Static code analysis and corrections
This commit is contained in:
Kristjan Komlosi
@@ -0,0 +1,252 @@
|
||||
"""
|
||||
=====================================
|
||||
Sparse matrices (:mod:`scipy.sparse`)
|
||||
=====================================
|
||||
|
||||
.. currentmodule:: scipy.sparse
|
||||
|
||||
SciPy 2-D sparse matrix package for numeric data.
|
||||
|
||||
Contents
|
||||
========
|
||||
|
||||
Sparse matrix classes
|
||||
---------------------
|
||||
|
||||
.. autosummary::
|
||||
:toctree: generated/
|
||||
|
||||
bsr_matrix - Block Sparse Row matrix
|
||||
coo_matrix - A sparse matrix in COOrdinate format
|
||||
csc_matrix - Compressed Sparse Column matrix
|
||||
csr_matrix - Compressed Sparse Row matrix
|
||||
dia_matrix - Sparse matrix with DIAgonal storage
|
||||
dok_matrix - Dictionary Of Keys based sparse matrix
|
||||
lil_matrix - Row-based linked list sparse matrix
|
||||
spmatrix - Sparse matrix base class
|
||||
|
||||
Functions
|
||||
---------
|
||||
|
||||
Building sparse matrices:
|
||||
|
||||
.. autosummary::
|
||||
:toctree: generated/
|
||||
|
||||
eye - Sparse MxN matrix whose k-th diagonal is all ones
|
||||
identity - Identity matrix in sparse format
|
||||
kron - kronecker product of two sparse matrices
|
||||
kronsum - kronecker sum of sparse matrices
|
||||
diags - Return a sparse matrix from diagonals
|
||||
spdiags - Return a sparse matrix from diagonals
|
||||
block_diag - Build a block diagonal sparse matrix
|
||||
tril - Lower triangular portion of a matrix in sparse format
|
||||
triu - Upper triangular portion of a matrix in sparse format
|
||||
bmat - Build a sparse matrix from sparse sub-blocks
|
||||
hstack - Stack sparse matrices horizontally (column wise)
|
||||
vstack - Stack sparse matrices vertically (row wise)
|
||||
rand - Random values in a given shape
|
||||
random - Random values in a given shape
|
||||
|
||||
Save and load sparse matrices:
|
||||
|
||||
.. autosummary::
|
||||
:toctree: generated/
|
||||
|
||||
save_npz - Save a sparse matrix to a file using ``.npz`` format.
|
||||
load_npz - Load a sparse matrix from a file using ``.npz`` format.
|
||||
|
||||
Sparse matrix tools:
|
||||
|
||||
.. autosummary::
|
||||
:toctree: generated/
|
||||
|
||||
find
|
||||
|
||||
Identifying sparse matrices:
|
||||
|
||||
.. autosummary::
|
||||
:toctree: generated/
|
||||
|
||||
issparse
|
||||
isspmatrix
|
||||
isspmatrix_csc
|
||||
isspmatrix_csr
|
||||
isspmatrix_bsr
|
||||
isspmatrix_lil
|
||||
isspmatrix_dok
|
||||
isspmatrix_coo
|
||||
isspmatrix_dia
|
||||
|
||||
Submodules
|
||||
----------
|
||||
|
||||
.. autosummary::
|
||||
:toctree: generated/
|
||||
|
||||
csgraph - Compressed sparse graph routines
|
||||
linalg - sparse linear algebra routines
|
||||
|
||||
Exceptions
|
||||
----------
|
||||
|
||||
.. autosummary::
|
||||
:toctree: generated/
|
||||
|
||||
SparseEfficiencyWarning
|
||||
SparseWarning
|
||||
|
||||
|
||||
Usage information
|
||||
=================
|
||||
|
||||
There are seven available sparse matrix types:
|
||||
|
||||
1. csc_matrix: Compressed Sparse Column format
|
||||
2. csr_matrix: Compressed Sparse Row format
|
||||
3. bsr_matrix: Block Sparse Row format
|
||||
4. lil_matrix: List of Lists format
|
||||
5. dok_matrix: Dictionary of Keys format
|
||||
6. coo_matrix: COOrdinate format (aka IJV, triplet format)
|
||||
7. dia_matrix: DIAgonal format
|
||||
|
||||
To construct a matrix efficiently, use either dok_matrix or lil_matrix.
|
||||
The lil_matrix class supports basic slicing and fancy indexing with a
|
||||
similar syntax to NumPy arrays. As illustrated below, the COO format
|
||||
may also be used to efficiently construct matrices. Despite their
|
||||
similarity to NumPy arrays, it is **strongly discouraged** to use NumPy
|
||||
functions directly on these matrices because NumPy may not properly convert
|
||||
them for computations, leading to unexpected (and incorrect) results. If you
|
||||
do want to apply a NumPy function to these matrices, first check if SciPy has
|
||||
its own implementation for the given sparse matrix class, or **convert the
|
||||
sparse matrix to a NumPy array** (e.g. using the `toarray()` method of the
|
||||
class) first before applying the method.
|
||||
|
||||
To perform manipulations such as multiplication or inversion, first
|
||||
convert the matrix to either CSC or CSR format. The lil_matrix format is
|
||||
row-based, so conversion to CSR is efficient, whereas conversion to CSC
|
||||
is less so.
|
||||
|
||||
All conversions among the CSR, CSC, and COO formats are efficient,
|
||||
linear-time operations.
|
||||
|
||||
Matrix vector product
|
||||
---------------------
|
||||
To do a vector product between a sparse matrix and a vector simply use
|
||||
the matrix `dot` method, as described in its docstring:
|
||||
|
||||
>>> import numpy as np
|
||||
>>> from scipy.sparse import csr_matrix
|
||||
>>> A = csr_matrix([[1, 2, 0], [0, 0, 3], [4, 0, 5]])
|
||||
>>> v = np.array([1, 0, -1])
|
||||
>>> A.dot(v)
|
||||
array([ 1, -3, -1], dtype=int64)
|
||||
|
||||
.. warning:: As of NumPy 1.7, `np.dot` is not aware of sparse matrices,
|
||||
therefore using it will result on unexpected results or errors.
|
||||
The corresponding dense array should be obtained first instead:
|
||||
|
||||
>>> np.dot(A.toarray(), v)
|
||||
array([ 1, -3, -1], dtype=int64)
|
||||
|
||||
but then all the performance advantages would be lost.
|
||||
|
||||
The CSR format is specially suitable for fast matrix vector products.
|
||||
|
||||
Example 1
|
||||
---------
|
||||
Construct a 1000x1000 lil_matrix and add some values to it:
|
||||
|
||||
>>> from scipy.sparse import lil_matrix
|
||||
>>> from scipy.sparse.linalg import spsolve
|
||||
>>> from numpy.linalg import solve, norm
|
||||
>>> from numpy.random import rand
|
||||
|
||||
>>> A = lil_matrix((1000, 1000))
|
||||
>>> A[0, :100] = rand(100)
|
||||
>>> A[1, 100:200] = A[0, :100]
|
||||
>>> A.setdiag(rand(1000))
|
||||
|
||||
Now convert it to CSR format and solve A x = b for x:
|
||||
|
||||
>>> A = A.tocsr()
|
||||
>>> b = rand(1000)
|
||||
>>> x = spsolve(A, b)
|
||||
|
||||
Convert it to a dense matrix and solve, and check that the result
|
||||
is the same:
|
||||
|
||||
>>> x_ = solve(A.toarray(), b)
|
||||
|
||||
Now we can compute norm of the error with:
|
||||
|
||||
>>> err = norm(x-x_)
|
||||
>>> err < 1e-10
|
||||
True
|
||||
|
||||
It should be small :)
|
||||
|
||||
|
||||
Example 2
|
||||
---------
|
||||
|
||||
Construct a matrix in COO format:
|
||||
|
||||
>>> from scipy import sparse
|
||||
>>> from numpy import array
|
||||
>>> I = array([0,3,1,0])
|
||||
>>> J = array([0,3,1,2])
|
||||
>>> V = array([4,5,7,9])
|
||||
>>> A = sparse.coo_matrix((V,(I,J)),shape=(4,4))
|
||||
|
||||
Notice that the indices do not need to be sorted.
|
||||
|
||||
Duplicate (i,j) entries are summed when converting to CSR or CSC.
|
||||
|
||||
>>> I = array([0,0,1,3,1,0,0])
|
||||
>>> J = array([0,2,1,3,1,0,0])
|
||||
>>> V = array([1,1,1,1,1,1,1])
|
||||
>>> B = sparse.coo_matrix((V,(I,J)),shape=(4,4)).tocsr()
|
||||
|
||||
This is useful for constructing finite-element stiffness and mass matrices.
|
||||
|
||||
Further Details
|
||||
---------------
|
||||
|
||||
CSR column indices are not necessarily sorted. Likewise for CSC row
|
||||
indices. Use the .sorted_indices() and .sort_indices() methods when
|
||||
sorted indices are required (e.g. when passing data to other libraries).
|
||||
|
||||
"""
|
||||
|
||||
from __future__ import division, print_function, absolute_import
|
||||
|
||||
# Original code by Travis Oliphant.
|
||||
# Modified and extended by Ed Schofield, Robert Cimrman,
|
||||
# Nathan Bell, and Jake Vanderplas.
|
||||
|
||||
import warnings as _warnings
|
||||
|
||||
from .base import *
|
||||
from .csr import *
|
||||
from .csc import *
|
||||
from .lil import *
|
||||
from .dok import *
|
||||
from .coo import *
|
||||
from .dia import *
|
||||
from .bsr import *
|
||||
from .construct import *
|
||||
from .extract import *
|
||||
from ._matrix_io import *
|
||||
|
||||
# For backward compatibility with v0.19.
|
||||
from . import csgraph
|
||||
|
||||
__all__ = [s for s in dir() if not s.startswith('_')]
|
||||
|
||||
# Filter PendingDeprecationWarning for np.matrix introduced with numpy 1.15
|
||||
_warnings.filterwarnings('ignore', message='the matrix subclass is not the recommended way')
|
||||
|
||||
from scipy._lib._testutils import PytestTester
|
||||
test = PytestTester(__name__)
|
||||
del PytestTester
|
||||
BIN
Binary file not shown.
BIN
Binary file not shown.
Binary file not shown.
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
Binary file not shown.
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
@@ -0,0 +1,157 @@
|
||||
from __future__ import division, print_function, absolute_import
|
||||
|
||||
import sys
|
||||
import numpy as np
|
||||
import scipy.sparse
|
||||
|
||||
from scipy._lib._version import NumpyVersion
|
||||
|
||||
__all__ = ['save_npz', 'load_npz']
|
||||
|
||||
|
||||
if NumpyVersion(np.__version__) >= '1.10.0':
|
||||
# Make loading safe vs. malicious input
|
||||
PICKLE_KWARGS = dict(allow_pickle=False)
|
||||
else:
|
||||
PICKLE_KWARGS = dict()
|
||||
|
||||
|
||||
def save_npz(file, matrix, compressed=True):
|
||||
""" Save a sparse matrix to a file using ``.npz`` format.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
file : str or file-like object
|
||||
Either the file name (string) or an open file (file-like object)
|
||||
where the data will be saved. If file is a string, the ``.npz``
|
||||
extension will be appended to the file name if it is not already
|
||||
there.
|
||||
matrix: spmatrix (format: ``csc``, ``csr``, ``bsr``, ``dia`` or coo``)
|
||||
The sparse matrix to save.
|
||||
compressed : bool, optional
|
||||
Allow compressing the file. Default: True
|
||||
|
||||
See Also
|
||||
--------
|
||||
scipy.sparse.load_npz: Load a sparse matrix from a file using ``.npz`` format.
|
||||
numpy.savez: Save several arrays into a ``.npz`` archive.
|
||||
numpy.savez_compressed : Save 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]]))
|
||||
>>> sparse_matrix
|
||||
<2x3 sparse matrix of type '<class 'numpy.int64'>'
|
||||
with 2 stored elements in Compressed Sparse Column format>
|
||||
>>> sparse_matrix.todense()
|
||||
matrix([[0, 0, 3],
|
||||
[4, 0, 0]], dtype=int64)
|
||||
|
||||
>>> scipy.sparse.save_npz('/tmp/sparse_matrix.npz', sparse_matrix)
|
||||
>>> sparse_matrix = scipy.sparse.load_npz('/tmp/sparse_matrix.npz')
|
||||
|
||||
>>> sparse_matrix
|
||||
<2x3 sparse matrix of type '<class 'numpy.int64'>'
|
||||
with 2 stored elements in Compressed Sparse Column format>
|
||||
>>> sparse_matrix.todense()
|
||||
matrix([[0, 0, 3],
|
||||
[4, 0, 0]], dtype=int64)
|
||||
"""
|
||||
arrays_dict = {}
|
||||
if matrix.format in ('csc', 'csr', 'bsr'):
|
||||
arrays_dict.update(indices=matrix.indices, indptr=matrix.indptr)
|
||||
elif matrix.format == 'dia':
|
||||
arrays_dict.update(offsets=matrix.offsets)
|
||||
elif matrix.format == 'coo':
|
||||
arrays_dict.update(row=matrix.row, col=matrix.col)
|
||||
else:
|
||||
raise NotImplementedError('Save is not implemented for sparse matrix of format {}.'.format(matrix.format))
|
||||
arrays_dict.update(
|
||||
format=matrix.format.encode('ascii'),
|
||||
shape=matrix.shape,
|
||||
data=matrix.data
|
||||
)
|
||||
if compressed:
|
||||
np.savez_compressed(file, **arrays_dict)
|
||||
else:
|
||||
np.savez(file, **arrays_dict)
|
||||
|
||||
|
||||
def load_npz(file):
|
||||
""" Load a sparse matrix from a file using ``.npz`` format.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
file : str or file-like object
|
||||
Either the file name (string) or an open file (file-like object)
|
||||
where the data will be loaded.
|
||||
|
||||
Returns
|
||||
-------
|
||||
result : csc_matrix, csr_matrix, bsr_matrix, dia_matrix or coo_matrix
|
||||
A sparse matrix containing the loaded data.
|
||||
|
||||
Raises
|
||||
------
|
||||
IOError
|
||||
If the input file does not exist or cannot be read.
|
||||
|
||||
See Also
|
||||
--------
|
||||
scipy.sparse.save_npz: Save a sparse matrix to a file using ``.npz`` format.
|
||||
numpy.load: Load 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]]))
|
||||
>>> sparse_matrix
|
||||
<2x3 sparse matrix of type '<class 'numpy.int64'>'
|
||||
with 2 stored elements in Compressed Sparse Column format>
|
||||
>>> sparse_matrix.todense()
|
||||
matrix([[0, 0, 3],
|
||||
[4, 0, 0]], dtype=int64)
|
||||
|
||||
>>> scipy.sparse.save_npz('/tmp/sparse_matrix.npz', sparse_matrix)
|
||||
>>> sparse_matrix = scipy.sparse.load_npz('/tmp/sparse_matrix.npz')
|
||||
|
||||
>>> sparse_matrix
|
||||
<2x3 sparse matrix of type '<class 'numpy.int64'>'
|
||||
with 2 stored elements in Compressed Sparse Column format>
|
||||
>>> sparse_matrix.todense()
|
||||
matrix([[0, 0, 3],
|
||||
[4, 0, 0]], dtype=int64)
|
||||
"""
|
||||
|
||||
with np.load(file, **PICKLE_KWARGS) as loaded:
|
||||
try:
|
||||
matrix_format = loaded['format']
|
||||
except KeyError:
|
||||
raise ValueError('The file {} does not contain a sparse matrix.'.format(file))
|
||||
|
||||
matrix_format = matrix_format.item()
|
||||
|
||||
if sys.version_info[0] >= 3 and not isinstance(matrix_format, str):
|
||||
# Play safe with Python 2 vs 3 backward compatibility;
|
||||
# files saved with Scipy < 1.0.0 may contain unicode or bytes.
|
||||
matrix_format = matrix_format.decode('ascii')
|
||||
|
||||
try:
|
||||
cls = getattr(scipy.sparse, '{}_matrix'.format(matrix_format))
|
||||
except AttributeError:
|
||||
raise ValueError('Unknown matrix format "{}"'.format(matrix_format))
|
||||
|
||||
if matrix_format in ('csc', 'csr', 'bsr'):
|
||||
return cls((loaded['data'], loaded['indices'], loaded['indptr']), shape=loaded['shape'])
|
||||
elif matrix_format == 'dia':
|
||||
return cls((loaded['data'], loaded['offsets']), shape=loaded['shape'])
|
||||
elif matrix_format == 'coo':
|
||||
return cls((loaded['data'], (loaded['row'], loaded['col'])), shape=loaded['shape'])
|
||||
else:
|
||||
raise NotImplementedError('Load is not implemented for '
|
||||
'sparse matrix of format {}.'.format(matrix_format))
|
||||
BIN
Binary file not shown.
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,721 @@
|
||||
"""Compressed Block Sparse Row matrix format"""
|
||||
from __future__ import division, print_function, absolute_import
|
||||
|
||||
|
||||
__docformat__ = "restructuredtext en"
|
||||
|
||||
__all__ = ['bsr_matrix', 'isspmatrix_bsr']
|
||||
|
||||
from warnings import warn
|
||||
|
||||
import numpy as np
|
||||
|
||||
from .data import _data_matrix, _minmax_mixin
|
||||
from .compressed import _cs_matrix
|
||||
from .base import isspmatrix, _formats, spmatrix
|
||||
from .sputils import (isshape, getdtype, to_native, upcast, get_index_dtype,
|
||||
check_shape)
|
||||
from . import _sparsetools
|
||||
from ._sparsetools import (bsr_matvec, bsr_matvecs, csr_matmat_pass1,
|
||||
bsr_matmat_pass2, bsr_transpose, bsr_sort_indices,
|
||||
bsr_tocsr)
|
||||
|
||||
|
||||
class bsr_matrix(_cs_matrix, _minmax_mixin):
|
||||
"""Block Sparse Row matrix
|
||||
|
||||
This can be instantiated in several ways:
|
||||
bsr_matrix(D, [blocksize=(R,C)])
|
||||
where D is a dense matrix or 2-D ndarray.
|
||||
|
||||
bsr_matrix(S, [blocksize=(R,C)])
|
||||
with another sparse matrix S (equivalent to S.tobsr())
|
||||
|
||||
bsr_matrix((M, N), [blocksize=(R,C), dtype])
|
||||
to construct an empty matrix with shape (M, N)
|
||||
dtype is optional, defaulting to dtype='d'.
|
||||
|
||||
bsr_matrix((data, ij), [blocksize=(R,C), shape=(M, N)])
|
||||
where ``data`` and ``ij`` satisfy ``a[ij[0, k], ij[1, k]] = data[k]``
|
||||
|
||||
bsr_matrix((data, indices, indptr), [shape=(M, N)])
|
||||
is the standard BSR representation where the block column
|
||||
indices for row i are stored in ``indices[indptr[i]:indptr[i+1]]``
|
||||
and their corresponding block values are stored in
|
||||
``data[ indptr[i]: indptr[i+1] ]``. If the shape parameter is not
|
||||
supplied, the matrix dimensions are inferred from the index arrays.
|
||||
|
||||
Attributes
|
||||
----------
|
||||
dtype : dtype
|
||||
Data type of the matrix
|
||||
shape : 2-tuple
|
||||
Shape of the matrix
|
||||
ndim : int
|
||||
Number of dimensions (this is always 2)
|
||||
nnz
|
||||
Number of nonzero elements
|
||||
data
|
||||
Data array of the matrix
|
||||
indices
|
||||
BSR format index array
|
||||
indptr
|
||||
BSR format index pointer array
|
||||
blocksize
|
||||
Block size of the matrix
|
||||
has_sorted_indices
|
||||
Whether indices are sorted
|
||||
|
||||
Notes
|
||||
-----
|
||||
Sparse matrices can be used in arithmetic operations: they support
|
||||
addition, subtraction, multiplication, division, and matrix power.
|
||||
|
||||
**Summary of BSR format**
|
||||
|
||||
The Block Compressed Row (BSR) format is very similar to the Compressed
|
||||
Sparse Row (CSR) format. BSR is appropriate for sparse matrices with dense
|
||||
sub matrices like the last example below. Block matrices often arise in
|
||||
vector-valued finite element discretizations. In such cases, BSR is
|
||||
considerably more efficient than CSR and CSC for many sparse arithmetic
|
||||
operations.
|
||||
|
||||
**Blocksize**
|
||||
|
||||
The blocksize (R,C) must evenly divide the shape of the matrix (M,N).
|
||||
That is, R and C must satisfy the relationship ``M % R = 0`` and
|
||||
``N % C = 0``.
|
||||
|
||||
If no blocksize is specified, a simple heuristic is applied to determine
|
||||
an appropriate blocksize.
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> from scipy.sparse import bsr_matrix
|
||||
>>> bsr_matrix((3, 4), dtype=np.int8).toarray()
|
||||
array([[0, 0, 0, 0],
|
||||
[0, 0, 0, 0],
|
||||
[0, 0, 0, 0]], dtype=int8)
|
||||
|
||||
>>> row = np.array([0, 0, 1, 2, 2, 2])
|
||||
>>> col = np.array([0, 2, 2, 0, 1, 2])
|
||||
>>> data = np.array([1, 2, 3 ,4, 5, 6])
|
||||
>>> bsr_matrix((data, (row, col)), shape=(3, 3)).toarray()
|
||||
array([[1, 0, 2],
|
||||
[0, 0, 3],
|
||||
[4, 5, 6]])
|
||||
|
||||
>>> indptr = np.array([0, 2, 3, 6])
|
||||
>>> indices = np.array([0, 2, 2, 0, 1, 2])
|
||||
>>> data = np.array([1, 2, 3, 4, 5, 6]).repeat(4).reshape(6, 2, 2)
|
||||
>>> bsr_matrix((data,indices,indptr), shape=(6, 6)).toarray()
|
||||
array([[1, 1, 0, 0, 2, 2],
|
||||
[1, 1, 0, 0, 2, 2],
|
||||
[0, 0, 0, 0, 3, 3],
|
||||
[0, 0, 0, 0, 3, 3],
|
||||
[4, 4, 5, 5, 6, 6],
|
||||
[4, 4, 5, 5, 6, 6]])
|
||||
|
||||
"""
|
||||
format = 'bsr'
|
||||
|
||||
def __init__(self, arg1, shape=None, dtype=None, copy=False, blocksize=None):
|
||||
_data_matrix.__init__(self)
|
||||
|
||||
if isspmatrix(arg1):
|
||||
if isspmatrix_bsr(arg1) and copy:
|
||||
arg1 = arg1.copy()
|
||||
else:
|
||||
arg1 = arg1.tobsr(blocksize=blocksize)
|
||||
self._set_self(arg1)
|
||||
|
||||
elif isinstance(arg1,tuple):
|
||||
if isshape(arg1):
|
||||
# it's a tuple of matrix dimensions (M,N)
|
||||
self._shape = check_shape(arg1)
|
||||
M,N = self.shape
|
||||
# process blocksize
|
||||
if blocksize is None:
|
||||
blocksize = (1,1)
|
||||
else:
|
||||
if not isshape(blocksize):
|
||||
raise ValueError('invalid blocksize=%s' % blocksize)
|
||||
blocksize = tuple(blocksize)
|
||||
self.data = np.zeros((0,) + blocksize, getdtype(dtype, default=float))
|
||||
|
||||
R,C = blocksize
|
||||
if (M % R) != 0 or (N % C) != 0:
|
||||
raise ValueError('shape must be multiple of blocksize')
|
||||
|
||||
# Select index dtype large enough to pass array and
|
||||
# scalar parameters to sparsetools
|
||||
idx_dtype = get_index_dtype(maxval=max(M//R, N//C, R, C))
|
||||
self.indices = np.zeros(0, dtype=idx_dtype)
|
||||
self.indptr = np.zeros(M//R + 1, dtype=idx_dtype)
|
||||
|
||||
elif len(arg1) == 2:
|
||||
# (data,(row,col)) format
|
||||
from .coo import coo_matrix
|
||||
self._set_self(coo_matrix(arg1, dtype=dtype).tobsr(blocksize=blocksize))
|
||||
|
||||
elif len(arg1) == 3:
|
||||
# (data,indices,indptr) format
|
||||
(data, indices, indptr) = arg1
|
||||
|
||||
# Select index dtype large enough to pass array and
|
||||
# scalar parameters to sparsetools
|
||||
maxval = 1
|
||||
if shape is not None:
|
||||
maxval = max(shape)
|
||||
if blocksize is not None:
|
||||
maxval = max(maxval, max(blocksize))
|
||||
idx_dtype = get_index_dtype((indices, indptr), maxval=maxval, check_contents=True)
|
||||
|
||||
self.indices = np.array(indices, copy=copy, dtype=idx_dtype)
|
||||
self.indptr = np.array(indptr, copy=copy, dtype=idx_dtype)
|
||||
self.data = np.array(data, copy=copy, dtype=getdtype(dtype, data))
|
||||
else:
|
||||
raise ValueError('unrecognized bsr_matrix constructor usage')
|
||||
else:
|
||||
# must be dense
|
||||
try:
|
||||
arg1 = np.asarray(arg1)
|
||||
except Exception:
|
||||
raise ValueError("unrecognized form for"
|
||||
" %s_matrix constructor" % self.format)
|
||||
from .coo import coo_matrix
|
||||
arg1 = coo_matrix(arg1, dtype=dtype).tobsr(blocksize=blocksize)
|
||||
self._set_self(arg1)
|
||||
|
||||
if shape is not None:
|
||||
self._shape = check_shape(shape)
|
||||
else:
|
||||
if self.shape is None:
|
||||
# shape not already set, try to infer dimensions
|
||||
try:
|
||||
M = len(self.indptr) - 1
|
||||
N = self.indices.max() + 1
|
||||
except Exception:
|
||||
raise ValueError('unable to infer matrix dimensions')
|
||||
else:
|
||||
R,C = self.blocksize
|
||||
self._shape = check_shape((M*R,N*C))
|
||||
|
||||
if self.shape is None:
|
||||
if shape is None:
|
||||
# TODO infer shape here
|
||||
raise ValueError('need to infer shape')
|
||||
else:
|
||||
self._shape = check_shape(shape)
|
||||
|
||||
if dtype is not None:
|
||||
self.data = self.data.astype(dtype)
|
||||
|
||||
self.check_format(full_check=False)
|
||||
|
||||
def check_format(self, full_check=True):
|
||||
"""check whether the matrix format is valid
|
||||
|
||||
*Parameters*:
|
||||
full_check:
|
||||
True - rigorous check, O(N) operations : default
|
||||
False - basic check, O(1) operations
|
||||
|
||||
"""
|
||||
M,N = self.shape
|
||||
R,C = self.blocksize
|
||||
|
||||
# index arrays should have integer data types
|
||||
if self.indptr.dtype.kind != 'i':
|
||||
warn("indptr array has non-integer dtype (%s)"
|
||||
% self.indptr.dtype.name)
|
||||
if self.indices.dtype.kind != 'i':
|
||||
warn("indices array has non-integer dtype (%s)"
|
||||
% self.indices.dtype.name)
|
||||
|
||||
idx_dtype = get_index_dtype((self.indices, self.indptr))
|
||||
self.indptr = np.asarray(self.indptr, dtype=idx_dtype)
|
||||
self.indices = np.asarray(self.indices, dtype=idx_dtype)
|
||||
self.data = to_native(self.data)
|
||||
|
||||
# check array shapes
|
||||
if self.indices.ndim != 1 or self.indptr.ndim != 1:
|
||||
raise ValueError("indices, and indptr should be 1-D")
|
||||
if self.data.ndim != 3:
|
||||
raise ValueError("data should be 3-D")
|
||||
|
||||
# check index pointer
|
||||
if (len(self.indptr) != M//R + 1):
|
||||
raise ValueError("index pointer size (%d) should be (%d)" %
|
||||
(len(self.indptr), M//R + 1))
|
||||
if (self.indptr[0] != 0):
|
||||
raise ValueError("index pointer should start with 0")
|
||||
|
||||
# check index and data arrays
|
||||
if (len(self.indices) != len(self.data)):
|
||||
raise ValueError("indices and data should have the same size")
|
||||
if (self.indptr[-1] > len(self.indices)):
|
||||
raise ValueError("Last value of index pointer should be less than "
|
||||
"the size of index and data arrays")
|
||||
|
||||
self.prune()
|
||||
|
||||
if full_check:
|
||||
# check format validity (more expensive)
|
||||
if self.nnz > 0:
|
||||
if self.indices.max() >= N//C:
|
||||
raise ValueError("column index values must be < %d (now max %d)" % (N//C, self.indices.max()))
|
||||
if self.indices.min() < 0:
|
||||
raise ValueError("column index values must be >= 0")
|
||||
if np.diff(self.indptr).min() < 0:
|
||||
raise ValueError("index pointer values must form a "
|
||||
"non-decreasing sequence")
|
||||
|
||||
# if not self.has_sorted_indices():
|
||||
# warn('Indices were not in sorted order. Sorting indices.')
|
||||
# self.sort_indices(check_first=False)
|
||||
|
||||
def _get_blocksize(self):
|
||||
return self.data.shape[1:]
|
||||
blocksize = property(fget=_get_blocksize)
|
||||
|
||||
def getnnz(self, axis=None):
|
||||
if axis is not None:
|
||||
raise NotImplementedError("getnnz over an axis is not implemented "
|
||||
"for BSR format")
|
||||
R,C = self.blocksize
|
||||
return int(self.indptr[-1] * R * C)
|
||||
|
||||
getnnz.__doc__ = spmatrix.getnnz.__doc__
|
||||
|
||||
def __repr__(self):
|
||||
format = _formats[self.getformat()][1]
|
||||
return ("<%dx%d sparse matrix of type '%s'\n"
|
||||
"\twith %d stored elements (blocksize = %dx%d) in %s format>" %
|
||||
(self.shape + (self.dtype.type, self.nnz) + self.blocksize +
|
||||
(format,)))
|
||||
|
||||
def diagonal(self, k=0):
|
||||
rows, cols = self.shape
|
||||
if k <= -rows or k >= cols:
|
||||
raise ValueError("k exceeds matrix dimensions")
|
||||
R, C = self.blocksize
|
||||
y = np.zeros(min(rows + min(k, 0), cols - max(k, 0)),
|
||||
dtype=upcast(self.dtype))
|
||||
_sparsetools.bsr_diagonal(k, rows // R, cols // C, R, C,
|
||||
self.indptr, self.indices,
|
||||
np.ravel(self.data), y)
|
||||
return y
|
||||
|
||||
diagonal.__doc__ = spmatrix.diagonal.__doc__
|
||||
|
||||
##########################
|
||||
# NotImplemented methods #
|
||||
##########################
|
||||
|
||||
def __getitem__(self,key):
|
||||
raise NotImplementedError
|
||||
|
||||
def __setitem__(self,key,val):
|
||||
raise NotImplementedError
|
||||
|
||||
######################
|
||||
# Arithmetic methods #
|
||||
######################
|
||||
|
||||
@np.deprecate(message="BSR matvec is deprecated in scipy 0.19.0. "
|
||||
"Use * operator instead.")
|
||||
def matvec(self, other):
|
||||
"""Multiply matrix by vector."""
|
||||
return self * other
|
||||
|
||||
@np.deprecate(message="BSR matmat is deprecated in scipy 0.19.0. "
|
||||
"Use * operator instead.")
|
||||
def matmat(self, other):
|
||||
"""Multiply this sparse matrix by other matrix."""
|
||||
return self * other
|
||||
|
||||
def _add_dense(self, other):
|
||||
return self.tocoo(copy=False)._add_dense(other)
|
||||
|
||||
def _mul_vector(self, other):
|
||||
M,N = self.shape
|
||||
R,C = self.blocksize
|
||||
|
||||
result = np.zeros(self.shape[0], dtype=upcast(self.dtype, other.dtype))
|
||||
|
||||
bsr_matvec(M//R, N//C, R, C,
|
||||
self.indptr, self.indices, self.data.ravel(),
|
||||
other, result)
|
||||
|
||||
return result
|
||||
|
||||
def _mul_multivector(self,other):
|
||||
R,C = self.blocksize
|
||||
M,N = self.shape
|
||||
n_vecs = other.shape[1] # number of column vectors
|
||||
|
||||
result = np.zeros((M,n_vecs), dtype=upcast(self.dtype,other.dtype))
|
||||
|
||||
bsr_matvecs(M//R, N//C, n_vecs, R, C,
|
||||
self.indptr, self.indices, self.data.ravel(),
|
||||
other.ravel(), result.ravel())
|
||||
|
||||
return result
|
||||
|
||||
def _mul_sparse_matrix(self, other):
|
||||
M, K1 = self.shape
|
||||
K2, N = other.shape
|
||||
|
||||
R,n = self.blocksize
|
||||
|
||||
# convert to this format
|
||||
if isspmatrix_bsr(other):
|
||||
C = other.blocksize[1]
|
||||
else:
|
||||
C = 1
|
||||
|
||||
from .csr import isspmatrix_csr
|
||||
|
||||
if isspmatrix_csr(other) and n == 1:
|
||||
other = other.tobsr(blocksize=(n,C), copy=False) # lightweight conversion
|
||||
else:
|
||||
other = other.tobsr(blocksize=(n,C))
|
||||
|
||||
idx_dtype = get_index_dtype((self.indptr, self.indices,
|
||||
other.indptr, other.indices),
|
||||
maxval=(M//R)*(N//C))
|
||||
indptr = np.empty(self.indptr.shape, dtype=idx_dtype)
|
||||
|
||||
csr_matmat_pass1(M//R, N//C,
|
||||
self.indptr.astype(idx_dtype),
|
||||
self.indices.astype(idx_dtype),
|
||||
other.indptr.astype(idx_dtype),
|
||||
other.indices.astype(idx_dtype),
|
||||
indptr)
|
||||
|
||||
bnnz = indptr[-1]
|
||||
|
||||
idx_dtype = get_index_dtype((self.indptr, self.indices,
|
||||
other.indptr, other.indices),
|
||||
maxval=bnnz)
|
||||
indptr = indptr.astype(idx_dtype)
|
||||
indices = np.empty(bnnz, dtype=idx_dtype)
|
||||
data = np.empty(R*C*bnnz, dtype=upcast(self.dtype,other.dtype))
|
||||
|
||||
bsr_matmat_pass2(M//R, N//C, R, C, n,
|
||||
self.indptr.astype(idx_dtype),
|
||||
self.indices.astype(idx_dtype),
|
||||
np.ravel(self.data),
|
||||
other.indptr.astype(idx_dtype),
|
||||
other.indices.astype(idx_dtype),
|
||||
np.ravel(other.data),
|
||||
indptr,
|
||||
indices,
|
||||
data)
|
||||
|
||||
data = data.reshape(-1,R,C)
|
||||
|
||||
# TODO eliminate zeros
|
||||
|
||||
return bsr_matrix((data,indices,indptr),shape=(M,N),blocksize=(R,C))
|
||||
|
||||
######################
|
||||
# Conversion methods #
|
||||
######################
|
||||
|
||||
def tobsr(self, blocksize=None, copy=False):
|
||||
"""Convert this matrix into Block Sparse Row Format.
|
||||
|
||||
With copy=False, the data/indices may be shared between this
|
||||
matrix and the resultant bsr_matrix.
|
||||
|
||||
If blocksize=(R, C) is provided, it will be used for determining
|
||||
block size of the bsr_matrix.
|
||||
"""
|
||||
if blocksize not in [None, self.blocksize]:
|
||||
return self.tocsr().tobsr(blocksize=blocksize)
|
||||
if copy:
|
||||
return self.copy()
|
||||
else:
|
||||
return self
|
||||
|
||||
def tocsr(self, copy=False):
|
||||
M, N = self.shape
|
||||
R, C = self.blocksize
|
||||
nnz = self.nnz
|
||||
idx_dtype = get_index_dtype((self.indptr, self.indices),
|
||||
maxval=max(nnz, N))
|
||||
indptr = np.empty(M + 1, dtype=idx_dtype)
|
||||
indices = np.empty(nnz, dtype=idx_dtype)
|
||||
data = np.empty(nnz, dtype=upcast(self.dtype))
|
||||
|
||||
bsr_tocsr(M // R, # n_brow
|
||||
N // C, # n_bcol
|
||||
R, C,
|
||||
self.indptr.astype(idx_dtype, copy=False),
|
||||
self.indices.astype(idx_dtype, copy=False),
|
||||
self.data,
|
||||
indptr,
|
||||
indices,
|
||||
data)
|
||||
from .csr import csr_matrix
|
||||
return csr_matrix((data, indices, indptr), shape=self.shape)
|
||||
|
||||
tocsr.__doc__ = spmatrix.tocsr.__doc__
|
||||
|
||||
def tocsc(self, copy=False):
|
||||
return self.tocsr(copy=False).tocsc(copy=copy)
|
||||
|
||||
tocsc.__doc__ = spmatrix.tocsc.__doc__
|
||||
|
||||
def tocoo(self, copy=True):
|
||||
"""Convert this matrix to COOrdinate format.
|
||||
|
||||
When copy=False the data array will be shared between
|
||||
this matrix and the resultant coo_matrix.
|
||||
"""
|
||||
|
||||
M,N = self.shape
|
||||
R,C = self.blocksize
|
||||
|
||||
indptr_diff = np.diff(self.indptr)
|
||||
if indptr_diff.dtype.itemsize > np.dtype(np.intp).itemsize:
|
||||
# Check for potential overflow
|
||||
indptr_diff_limited = indptr_diff.astype(np.intp)
|
||||
if np.any(indptr_diff_limited != indptr_diff):
|
||||
raise ValueError("Matrix too big to convert")
|
||||
indptr_diff = indptr_diff_limited
|
||||
|
||||
row = (R * np.arange(M//R)).repeat(indptr_diff)
|
||||
row = row.repeat(R*C).reshape(-1,R,C)
|
||||
row += np.tile(np.arange(R).reshape(-1,1), (1,C))
|
||||
row = row.reshape(-1)
|
||||
|
||||
col = (C * self.indices).repeat(R*C).reshape(-1,R,C)
|
||||
col += np.tile(np.arange(C), (R,1))
|
||||
col = col.reshape(-1)
|
||||
|
||||
data = self.data.reshape(-1)
|
||||
|
||||
if copy:
|
||||
data = data.copy()
|
||||
|
||||
from .coo import coo_matrix
|
||||
return coo_matrix((data,(row,col)), shape=self.shape)
|
||||
|
||||
def toarray(self, order=None, out=None):
|
||||
return self.tocoo(copy=False).toarray(order=order, out=out)
|
||||
|
||||
toarray.__doc__ = spmatrix.toarray.__doc__
|
||||
|
||||
def transpose(self, axes=None, copy=False):
|
||||
if axes is not None:
|
||||
raise ValueError(("Sparse matrices do not support "
|
||||
"an 'axes' parameter because swapping "
|
||||
"dimensions is the only logical permutation."))
|
||||
|
||||
R, C = self.blocksize
|
||||
M, N = self.shape
|
||||
NBLK = self.nnz//(R*C)
|
||||
|
||||
if self.nnz == 0:
|
||||
return bsr_matrix((N, M), blocksize=(C, R),
|
||||
dtype=self.dtype, copy=copy)
|
||||
|
||||
indptr = np.empty(N//C + 1, dtype=self.indptr.dtype)
|
||||
indices = np.empty(NBLK, dtype=self.indices.dtype)
|
||||
data = np.empty((NBLK, C, R), dtype=self.data.dtype)
|
||||
|
||||
bsr_transpose(M//R, N//C, R, C,
|
||||
self.indptr, self.indices, self.data.ravel(),
|
||||
indptr, indices, data.ravel())
|
||||
|
||||
return bsr_matrix((data, indices, indptr),
|
||||
shape=(N, M), copy=copy)
|
||||
|
||||
transpose.__doc__ = spmatrix.transpose.__doc__
|
||||
|
||||
##############################################################
|
||||
# methods that examine or modify the internal data structure #
|
||||
##############################################################
|
||||
|
||||
def eliminate_zeros(self):
|
||||
"""Remove zero elements in-place."""
|
||||
R,C = self.blocksize
|
||||
M,N = self.shape
|
||||
|
||||
mask = (self.data != 0).reshape(-1,R*C).sum(axis=1) # nonzero blocks
|
||||
|
||||
nonzero_blocks = mask.nonzero()[0]
|
||||
|
||||
if len(nonzero_blocks) == 0:
|
||||
return # nothing to do
|
||||
|
||||
self.data[:len(nonzero_blocks)] = self.data[nonzero_blocks]
|
||||
|
||||
# modifies self.indptr and self.indices *in place*
|
||||
_sparsetools.csr_eliminate_zeros(M//R, N//C, self.indptr,
|
||||
self.indices, mask)
|
||||
self.prune()
|
||||
|
||||
def sum_duplicates(self):
|
||||
"""Eliminate duplicate matrix entries by adding them together
|
||||
|
||||
The is an *in place* operation
|
||||
"""
|
||||
if self.has_canonical_format:
|
||||
return
|
||||
self.sort_indices()
|
||||
R, C = self.blocksize
|
||||
M, N = self.shape
|
||||
|
||||
# port of _sparsetools.csr_sum_duplicates
|
||||
n_row = M // R
|
||||
nnz = 0
|
||||
row_end = 0
|
||||
for i in range(n_row):
|
||||
jj = row_end
|
||||
row_end = self.indptr[i+1]
|
||||
while jj < row_end:
|
||||
j = self.indices[jj]
|
||||
x = self.data[jj]
|
||||
jj += 1
|
||||
while jj < row_end and self.indices[jj] == j:
|
||||
x += self.data[jj]
|
||||
jj += 1
|
||||
self.indices[nnz] = j
|
||||
self.data[nnz] = x
|
||||
nnz += 1
|
||||
self.indptr[i+1] = nnz
|
||||
|
||||
self.prune() # nnz may have changed
|
||||
self.has_canonical_format = True
|
||||
|
||||
def sort_indices(self):
|
||||
"""Sort the indices of this matrix *in place*
|
||||
"""
|
||||
if self.has_sorted_indices:
|
||||
return
|
||||
|
||||
R,C = self.blocksize
|
||||
M,N = self.shape
|
||||
|
||||
bsr_sort_indices(M//R, N//C, R, C, self.indptr, self.indices, self.data.ravel())
|
||||
|
||||
self.has_sorted_indices = True
|
||||
|
||||
def prune(self):
|
||||
""" Remove empty space after all non-zero elements.
|
||||
"""
|
||||
|
||||
R,C = self.blocksize
|
||||
M,N = self.shape
|
||||
|
||||
if len(self.indptr) != M//R + 1:
|
||||
raise ValueError("index pointer has invalid length")
|
||||
|
||||
bnnz = self.indptr[-1]
|
||||
|
||||
if len(self.indices) < bnnz:
|
||||
raise ValueError("indices array has too few elements")
|
||||
if len(self.data) < bnnz:
|
||||
raise ValueError("data array has too few elements")
|
||||
|
||||
self.data = self.data[:bnnz]
|
||||
self.indices = self.indices[:bnnz]
|
||||
|
||||
# utility functions
|
||||
def _binopt(self, other, op, in_shape=None, out_shape=None):
|
||||
"""Apply the binary operation fn to two sparse matrices."""
|
||||
|
||||
# Ideally we'd take the GCDs of the blocksize dimensions
|
||||
# and explode self and other to match.
|
||||
other = self.__class__(other, blocksize=self.blocksize)
|
||||
|
||||
# e.g. bsr_plus_bsr, etc.
|
||||
fn = getattr(_sparsetools, self.format + op + self.format)
|
||||
|
||||
R,C = self.blocksize
|
||||
|
||||
max_bnnz = len(self.data) + len(other.data)
|
||||
idx_dtype = get_index_dtype((self.indptr, self.indices,
|
||||
other.indptr, other.indices),
|
||||
maxval=max_bnnz)
|
||||
indptr = np.empty(self.indptr.shape, dtype=idx_dtype)
|
||||
indices = np.empty(max_bnnz, dtype=idx_dtype)
|
||||
|
||||
bool_ops = ['_ne_', '_lt_', '_gt_', '_le_', '_ge_']
|
||||
if op in bool_ops:
|
||||
data = np.empty(R*C*max_bnnz, dtype=np.bool_)
|
||||
else:
|
||||
data = np.empty(R*C*max_bnnz, dtype=upcast(self.dtype,other.dtype))
|
||||
|
||||
fn(self.shape[0]//R, self.shape[1]//C, R, C,
|
||||
self.indptr.astype(idx_dtype),
|
||||
self.indices.astype(idx_dtype),
|
||||
self.data,
|
||||
other.indptr.astype(idx_dtype),
|
||||
other.indices.astype(idx_dtype),
|
||||
np.ravel(other.data),
|
||||
indptr,
|
||||
indices,
|
||||
data)
|
||||
|
||||
actual_bnnz = indptr[-1]
|
||||
indices = indices[:actual_bnnz]
|
||||
data = data[:R*C*actual_bnnz]
|
||||
|
||||
if actual_bnnz < max_bnnz/2:
|
||||
indices = indices.copy()
|
||||
data = data.copy()
|
||||
|
||||
data = data.reshape(-1,R,C)
|
||||
|
||||
return self.__class__((data, indices, indptr), shape=self.shape)
|
||||
|
||||
# needed by _data_matrix
|
||||
def _with_data(self,data,copy=True):
|
||||
"""Returns a matrix with the same sparsity structure as self,
|
||||
but with different data. By default the structure arrays
|
||||
(i.e. .indptr and .indices) are copied.
|
||||
"""
|
||||
if copy:
|
||||
return self.__class__((data,self.indices.copy(),self.indptr.copy()),
|
||||
shape=self.shape,dtype=data.dtype)
|
||||
else:
|
||||
return self.__class__((data,self.indices,self.indptr),
|
||||
shape=self.shape,dtype=data.dtype)
|
||||
|
||||
# # these functions are used by the parent class
|
||||
# # to remove redudancy between bsc_matrix and bsr_matrix
|
||||
# def _swap(self,x):
|
||||
# """swap the members of x if this is a column-oriented matrix
|
||||
# """
|
||||
# return (x[0],x[1])
|
||||
|
||||
|
||||
def isspmatrix_bsr(x):
|
||||
"""Is x of a bsr_matrix type?
|
||||
|
||||
Parameters
|
||||
----------
|
||||
x
|
||||
object to check for being a bsr matrix
|
||||
|
||||
Returns
|
||||
-------
|
||||
bool
|
||||
True if x is a bsr matrix, False otherwise
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> from scipy.sparse import bsr_matrix, isspmatrix_bsr
|
||||
>>> isspmatrix_bsr(bsr_matrix([[5]]))
|
||||
True
|
||||
|
||||
>>> from scipy.sparse import bsr_matrix, csr_matrix, isspmatrix_bsr
|
||||
>>> isspmatrix_bsr(csr_matrix([[5]]))
|
||||
False
|
||||
"""
|
||||
return isinstance(x, bsr_matrix)
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,842 @@
|
||||
"""Functions to construct sparse matrices
|
||||
"""
|
||||
from __future__ import division, print_function, absolute_import
|
||||
|
||||
__docformat__ = "restructuredtext en"
|
||||
|
||||
__all__ = ['spdiags', 'eye', 'identity', 'kron', 'kronsum',
|
||||
'hstack', 'vstack', 'bmat', 'rand', 'random', 'diags', 'block_diag']
|
||||
|
||||
|
||||
import numpy as np
|
||||
from scipy._lib._numpy_compat import get_randint
|
||||
|
||||
from scipy._lib.six import xrange
|
||||
|
||||
from .sputils import upcast, get_index_dtype, isscalarlike
|
||||
|
||||
from .csr import csr_matrix
|
||||
from .csc import csc_matrix
|
||||
from .bsr import bsr_matrix
|
||||
from .coo import coo_matrix
|
||||
from .dia import dia_matrix
|
||||
|
||||
from .base import issparse
|
||||
|
||||
|
||||
def spdiags(data, diags, m, n, format=None):
|
||||
"""
|
||||
Return a sparse matrix from diagonals.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
data : array_like
|
||||
matrix diagonals stored row-wise
|
||||
diags : diagonals to set
|
||||
- k = 0 the main diagonal
|
||||
- k > 0 the k-th upper diagonal
|
||||
- k < 0 the k-th lower diagonal
|
||||
m, n : int
|
||||
shape of the result
|
||||
format : str, optional
|
||||
Format of the result. By default (format=None) an appropriate sparse
|
||||
matrix format is returned. This choice is subject to change.
|
||||
|
||||
See Also
|
||||
--------
|
||||
diags : more convenient form of this function
|
||||
dia_matrix : the sparse DIAgonal format.
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> from scipy.sparse import spdiags
|
||||
>>> data = np.array([[1, 2, 3, 4], [1, 2, 3, 4], [1, 2, 3, 4]])
|
||||
>>> diags = np.array([0, -1, 2])
|
||||
>>> spdiags(data, diags, 4, 4).toarray()
|
||||
array([[1, 0, 3, 0],
|
||||
[1, 2, 0, 4],
|
||||
[0, 2, 3, 0],
|
||||
[0, 0, 3, 4]])
|
||||
|
||||
"""
|
||||
return dia_matrix((data, diags), shape=(m,n)).asformat(format)
|
||||
|
||||
|
||||
def diags(diagonals, offsets=0, shape=None, format=None, dtype=None):
|
||||
"""
|
||||
Construct a sparse matrix from diagonals.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
diagonals : sequence of array_like
|
||||
Sequence of arrays containing the matrix diagonals,
|
||||
corresponding to `offsets`.
|
||||
offsets : sequence of int or an int, optional
|
||||
Diagonals to set:
|
||||
- k = 0 the main diagonal (default)
|
||||
- k > 0 the k-th upper diagonal
|
||||
- k < 0 the k-th lower diagonal
|
||||
shape : tuple of int, optional
|
||||
Shape of the result. If omitted, a square matrix large enough
|
||||
to contain the diagonals is returned.
|
||||
format : {"dia", "csr", "csc", "lil", ...}, optional
|
||||
Matrix format of the result. By default (format=None) an
|
||||
appropriate sparse matrix format is returned. This choice is
|
||||
subject to change.
|
||||
dtype : dtype, optional
|
||||
Data type of the matrix.
|
||||
|
||||
See Also
|
||||
--------
|
||||
spdiags : construct matrix from diagonals
|
||||
|
||||
Notes
|
||||
-----
|
||||
This function differs from `spdiags` in the way it handles
|
||||
off-diagonals.
|
||||
|
||||
The result from `diags` is the sparse equivalent of::
|
||||
|
||||
np.diag(diagonals[0], offsets[0])
|
||||
+ ...
|
||||
+ np.diag(diagonals[k], offsets[k])
|
||||
|
||||
Repeated diagonal offsets are disallowed.
|
||||
|
||||
.. versionadded:: 0.11
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> from scipy.sparse import diags
|
||||
>>> diagonals = [[1, 2, 3, 4], [1, 2, 3], [1, 2]]
|
||||
>>> diags(diagonals, [0, -1, 2]).toarray()
|
||||
array([[1, 0, 1, 0],
|
||||
[1, 2, 0, 2],
|
||||
[0, 2, 3, 0],
|
||||
[0, 0, 3, 4]])
|
||||
|
||||
Broadcasting of scalars is supported (but shape needs to be
|
||||
specified):
|
||||
|
||||
>>> 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
|
||||
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.]])
|
||||
"""
|
||||
# if offsets is not a sequence, assume that there's only one diagonal
|
||||
if isscalarlike(offsets):
|
||||
# now check that there's actually only one diagonal
|
||||
if len(diagonals) == 0 or isscalarlike(diagonals[0]):
|
||||
diagonals = [np.atleast_1d(diagonals)]
|
||||
else:
|
||||
raise ValueError("Different number of diagonals and offsets.")
|
||||
else:
|
||||
diagonals = list(map(np.atleast_1d, diagonals))
|
||||
|
||||
offsets = np.atleast_1d(offsets)
|
||||
|
||||
# Basic check
|
||||
if len(diagonals) != len(offsets):
|
||||
raise ValueError("Different number of diagonals and offsets.")
|
||||
|
||||
# Determine shape, if omitted
|
||||
if shape is None:
|
||||
m = len(diagonals[0]) + abs(int(offsets[0]))
|
||||
shape = (m, m)
|
||||
|
||||
# Determine data type, if omitted
|
||||
if dtype is None:
|
||||
dtype = np.common_type(*diagonals)
|
||||
|
||||
# Construct data array
|
||||
m, n = shape
|
||||
|
||||
M = max([min(m + offset, n - offset) + max(0, offset)
|
||||
for offset in offsets])
|
||||
M = max(0, M)
|
||||
data_arr = np.zeros((len(offsets), M), dtype=dtype)
|
||||
|
||||
K = min(m, n)
|
||||
|
||||
for j, diagonal in enumerate(diagonals):
|
||||
offset = offsets[j]
|
||||
k = max(0, offset)
|
||||
length = min(m + offset, n - offset, K)
|
||||
if length < 0:
|
||||
raise ValueError("Offset %d (index %d) out of bounds" % (offset, j))
|
||||
try:
|
||||
data_arr[j, k:k+length] = diagonal[...,:length]
|
||||
except ValueError:
|
||||
if len(diagonal) != length and len(diagonal) != 1:
|
||||
raise ValueError(
|
||||
"Diagonal length (index %d: %d at offset %d) does not "
|
||||
"agree with matrix size (%d, %d)." % (
|
||||
j, len(diagonal), offset, m, n))
|
||||
raise
|
||||
|
||||
return dia_matrix((data_arr, offsets), shape=(m, n)).asformat(format)
|
||||
|
||||
|
||||
def identity(n, dtype='d', format=None):
|
||||
"""Identity matrix in sparse format
|
||||
|
||||
Returns an identity matrix with shape (n,n) using a given
|
||||
sparse format and dtype.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
n : int
|
||||
Shape of the identity matrix.
|
||||
dtype : dtype, optional
|
||||
Data type of the matrix
|
||||
format : str, optional
|
||||
Sparse format of the result, e.g. format="csr", etc.
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> from scipy.sparse import identity
|
||||
>>> identity(3).toarray()
|
||||
array([[ 1., 0., 0.],
|
||||
[ 0., 1., 0.],
|
||||
[ 0., 0., 1.]])
|
||||
>>> identity(3, dtype='int8', format='dia')
|
||||
<3x3 sparse matrix of type '<class 'numpy.int8'>'
|
||||
with 3 stored elements (1 diagonals) in DIAgonal format>
|
||||
|
||||
"""
|
||||
return eye(n, n, dtype=dtype, format=format)
|
||||
|
||||
|
||||
def eye(m, n=None, k=0, dtype=float, format=None):
|
||||
"""Sparse matrix with ones on diagonal
|
||||
|
||||
Returns a sparse (m x n) matrix where the k-th diagonal
|
||||
is all ones and everything else is zeros.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
m : int
|
||||
Number of rows in the matrix.
|
||||
n : int, optional
|
||||
Number of columns. Default: `m`.
|
||||
k : int, optional
|
||||
Diagonal to place ones on. Default: 0 (main diagonal).
|
||||
dtype : dtype, optional
|
||||
Data type of the matrix.
|
||||
format : str, optional
|
||||
Sparse format of the result, e.g. format="csr", etc.
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> from scipy import sparse
|
||||
>>> sparse.eye(3).toarray()
|
||||
array([[ 1., 0., 0.],
|
||||
[ 0., 1., 0.],
|
||||
[ 0., 0., 1.]])
|
||||
>>> sparse.eye(3, dtype=np.int8)
|
||||
<3x3 sparse matrix of type '<class 'numpy.int8'>'
|
||||
with 3 stored elements (1 diagonals) in DIAgonal format>
|
||||
|
||||
"""
|
||||
if n is None:
|
||||
n = m
|
||||
m,n = int(m),int(n)
|
||||
|
||||
if m == n and k == 0:
|
||||
# fast branch for special formats
|
||||
if format in ['csr', 'csc']:
|
||||
idx_dtype = get_index_dtype(maxval=n)
|
||||
indptr = np.arange(n+1, dtype=idx_dtype)
|
||||
indices = np.arange(n, dtype=idx_dtype)
|
||||
data = np.ones(n, dtype=dtype)
|
||||
cls = {'csr': csr_matrix, 'csc': csc_matrix}[format]
|
||||
return cls((data,indices,indptr),(n,n))
|
||||
elif format == 'coo':
|
||||
idx_dtype = get_index_dtype(maxval=n)
|
||||
row = np.arange(n, dtype=idx_dtype)
|
||||
col = np.arange(n, dtype=idx_dtype)
|
||||
data = np.ones(n, dtype=dtype)
|
||||
return coo_matrix((data,(row,col)),(n,n))
|
||||
|
||||
diags = np.ones((1, max(0, min(m + k, n))), dtype=dtype)
|
||||
return spdiags(diags, k, m, n).asformat(format)
|
||||
|
||||
|
||||
def kron(A, B, format=None):
|
||||
"""kronecker product of sparse matrices A and B
|
||||
|
||||
Parameters
|
||||
----------
|
||||
A : sparse or dense matrix
|
||||
first matrix of the product
|
||||
B : sparse or dense matrix
|
||||
second matrix of the product
|
||||
format : str, optional
|
||||
format of the result (e.g. "csr")
|
||||
|
||||
Returns
|
||||
-------
|
||||
kronecker product in a sparse matrix format
|
||||
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> from scipy import sparse
|
||||
>>> A = sparse.csr_matrix(np.array([[0, 2], [5, 0]]))
|
||||
>>> B = sparse.csr_matrix(np.array([[1, 2], [3, 4]]))
|
||||
>>> sparse.kron(A, B).toarray()
|
||||
array([[ 0, 0, 2, 4],
|
||||
[ 0, 0, 6, 8],
|
||||
[ 5, 10, 0, 0],
|
||||
[15, 20, 0, 0]])
|
||||
|
||||
>>> sparse.kron(A, [[1, 2], [3, 4]]).toarray()
|
||||
array([[ 0, 0, 2, 4],
|
||||
[ 0, 0, 6, 8],
|
||||
[ 5, 10, 0, 0],
|
||||
[15, 20, 0, 0]])
|
||||
|
||||
"""
|
||||
B = coo_matrix(B)
|
||||
|
||||
if (format is None or format == "bsr") and 2*B.nnz >= B.shape[0] * B.shape[1]:
|
||||
# B is fairly dense, use BSR
|
||||
A = csr_matrix(A,copy=True)
|
||||
|
||||
output_shape = (A.shape[0]*B.shape[0], A.shape[1]*B.shape[1])
|
||||
|
||||
if A.nnz == 0 or B.nnz == 0:
|
||||
# kronecker product is the zero matrix
|
||||
return coo_matrix(output_shape)
|
||||
|
||||
B = B.toarray()
|
||||
data = A.data.repeat(B.size).reshape(-1,B.shape[0],B.shape[1])
|
||||
data = data * B
|
||||
|
||||
return bsr_matrix((data,A.indices,A.indptr), shape=output_shape)
|
||||
else:
|
||||
# use COO
|
||||
A = coo_matrix(A)
|
||||
output_shape = (A.shape[0]*B.shape[0], A.shape[1]*B.shape[1])
|
||||
|
||||
if A.nnz == 0 or B.nnz == 0:
|
||||
# kronecker product is the zero matrix
|
||||
return coo_matrix(output_shape)
|
||||
|
||||
# expand entries of a into blocks
|
||||
row = A.row.repeat(B.nnz)
|
||||
col = A.col.repeat(B.nnz)
|
||||
data = A.data.repeat(B.nnz)
|
||||
|
||||
row *= B.shape[0]
|
||||
col *= B.shape[1]
|
||||
|
||||
# increment block indices
|
||||
row,col = row.reshape(-1,B.nnz),col.reshape(-1,B.nnz)
|
||||
row += B.row
|
||||
col += B.col
|
||||
row,col = row.reshape(-1),col.reshape(-1)
|
||||
|
||||
# compute block entries
|
||||
data = data.reshape(-1,B.nnz) * B.data
|
||||
data = data.reshape(-1)
|
||||
|
||||
return coo_matrix((data,(row,col)), shape=output_shape).asformat(format)
|
||||
|
||||
|
||||
def kronsum(A, B, format=None):
|
||||
"""kronecker sum of sparse matrices A and B
|
||||
|
||||
Kronecker sum of two sparse matrices is a sum of two Kronecker
|
||||
products kron(I_n,A) + kron(B,I_m) where A has shape (m,m)
|
||||
and B has shape (n,n) and I_m and I_n are identity matrices
|
||||
of shape (m,m) and (n,n) respectively.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
A
|
||||
square matrix
|
||||
B
|
||||
square matrix
|
||||
format : str
|
||||
format of the result (e.g. "csr")
|
||||
|
||||
Returns
|
||||
-------
|
||||
kronecker sum in a sparse matrix format
|
||||
|
||||
Examples
|
||||
--------
|
||||
|
||||
|
||||
"""
|
||||
A = coo_matrix(A)
|
||||
B = coo_matrix(B)
|
||||
|
||||
if A.shape[0] != A.shape[1]:
|
||||
raise ValueError('A is not square')
|
||||
|
||||
if B.shape[0] != B.shape[1]:
|
||||
raise ValueError('B is not square')
|
||||
|
||||
dtype = upcast(A.dtype, B.dtype)
|
||||
|
||||
L = kron(eye(B.shape[0],dtype=dtype), A, format=format)
|
||||
R = kron(B, eye(A.shape[0],dtype=dtype), format=format)
|
||||
|
||||
return (L+R).asformat(format) # since L + R is not always same format
|
||||
|
||||
|
||||
def _compressed_sparse_stack(blocks, axis):
|
||||
"""
|
||||
Stacking fast path for CSR/CSC matrices
|
||||
(i) vstack for CSR, (ii) hstack for CSC.
|
||||
"""
|
||||
other_axis = 1 if axis == 0 else 0
|
||||
data = np.concatenate([b.data for b in blocks])
|
||||
constant_dim = blocks[0].shape[other_axis]
|
||||
idx_dtype = get_index_dtype(arrays=[b.indptr for b in blocks],
|
||||
maxval=max(data.size, constant_dim))
|
||||
indices = np.empty(data.size, dtype=idx_dtype)
|
||||
indptr = np.empty(sum(b.shape[axis] for b in blocks) + 1, dtype=idx_dtype)
|
||||
last_indptr = idx_dtype(0)
|
||||
sum_dim = 0
|
||||
sum_indices = 0
|
||||
for b in blocks:
|
||||
if b.shape[other_axis] != constant_dim:
|
||||
raise ValueError('incompatible dimensions for axis %d' % other_axis)
|
||||
indices[sum_indices:sum_indices+b.indices.size] = b.indices
|
||||
sum_indices += b.indices.size
|
||||
idxs = slice(sum_dim, sum_dim + b.shape[axis])
|
||||
indptr[idxs] = b.indptr[:-1]
|
||||
indptr[idxs] += last_indptr
|
||||
sum_dim += b.shape[axis]
|
||||
last_indptr += b.indptr[-1]
|
||||
indptr[-1] = last_indptr
|
||||
if axis == 0:
|
||||
return csr_matrix((data, indices, indptr),
|
||||
shape=(sum_dim, constant_dim))
|
||||
else:
|
||||
return csc_matrix((data, indices, indptr),
|
||||
shape=(constant_dim, sum_dim))
|
||||
|
||||
|
||||
def hstack(blocks, format=None, dtype=None):
|
||||
"""
|
||||
Stack sparse matrices horizontally (column wise)
|
||||
|
||||
Parameters
|
||||
----------
|
||||
blocks
|
||||
sequence of sparse matrices with compatible shapes
|
||||
format : str
|
||||
sparse format of the result (e.g. "csr")
|
||||
by default an appropriate sparse matrix format is returned.
|
||||
This choice is subject to change.
|
||||
dtype : dtype, optional
|
||||
The data-type of the output matrix. If not given, the dtype is
|
||||
determined from that of `blocks`.
|
||||
|
||||
See Also
|
||||
--------
|
||||
vstack : stack sparse matrices vertically (row wise)
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> from scipy.sparse import coo_matrix, hstack
|
||||
>>> A = coo_matrix([[1, 2], [3, 4]])
|
||||
>>> B = coo_matrix([[5], [6]])
|
||||
>>> hstack([A,B]).toarray()
|
||||
array([[1, 2, 5],
|
||||
[3, 4, 6]])
|
||||
|
||||
"""
|
||||
return bmat([blocks], format=format, dtype=dtype)
|
||||
|
||||
|
||||
def vstack(blocks, format=None, dtype=None):
|
||||
"""
|
||||
Stack sparse matrices vertically (row wise)
|
||||
|
||||
Parameters
|
||||
----------
|
||||
blocks
|
||||
sequence of sparse matrices with compatible shapes
|
||||
format : str, optional
|
||||
sparse format of the result (e.g. "csr")
|
||||
by default an appropriate sparse matrix format is returned.
|
||||
This choice is subject to change.
|
||||
dtype : dtype, optional
|
||||
The data-type of the output matrix. If not given, the dtype is
|
||||
determined from that of `blocks`.
|
||||
|
||||
See Also
|
||||
--------
|
||||
hstack : stack sparse matrices horizontally (column wise)
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> from scipy.sparse import coo_matrix, vstack
|
||||
>>> A = coo_matrix([[1, 2], [3, 4]])
|
||||
>>> B = coo_matrix([[5, 6]])
|
||||
>>> vstack([A, B]).toarray()
|
||||
array([[1, 2],
|
||||
[3, 4],
|
||||
[5, 6]])
|
||||
|
||||
"""
|
||||
return bmat([[b] for b in blocks], format=format, dtype=dtype)
|
||||
|
||||
|
||||
def bmat(blocks, format=None, dtype=None):
|
||||
"""
|
||||
Build a sparse matrix from sparse sub-blocks
|
||||
|
||||
Parameters
|
||||
----------
|
||||
blocks : array_like
|
||||
Grid of sparse matrices with compatible shapes.
|
||||
An entry of None implies an all-zero matrix.
|
||||
format : {'bsr', 'coo', 'csc', 'csr', 'dia', 'dok', 'lil'}, optional
|
||||
The sparse format of the result (e.g. "csr"). By default an
|
||||
appropriate sparse matrix format is returned.
|
||||
This choice is subject to change.
|
||||
dtype : dtype, optional
|
||||
The data-type of the output matrix. If not given, the dtype is
|
||||
determined from that of `blocks`.
|
||||
|
||||
Returns
|
||||
-------
|
||||
bmat : sparse matrix
|
||||
|
||||
See Also
|
||||
--------
|
||||
block_diag, diags
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> from scipy.sparse import coo_matrix, bmat
|
||||
>>> A = coo_matrix([[1, 2], [3, 4]])
|
||||
>>> B = coo_matrix([[5], [6]])
|
||||
>>> C = coo_matrix([[7]])
|
||||
>>> bmat([[A, B], [None, C]]).toarray()
|
||||
array([[1, 2, 5],
|
||||
[3, 4, 6],
|
||||
[0, 0, 7]])
|
||||
|
||||
>>> bmat([[A, None], [None, C]]).toarray()
|
||||
array([[1, 2, 0],
|
||||
[3, 4, 0],
|
||||
[0, 0, 7]])
|
||||
|
||||
"""
|
||||
|
||||
blocks = np.asarray(blocks, dtype='object')
|
||||
|
||||
if blocks.ndim != 2:
|
||||
raise ValueError('blocks must be 2-D')
|
||||
|
||||
M,N = blocks.shape
|
||||
|
||||
# check for fast path cases
|
||||
if (N == 1 and format in (None, 'csr') and all(isinstance(b, csr_matrix)
|
||||
for b in blocks.flat)):
|
||||
A = _compressed_sparse_stack(blocks[:,0], 0)
|
||||
if dtype is not None:
|
||||
A = A.astype(dtype)
|
||||
return A
|
||||
elif (M == 1 and format in (None, 'csc')
|
||||
and all(isinstance(b, csc_matrix) for b in blocks.flat)):
|
||||
A = _compressed_sparse_stack(blocks[0,:], 1)
|
||||
if dtype is not None:
|
||||
A = A.astype(dtype)
|
||||
return A
|
||||
|
||||
block_mask = np.zeros(blocks.shape, dtype=bool)
|
||||
brow_lengths = np.zeros(M, dtype=np.int64)
|
||||
bcol_lengths = np.zeros(N, dtype=np.int64)
|
||||
|
||||
# convert everything to COO format
|
||||
for i in range(M):
|
||||
for j in range(N):
|
||||
if blocks[i,j] is not None:
|
||||
A = coo_matrix(blocks[i,j])
|
||||
blocks[i,j] = A
|
||||
block_mask[i,j] = True
|
||||
|
||||
if brow_lengths[i] == 0:
|
||||
brow_lengths[i] = A.shape[0]
|
||||
elif brow_lengths[i] != A.shape[0]:
|
||||
msg = ('blocks[{i},:] has incompatible row dimensions. '
|
||||
'Got blocks[{i},{j}].shape[0] == {got}, '
|
||||
'expected {exp}.'.format(i=i, j=j,
|
||||
exp=brow_lengths[i],
|
||||
got=A.shape[0]))
|
||||
raise ValueError(msg)
|
||||
|
||||
if bcol_lengths[j] == 0:
|
||||
bcol_lengths[j] = A.shape[1]
|
||||
elif bcol_lengths[j] != A.shape[1]:
|
||||
msg = ('blocks[:,{j}] has incompatible row dimensions. '
|
||||
'Got blocks[{i},{j}].shape[1] == {got}, '
|
||||
'expected {exp}.'.format(i=i, j=j,
|
||||
exp=bcol_lengths[j],
|
||||
got=A.shape[1]))
|
||||
raise ValueError(msg)
|
||||
|
||||
nnz = sum(block.nnz for block in blocks[block_mask])
|
||||
if dtype is None:
|
||||
all_dtypes = [blk.dtype for blk in blocks[block_mask]]
|
||||
dtype = upcast(*all_dtypes) if all_dtypes else None
|
||||
|
||||
row_offsets = np.append(0, np.cumsum(brow_lengths))
|
||||
col_offsets = np.append(0, np.cumsum(bcol_lengths))
|
||||
|
||||
shape = (row_offsets[-1], col_offsets[-1])
|
||||
|
||||
data = np.empty(nnz, dtype=dtype)
|
||||
idx_dtype = get_index_dtype(maxval=max(shape))
|
||||
row = np.empty(nnz, dtype=idx_dtype)
|
||||
col = np.empty(nnz, dtype=idx_dtype)
|
||||
|
||||
nnz = 0
|
||||
ii, jj = np.nonzero(block_mask)
|
||||
for i, j in zip(ii, jj):
|
||||
B = blocks[i, j]
|
||||
idx = slice(nnz, nnz + B.nnz)
|
||||
data[idx] = B.data
|
||||
row[idx] = B.row + row_offsets[i]
|
||||
col[idx] = B.col + col_offsets[j]
|
||||
nnz += B.nnz
|
||||
|
||||
return coo_matrix((data, (row, col)), shape=shape).asformat(format)
|
||||
|
||||
|
||||
def block_diag(mats, format=None, dtype=None):
|
||||
"""
|
||||
Build a block diagonal sparse matrix from provided matrices.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
mats : sequence of matrices
|
||||
Input matrices.
|
||||
format : str, optional
|
||||
The sparse format of the result (e.g. "csr"). If not given, the matrix
|
||||
is returned in "coo" format.
|
||||
dtype : dtype specifier, optional
|
||||
The data-type of the output matrix. If not given, the dtype is
|
||||
determined from that of `blocks`.
|
||||
|
||||
Returns
|
||||
-------
|
||||
res : sparse matrix
|
||||
|
||||
Notes
|
||||
-----
|
||||
|
||||
.. versionadded:: 0.11.0
|
||||
|
||||
See Also
|
||||
--------
|
||||
bmat, diags
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> from scipy.sparse import coo_matrix, block_diag
|
||||
>>> A = coo_matrix([[1, 2], [3, 4]])
|
||||
>>> B = coo_matrix([[5], [6]])
|
||||
>>> C = coo_matrix([[7]])
|
||||
>>> block_diag((A, B, C)).toarray()
|
||||
array([[1, 2, 0, 0],
|
||||
[3, 4, 0, 0],
|
||||
[0, 0, 5, 0],
|
||||
[0, 0, 6, 0],
|
||||
[0, 0, 0, 7]])
|
||||
|
||||
"""
|
||||
nmat = len(mats)
|
||||
rows = []
|
||||
for ia, a in enumerate(mats):
|
||||
row = [None]*nmat
|
||||
if issparse(a):
|
||||
row[ia] = a
|
||||
else:
|
||||
row[ia] = coo_matrix(a)
|
||||
rows.append(row)
|
||||
return bmat(rows, format=format, dtype=dtype)
|
||||
|
||||
|
||||
def random(m, n, density=0.01, format='coo', dtype=None,
|
||||
random_state=None, data_rvs=None):
|
||||
"""Generate a sparse matrix of the given shape and density with randomly
|
||||
distributed values.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
m, n : int
|
||||
shape of the matrix
|
||||
density : real, optional
|
||||
density of the generated matrix: density equal to one means a full
|
||||
matrix, density of 0 means a matrix with no non-zero items.
|
||||
format : str, optional
|
||||
sparse matrix format.
|
||||
dtype : dtype, optional
|
||||
type of the returned matrix values.
|
||||
random_state : {numpy.random.RandomState, int}, optional
|
||||
Random number generator or random seed. If not given, the singleton
|
||||
numpy.random will be used. This random state will be used
|
||||
for sampling the sparsity structure, but not necessarily for sampling
|
||||
the values of the structurally nonzero entries of the matrix.
|
||||
data_rvs : callable, optional
|
||||
Samples a requested number of random values.
|
||||
This function should take a single argument specifying the length
|
||||
of the ndarray that it will return. The structurally nonzero entries
|
||||
of the sparse random matrix will be taken from the array sampled
|
||||
by this function. By default, uniform [0, 1) random values will be
|
||||
sampled using the same random state as is used for sampling
|
||||
the sparsity structure.
|
||||
|
||||
Returns
|
||||
-------
|
||||
res : sparse matrix
|
||||
|
||||
Notes
|
||||
-----
|
||||
Only float types are supported for now.
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> from scipy.sparse import random
|
||||
>>> from scipy import stats
|
||||
|
||||
>>> class CustomRandomState(np.random.RandomState):
|
||||
... def randint(self, k):
|
||||
... i = np.random.randint(k)
|
||||
... return i - i % 2
|
||||
>>> np.random.seed(12345)
|
||||
>>> rs = CustomRandomState()
|
||||
>>> rvs = stats.poisson(25, loc=10).rvs
|
||||
>>> S = random(3, 4, density=0.25, random_state=rs, data_rvs=rvs)
|
||||
>>> S.A
|
||||
array([[ 36., 0., 33., 0.], # random
|
||||
[ 0., 0., 0., 0.],
|
||||
[ 0., 0., 36., 0.]])
|
||||
|
||||
>>> from scipy.sparse import random
|
||||
>>> from scipy.stats import rv_continuous
|
||||
>>> class CustomDistribution(rv_continuous):
|
||||
... def _rvs(self, *args, **kwargs):
|
||||
... return self._random_state.randn(*self._size)
|
||||
>>> X = CustomDistribution(seed=2906)
|
||||
>>> Y = X() # get a frozen version of the distribution
|
||||
>>> S = random(3, 4, density=0.25, random_state=2906, data_rvs=Y.rvs)
|
||||
>>> S.A
|
||||
array([[ 0. , 0. , 0. , 0. ],
|
||||
[ 0.13569738, 1.9467163 , -0.81205367, 0. ],
|
||||
[ 0. , 0. , 0. , 0. ]])
|
||||
|
||||
"""
|
||||
if density < 0 or density > 1:
|
||||
raise ValueError("density expected to be 0 <= density <= 1")
|
||||
dtype = np.dtype(dtype)
|
||||
|
||||
mn = m * n
|
||||
|
||||
tp = np.intc
|
||||
if mn > np.iinfo(tp).max:
|
||||
tp = np.int64
|
||||
|
||||
if mn > np.iinfo(tp).max:
|
||||
msg = """\
|
||||
Trying to generate a random sparse matrix such as the product of dimensions is
|
||||
greater than %d - this is not supported on this machine
|
||||
"""
|
||||
raise ValueError(msg % np.iinfo(tp).max)
|
||||
|
||||
# Number of non zero values
|
||||
k = int(density * m * n)
|
||||
|
||||
if random_state is None:
|
||||
random_state = np.random
|
||||
elif isinstance(random_state, (int, np.integer)):
|
||||
random_state = np.random.RandomState(random_state)
|
||||
|
||||
if data_rvs is None:
|
||||
if np.issubdtype(dtype, np.integer):
|
||||
randint = get_randint(random_state)
|
||||
|
||||
def data_rvs(n):
|
||||
return randint(np.iinfo(dtype).min, np.iinfo(dtype).max,
|
||||
n, dtype=dtype)
|
||||
elif np.issubdtype(dtype, np.complexfloating):
|
||||
def data_rvs(n):
|
||||
return random_state.rand(n) + random_state.rand(n) * 1j
|
||||
else:
|
||||
data_rvs = random_state.rand
|
||||
|
||||
ind = random_state.choice(mn, size=k, replace=False)
|
||||
|
||||
j = np.floor(ind * 1. / m).astype(tp, copy=False)
|
||||
i = (ind - j * m).astype(tp, copy=False)
|
||||
vals = data_rvs(k).astype(dtype, copy=False)
|
||||
return coo_matrix((vals, (i, j)), shape=(m, n)).asformat(format,
|
||||
copy=False)
|
||||
|
||||
|
||||
def rand(m, n, density=0.01, format="coo", dtype=None, random_state=None):
|
||||
"""Generate a sparse matrix of the given shape and density with uniformly
|
||||
distributed values.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
m, n : int
|
||||
shape of the matrix
|
||||
density : real, optional
|
||||
density of the generated matrix: density equal to one means a full
|
||||
matrix, density of 0 means a matrix with no non-zero items.
|
||||
format : str, optional
|
||||
sparse matrix format.
|
||||
dtype : dtype, optional
|
||||
type of the returned matrix values.
|
||||
random_state : {numpy.random.RandomState, int}, optional
|
||||
Random number generator or random seed. If not given, the singleton
|
||||
numpy.random will be used.
|
||||
|
||||
Returns
|
||||
-------
|
||||
res : sparse matrix
|
||||
|
||||
Notes
|
||||
-----
|
||||
Only float types are supported for now.
|
||||
|
||||
See Also
|
||||
--------
|
||||
scipy.sparse.random : Similar function that allows a user-specified random
|
||||
data source.
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> from scipy.sparse import rand
|
||||
>>> matrix = rand(3, 4, density=0.25, format="csr", random_state=42)
|
||||
>>> matrix
|
||||
<3x4 sparse matrix of type '<class 'numpy.float64'>'
|
||||
with 3 stored elements in Compressed Sparse Row format>
|
||||
>>> matrix.todense()
|
||||
matrix([[0.05641158, 0. , 0. , 0.65088847],
|
||||
[0. , 0. , 0. , 0.14286682],
|
||||
[0. , 0. , 0. , 0. ]])
|
||||
|
||||
"""
|
||||
return random(m, n, density, format, dtype, random_state)
|
||||
@@ -0,0 +1,613 @@
|
||||
""" A sparse matrix in COOrdinate or 'triplet' format"""
|
||||
from __future__ import division, print_function, absolute_import
|
||||
|
||||
__docformat__ = "restructuredtext en"
|
||||
|
||||
__all__ = ['coo_matrix', 'isspmatrix_coo']
|
||||
|
||||
from warnings import warn
|
||||
|
||||
import numpy as np
|
||||
|
||||
from scipy._lib.six import zip as izip
|
||||
|
||||
from ._sparsetools import coo_tocsr, coo_todense, coo_matvec
|
||||
from .base import isspmatrix, SparseEfficiencyWarning, spmatrix
|
||||
from .data import _data_matrix, _minmax_mixin
|
||||
from .sputils import (upcast, upcast_char, to_native, isshape, getdtype,
|
||||
get_index_dtype, downcast_intp_index, check_shape,
|
||||
check_reshape_kwargs)
|
||||
|
||||
|
||||
class coo_matrix(_data_matrix, _minmax_mixin):
|
||||
"""
|
||||
A sparse matrix in COOrdinate format.
|
||||
|
||||
Also known as the 'ijv' or 'triplet' format.
|
||||
|
||||
This can be instantiated in several ways:
|
||||
coo_matrix(D)
|
||||
with a dense matrix D
|
||||
|
||||
coo_matrix(S)
|
||||
with another sparse matrix S (equivalent to S.tocoo())
|
||||
|
||||
coo_matrix((M, N), [dtype])
|
||||
to construct an empty matrix with shape (M, N)
|
||||
dtype is optional, defaulting to dtype='d'.
|
||||
|
||||
coo_matrix((data, (i, j)), [shape=(M, N)])
|
||||
to construct from three arrays:
|
||||
1. data[:] the entries of the matrix, in any order
|
||||
2. i[:] the row indices of the matrix entries
|
||||
3. j[:] the column indices of the matrix entries
|
||||
|
||||
Where ``A[i[k], j[k]] = data[k]``. When shape is not
|
||||
specified, it is inferred from the index arrays
|
||||
|
||||
Attributes
|
||||
----------
|
||||
dtype : dtype
|
||||
Data type of the matrix
|
||||
shape : 2-tuple
|
||||
Shape of the matrix
|
||||
ndim : int
|
||||
Number of dimensions (this is always 2)
|
||||
nnz
|
||||
Number of nonzero elements
|
||||
data
|
||||
COO format data array of the matrix
|
||||
row
|
||||
COO format row index array of the matrix
|
||||
col
|
||||
COO format column index array of the matrix
|
||||
|
||||
Notes
|
||||
-----
|
||||
|
||||
Sparse matrices can be used in arithmetic operations: they support
|
||||
addition, subtraction, multiplication, division, and matrix power.
|
||||
|
||||
Advantages of the COO format
|
||||
- facilitates fast conversion among sparse formats
|
||||
- permits duplicate entries (see example)
|
||||
- very fast conversion to and from CSR/CSC formats
|
||||
|
||||
Disadvantages of the COO format
|
||||
- does not directly support:
|
||||
+ arithmetic operations
|
||||
+ slicing
|
||||
|
||||
Intended Usage
|
||||
- COO is a fast format for constructing sparse matrices
|
||||
- Once a matrix has been constructed, convert to CSR or
|
||||
CSC format for fast arithmetic and matrix vector operations
|
||||
- By default when converting to CSR or CSC format, duplicate (i,j)
|
||||
entries will be summed together. This facilitates efficient
|
||||
construction of finite element matrices and the like. (see example)
|
||||
|
||||
Examples
|
||||
--------
|
||||
|
||||
>>> # Constructing an empty matrix
|
||||
>>> from scipy.sparse import coo_matrix
|
||||
>>> coo_matrix((3, 4), dtype=np.int8).toarray()
|
||||
array([[0, 0, 0, 0],
|
||||
[0, 0, 0, 0],
|
||||
[0, 0, 0, 0]], dtype=int8)
|
||||
|
||||
>>> # Constructing a matrix using ijv format
|
||||
>>> row = np.array([0, 3, 1, 0])
|
||||
>>> col = np.array([0, 3, 1, 2])
|
||||
>>> data = np.array([4, 5, 7, 9])
|
||||
>>> coo_matrix((data, (row, col)), shape=(4, 4)).toarray()
|
||||
array([[4, 0, 9, 0],
|
||||
[0, 7, 0, 0],
|
||||
[0, 0, 0, 0],
|
||||
[0, 0, 0, 5]])
|
||||
|
||||
>>> # Constructing a matrix with duplicate indices
|
||||
>>> row = np.array([0, 0, 1, 3, 1, 0, 0])
|
||||
>>> col = np.array([0, 2, 1, 3, 1, 0, 0])
|
||||
>>> data = np.array([1, 1, 1, 1, 1, 1, 1])
|
||||
>>> coo = coo_matrix((data, (row, col)), shape=(4, 4))
|
||||
>>> # Duplicate indices are maintained until implicitly or explicitly summed
|
||||
>>> np.max(coo.data)
|
||||
1
|
||||
>>> coo.toarray()
|
||||
array([[3, 0, 1, 0],
|
||||
[0, 2, 0, 0],
|
||||
[0, 0, 0, 0],
|
||||
[0, 0, 0, 1]])
|
||||
|
||||
"""
|
||||
format = 'coo'
|
||||
|
||||
def __init__(self, arg1, shape=None, dtype=None, copy=False):
|
||||
_data_matrix.__init__(self)
|
||||
|
||||
if isinstance(arg1, tuple):
|
||||
if isshape(arg1):
|
||||
M, N = arg1
|
||||
self._shape = check_shape((M, N))
|
||||
idx_dtype = get_index_dtype(maxval=max(M, N))
|
||||
self.row = np.array([], dtype=idx_dtype)
|
||||
self.col = np.array([], dtype=idx_dtype)
|
||||
self.data = np.array([], getdtype(dtype, default=float))
|
||||
self.has_canonical_format = True
|
||||
else:
|
||||
try:
|
||||
obj, (row, col) = arg1
|
||||
except (TypeError, ValueError):
|
||||
raise TypeError('invalid input format')
|
||||
|
||||
if shape is None:
|
||||
if len(row) == 0 or len(col) == 0:
|
||||
raise ValueError('cannot infer dimensions from zero '
|
||||
'sized index arrays')
|
||||
M = np.max(row) + 1
|
||||
N = np.max(col) + 1
|
||||
self._shape = check_shape((M, N))
|
||||
else:
|
||||
# Use 2 steps to ensure shape has length 2.
|
||||
M, N = shape
|
||||
self._shape = check_shape((M, N))
|
||||
|
||||
idx_dtype = get_index_dtype(maxval=max(self.shape))
|
||||
self.row = np.array(row, copy=copy, dtype=idx_dtype)
|
||||
self.col = np.array(col, copy=copy, dtype=idx_dtype)
|
||||
self.data = np.array(obj, copy=copy)
|
||||
self.has_canonical_format = False
|
||||
|
||||
else:
|
||||
if isspmatrix(arg1):
|
||||
if isspmatrix_coo(arg1) and copy:
|
||||
self.row = arg1.row.copy()
|
||||
self.col = arg1.col.copy()
|
||||
self.data = arg1.data.copy()
|
||||
self._shape = check_shape(arg1.shape)
|
||||
else:
|
||||
coo = arg1.tocoo()
|
||||
self.row = coo.row
|
||||
self.col = coo.col
|
||||
self.data = coo.data
|
||||
self._shape = check_shape(coo.shape)
|
||||
self.has_canonical_format = False
|
||||
else:
|
||||
#dense argument
|
||||
M = np.atleast_2d(np.asarray(arg1))
|
||||
|
||||
if M.ndim != 2:
|
||||
raise TypeError('expected dimension <= 2 array or matrix')
|
||||
else:
|
||||
self._shape = check_shape(M.shape)
|
||||
|
||||
self.row, self.col = M.nonzero()
|
||||
self.data = M[self.row, self.col]
|
||||
self.has_canonical_format = True
|
||||
|
||||
if dtype is not None:
|
||||
self.data = self.data.astype(dtype, copy=False)
|
||||
|
||||
self._check()
|
||||
|
||||
def reshape(self, *args, **kwargs):
|
||||
shape = check_shape(args, self.shape)
|
||||
order, copy = check_reshape_kwargs(kwargs)
|
||||
|
||||
# Return early if reshape is not required
|
||||
if shape == self.shape:
|
||||
if copy:
|
||||
return self.copy()
|
||||
else:
|
||||
return self
|
||||
|
||||
nrows, ncols = self.shape
|
||||
|
||||
if order == 'C':
|
||||
# Upcast to avoid overflows: the coo_matrix constructor
|
||||
# below will downcast the results to a smaller dtype, if
|
||||
# possible.
|
||||
dtype = get_index_dtype(maxval=(ncols * max(0, nrows - 1) + max(0, ncols - 1)))
|
||||
|
||||
flat_indices = np.multiply(ncols, self.row, dtype=dtype) + self.col
|
||||
new_row, new_col = divmod(flat_indices, shape[1])
|
||||
elif order == 'F':
|
||||
dtype = get_index_dtype(maxval=(nrows * max(0, ncols - 1) + max(0, nrows - 1)))
|
||||
|
||||
flat_indices = np.multiply(nrows, self.col, dtype=dtype) + self.row
|
||||
new_col, new_row = divmod(flat_indices, shape[0])
|
||||
else:
|
||||
raise ValueError("'order' must be 'C' or 'F'")
|
||||
|
||||
# Handle copy here rather than passing on to the constructor so that no
|
||||
# copy will be made of new_row and new_col regardless
|
||||
if copy:
|
||||
new_data = self.data.copy()
|
||||
else:
|
||||
new_data = self.data
|
||||
|
||||
return coo_matrix((new_data, (new_row, new_col)),
|
||||
shape=shape, copy=False)
|
||||
|
||||
reshape.__doc__ = spmatrix.reshape.__doc__
|
||||
|
||||
def getnnz(self, axis=None):
|
||||
if axis is None:
|
||||
nnz = len(self.data)
|
||||
if nnz != len(self.row) or nnz != len(self.col):
|
||||
raise ValueError('row, column, and data array must all be the '
|
||||
'same length')
|
||||
|
||||
if self.data.ndim != 1 or self.row.ndim != 1 or \
|
||||
self.col.ndim != 1:
|
||||
raise ValueError('row, column, and data arrays must be 1-D')
|
||||
|
||||
return int(nnz)
|
||||
|
||||
if axis < 0:
|
||||
axis += 2
|
||||
if axis == 0:
|
||||
return np.bincount(downcast_intp_index(self.col),
|
||||
minlength=self.shape[1])
|
||||
elif axis == 1:
|
||||
return np.bincount(downcast_intp_index(self.row),
|
||||
minlength=self.shape[0])
|
||||
else:
|
||||
raise ValueError('axis out of bounds')
|
||||
|
||||
getnnz.__doc__ = spmatrix.getnnz.__doc__
|
||||
|
||||
def _check(self):
|
||||
""" Checks data structure for consistency """
|
||||
|
||||
# index arrays should have integer data types
|
||||
if self.row.dtype.kind != 'i':
|
||||
warn("row index array has non-integer dtype (%s) "
|
||||
% self.row.dtype.name)
|
||||
if self.col.dtype.kind != 'i':
|
||||
warn("col index array has non-integer dtype (%s) "
|
||||
% self.col.dtype.name)
|
||||
|
||||
idx_dtype = get_index_dtype(maxval=max(self.shape))
|
||||
self.row = np.asarray(self.row, dtype=idx_dtype)
|
||||
self.col = np.asarray(self.col, dtype=idx_dtype)
|
||||
self.data = to_native(self.data)
|
||||
|
||||
if self.nnz > 0:
|
||||
if self.row.max() >= self.shape[0]:
|
||||
raise ValueError('row index exceeds matrix dimensions')
|
||||
if self.col.max() >= self.shape[1]:
|
||||
raise ValueError('column index exceeds matrix dimensions')
|
||||
if self.row.min() < 0:
|
||||
raise ValueError('negative row index found')
|
||||
if self.col.min() < 0:
|
||||
raise ValueError('negative column index found')
|
||||
|
||||
def transpose(self, axes=None, copy=False):
|
||||
if axes is not None:
|
||||
raise ValueError(("Sparse matrices do not support "
|
||||
"an 'axes' parameter because swapping "
|
||||
"dimensions is the only logical permutation."))
|
||||
|
||||
M, N = self.shape
|
||||
return coo_matrix((self.data, (self.col, self.row)),
|
||||
shape=(N, M), copy=copy)
|
||||
|
||||
transpose.__doc__ = spmatrix.transpose.__doc__
|
||||
|
||||
def resize(self, *shape):
|
||||
shape = check_shape(shape)
|
||||
new_M, new_N = shape
|
||||
M, N = self.shape
|
||||
|
||||
if new_M < M or new_N < N:
|
||||
mask = np.logical_and(self.row < new_M, self.col < new_N)
|
||||
if not mask.all():
|
||||
self.row = self.row[mask]
|
||||
self.col = self.col[mask]
|
||||
self.data = self.data[mask]
|
||||
|
||||
self._shape = shape
|
||||
|
||||
resize.__doc__ = spmatrix.resize.__doc__
|
||||
|
||||
def toarray(self, order=None, out=None):
|
||||
"""See the docstring for `spmatrix.toarray`."""
|
||||
B = self._process_toarray_args(order, out)
|
||||
fortran = int(B.flags.f_contiguous)
|
||||
if not fortran and not B.flags.c_contiguous:
|
||||
raise ValueError("Output array must be C or F contiguous")
|
||||
M,N = self.shape
|
||||
coo_todense(M, N, self.nnz, self.row, self.col, self.data,
|
||||
B.ravel('A'), fortran)
|
||||
return B
|
||||
|
||||
def tocsc(self, copy=False):
|
||||
"""Convert this matrix to Compressed Sparse Column format
|
||||
|
||||
Duplicate entries will be summed together.
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> from numpy import array
|
||||
>>> from scipy.sparse import coo_matrix
|
||||
>>> row = array([0, 0, 1, 3, 1, 0, 0])
|
||||
>>> col = array([0, 2, 1, 3, 1, 0, 0])
|
||||
>>> data = array([1, 1, 1, 1, 1, 1, 1])
|
||||
>>> A = coo_matrix((data, (row, col)), shape=(4, 4)).tocsc()
|
||||
>>> A.toarray()
|
||||
array([[3, 0, 1, 0],
|
||||
[0, 2, 0, 0],
|
||||
[0, 0, 0, 0],
|
||||
[0, 0, 0, 1]])
|
||||
|
||||
"""
|
||||
from .csc import csc_matrix
|
||||
if self.nnz == 0:
|
||||
return csc_matrix(self.shape, dtype=self.dtype)
|
||||
else:
|
||||
M,N = self.shape
|
||||
idx_dtype = get_index_dtype((self.col, self.row),
|
||||
maxval=max(self.nnz, M))
|
||||
row = self.row.astype(idx_dtype, copy=False)
|
||||
col = self.col.astype(idx_dtype, copy=False)
|
||||
|
||||
indptr = np.empty(N + 1, dtype=idx_dtype)
|
||||
indices = np.empty_like(row, dtype=idx_dtype)
|
||||
data = np.empty_like(self.data, dtype=upcast(self.dtype))
|
||||
|
||||
coo_tocsr(N, M, self.nnz, col, row, self.data,
|
||||
indptr, indices, data)
|
||||
|
||||
x = csc_matrix((data, indices, indptr), shape=self.shape)
|
||||
if not self.has_canonical_format:
|
||||
x.sum_duplicates()
|
||||
return x
|
||||
|
||||
def tocsr(self, copy=False):
|
||||
"""Convert this matrix to Compressed Sparse Row format
|
||||
|
||||
Duplicate entries will be summed together.
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> from numpy import array
|
||||
>>> from scipy.sparse import coo_matrix
|
||||
>>> row = array([0, 0, 1, 3, 1, 0, 0])
|
||||
>>> col = array([0, 2, 1, 3, 1, 0, 0])
|
||||
>>> data = array([1, 1, 1, 1, 1, 1, 1])
|
||||
>>> A = coo_matrix((data, (row, col)), shape=(4, 4)).tocsr()
|
||||
>>> A.toarray()
|
||||
array([[3, 0, 1, 0],
|
||||
[0, 2, 0, 0],
|
||||
[0, 0, 0, 0],
|
||||
[0, 0, 0, 1]])
|
||||
|
||||
"""
|
||||
from .csr import csr_matrix
|
||||
if self.nnz == 0:
|
||||
return csr_matrix(self.shape, dtype=self.dtype)
|
||||
else:
|
||||
M,N = self.shape
|
||||
idx_dtype = get_index_dtype((self.row, self.col),
|
||||
maxval=max(self.nnz, N))
|
||||
row = self.row.astype(idx_dtype, copy=False)
|
||||
col = self.col.astype(idx_dtype, copy=False)
|
||||
|
||||
indptr = np.empty(M + 1, dtype=idx_dtype)
|
||||
indices = np.empty_like(col, dtype=idx_dtype)
|
||||
data = np.empty_like(self.data, dtype=upcast(self.dtype))
|
||||
|
||||
coo_tocsr(M, N, self.nnz, row, col, self.data,
|
||||
indptr, indices, data)
|
||||
|
||||
x = csr_matrix((data, indices, indptr), shape=self.shape)
|
||||
if not self.has_canonical_format:
|
||||
x.sum_duplicates()
|
||||
return x
|
||||
|
||||
def tocoo(self, copy=False):
|
||||
if copy:
|
||||
return self.copy()
|
||||
else:
|
||||
return self
|
||||
|
||||
tocoo.__doc__ = spmatrix.tocoo.__doc__
|
||||
|
||||
def todia(self, copy=False):
|
||||
from .dia import dia_matrix
|
||||
|
||||
self.sum_duplicates()
|
||||
ks = self.col - self.row # the diagonal for each nonzero
|
||||
diags, diag_idx = np.unique(ks, return_inverse=True)
|
||||
|
||||
if len(diags) > 100:
|
||||
# probably undesired, should todia() have a maxdiags parameter?
|
||||
warn("Constructing a DIA matrix with %d diagonals "
|
||||
"is inefficient" % len(diags), SparseEfficiencyWarning)
|
||||
|
||||
#initialize and fill in data array
|
||||
if self.data.size == 0:
|
||||
data = np.zeros((0, 0), dtype=self.dtype)
|
||||
else:
|
||||
data = np.zeros((len(diags), self.col.max()+1), dtype=self.dtype)
|
||||
data[diag_idx, self.col] = self.data
|
||||
|
||||
return dia_matrix((data,diags), shape=self.shape)
|
||||
|
||||
todia.__doc__ = spmatrix.todia.__doc__
|
||||
|
||||
def todok(self, copy=False):
|
||||
from .dok import dok_matrix
|
||||
|
||||
self.sum_duplicates()
|
||||
dok = dok_matrix((self.shape), dtype=self.dtype)
|
||||
dok._update(izip(izip(self.row,self.col),self.data))
|
||||
|
||||
return dok
|
||||
|
||||
todok.__doc__ = spmatrix.todok.__doc__
|
||||
|
||||
def diagonal(self, k=0):
|
||||
rows, cols = self.shape
|
||||
if k <= -rows or k >= cols:
|
||||
raise ValueError("k exceeds matrix dimensions")
|
||||
diag = np.zeros(min(rows + min(k, 0), cols - max(k, 0)),
|
||||
dtype=self.dtype)
|
||||
diag_mask = (self.row + k) == self.col
|
||||
|
||||
if self.has_canonical_format:
|
||||
row = self.row[diag_mask]
|
||||
data = self.data[diag_mask]
|
||||
else:
|
||||
row, _, data = self._sum_duplicates(self.row[diag_mask],
|
||||
self.col[diag_mask],
|
||||
self.data[diag_mask])
|
||||
diag[row + min(k, 0)] = data
|
||||
|
||||
return diag
|
||||
|
||||
diagonal.__doc__ = _data_matrix.diagonal.__doc__
|
||||
|
||||
def _setdiag(self, values, k):
|
||||
M, N = self.shape
|
||||
if values.ndim and not len(values):
|
||||
return
|
||||
idx_dtype = self.row.dtype
|
||||
|
||||
# Determine which triples to keep and where to put the new ones.
|
||||
full_keep = self.col - self.row != k
|
||||
if k < 0:
|
||||
max_index = min(M+k, N)
|
||||
if values.ndim:
|
||||
max_index = min(max_index, len(values))
|
||||
keep = np.logical_or(full_keep, self.col >= max_index)
|
||||
new_row = np.arange(-k, -k + max_index, dtype=idx_dtype)
|
||||
new_col = np.arange(max_index, dtype=idx_dtype)
|
||||
else:
|
||||
max_index = min(M, N-k)
|
||||
if values.ndim:
|
||||
max_index = min(max_index, len(values))
|
||||
keep = np.logical_or(full_keep, self.row >= max_index)
|
||||
new_row = np.arange(max_index, dtype=idx_dtype)
|
||||
new_col = np.arange(k, k + max_index, dtype=idx_dtype)
|
||||
|
||||
# Define the array of data consisting of the entries to be added.
|
||||
if values.ndim:
|
||||
new_data = values[:max_index]
|
||||
else:
|
||||
new_data = np.empty(max_index, dtype=self.dtype)
|
||||
new_data[:] = values
|
||||
|
||||
# Update the internal structure.
|
||||
self.row = np.concatenate((self.row[keep], new_row))
|
||||
self.col = np.concatenate((self.col[keep], new_col))
|
||||
self.data = np.concatenate((self.data[keep], new_data))
|
||||
self.has_canonical_format = False
|
||||
|
||||
# needed by _data_matrix
|
||||
def _with_data(self,data,copy=True):
|
||||
"""Returns a matrix with the same sparsity structure as self,
|
||||
but with different data. By default the index arrays
|
||||
(i.e. .row and .col) are copied.
|
||||
"""
|
||||
if copy:
|
||||
return coo_matrix((data, (self.row.copy(), self.col.copy())),
|
||||
shape=self.shape, dtype=data.dtype)
|
||||
else:
|
||||
return coo_matrix((data, (self.row, self.col)),
|
||||
shape=self.shape, dtype=data.dtype)
|
||||
|
||||
def sum_duplicates(self):
|
||||
"""Eliminate duplicate matrix entries by adding them together
|
||||
|
||||
This is an *in place* operation
|
||||
"""
|
||||
if self.has_canonical_format:
|
||||
return
|
||||
summed = self._sum_duplicates(self.row, self.col, self.data)
|
||||
self.row, self.col, self.data = summed
|
||||
self.has_canonical_format = True
|
||||
|
||||
def _sum_duplicates(self, row, col, data):
|
||||
# Assumes (data, row, col) not in canonical format.
|
||||
if len(data) == 0:
|
||||
return row, col, data
|
||||
order = np.lexsort((row, col))
|
||||
row = row[order]
|
||||
col = col[order]
|
||||
data = data[order]
|
||||
unique_mask = ((row[1:] != row[:-1]) |
|
||||
(col[1:] != col[:-1]))
|
||||
unique_mask = np.append(True, unique_mask)
|
||||
row = row[unique_mask]
|
||||
col = col[unique_mask]
|
||||
unique_inds, = np.nonzero(unique_mask)
|
||||
data = np.add.reduceat(data, unique_inds, dtype=self.dtype)
|
||||
return row, col, data
|
||||
|
||||
def eliminate_zeros(self):
|
||||
"""Remove zero entries from the matrix
|
||||
|
||||
This is an *in place* operation
|
||||
"""
|
||||
mask = self.data != 0
|
||||
self.data = self.data[mask]
|
||||
self.row = self.row[mask]
|
||||
self.col = self.col[mask]
|
||||
|
||||
#######################
|
||||
# Arithmetic handlers #
|
||||
#######################
|
||||
|
||||
def _add_dense(self, other):
|
||||
if other.shape != self.shape:
|
||||
raise ValueError('Incompatible shapes.')
|
||||
dtype = upcast_char(self.dtype.char, other.dtype.char)
|
||||
result = np.array(other, dtype=dtype, copy=True)
|
||||
fortran = int(result.flags.f_contiguous)
|
||||
M, N = self.shape
|
||||
coo_todense(M, N, self.nnz, self.row, self.col, self.data,
|
||||
result.ravel('A'), fortran)
|
||||
return np.matrix(result, copy=False)
|
||||
|
||||
def _mul_vector(self, other):
|
||||
#output array
|
||||
result = np.zeros(self.shape[0], dtype=upcast_char(self.dtype.char,
|
||||
other.dtype.char))
|
||||
coo_matvec(self.nnz, self.row, self.col, self.data, other, result)
|
||||
return result
|
||||
|
||||
def _mul_multivector(self, other):
|
||||
result = np.zeros((other.shape[1], self.shape[0]),
|
||||
dtype=upcast_char(self.dtype.char, other.dtype.char))
|
||||
for i, col in enumerate(other.T):
|
||||
coo_matvec(self.nnz, self.row, self.col, self.data, col, result[i])
|
||||
return result.T.view(type=type(other))
|
||||
|
||||
|
||||
def isspmatrix_coo(x):
|
||||
"""Is x of coo_matrix type?
|
||||
|
||||
Parameters
|
||||
----------
|
||||
x
|
||||
object to check for being a coo matrix
|
||||
|
||||
Returns
|
||||
-------
|
||||
bool
|
||||
True if x is a coo matrix, False otherwise
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> from scipy.sparse import coo_matrix, isspmatrix_coo
|
||||
>>> isspmatrix_coo(coo_matrix([[5]]))
|
||||
True
|
||||
|
||||
>>> from scipy.sparse import coo_matrix, csr_matrix, isspmatrix_coo
|
||||
>>> isspmatrix_coo(csr_matrix([[5]]))
|
||||
False
|
||||
"""
|
||||
return isinstance(x, coo_matrix)
|
||||
@@ -0,0 +1,253 @@
|
||||
"""Compressed Sparse Column matrix format"""
|
||||
from __future__ import division, print_function, absolute_import
|
||||
|
||||
__docformat__ = "restructuredtext en"
|
||||
|
||||
__all__ = ['csc_matrix', 'isspmatrix_csc']
|
||||
|
||||
|
||||
import numpy as np
|
||||
|
||||
from .base import spmatrix
|
||||
from ._sparsetools import csc_tocsr
|
||||
from . import _sparsetools
|
||||
from .sputils import upcast, isintlike, IndexMixin, get_index_dtype
|
||||
|
||||
from .compressed import _cs_matrix
|
||||
|
||||
|
||||
class csc_matrix(_cs_matrix, IndexMixin):
|
||||
"""
|
||||
Compressed Sparse Column matrix
|
||||
|
||||
This can be instantiated in several ways:
|
||||
|
||||
csc_matrix(D)
|
||||
with a dense matrix or rank-2 ndarray D
|
||||
|
||||
csc_matrix(S)
|
||||
with another sparse matrix S (equivalent to S.tocsc())
|
||||
|
||||
csc_matrix((M, N), [dtype])
|
||||
to construct an empty matrix with shape (M, N)
|
||||
dtype is optional, defaulting to dtype='d'.
|
||||
|
||||
csc_matrix((data, (row_ind, col_ind)), [shape=(M, N)])
|
||||
where ``data``, ``row_ind`` and ``col_ind`` satisfy the
|
||||
relationship ``a[row_ind[k], col_ind[k]] = data[k]``.
|
||||
|
||||
csc_matrix((data, indices, indptr), [shape=(M, N)])
|
||||
is the standard CSC representation where the row indices for
|
||||
column i are stored in ``indices[indptr[i]:indptr[i+1]]``
|
||||
and their corresponding values are stored in
|
||||
``data[indptr[i]:indptr[i+1]]``. If the shape parameter is
|
||||
not supplied, the matrix dimensions are inferred from
|
||||
the index arrays.
|
||||
|
||||
Attributes
|
||||
----------
|
||||
dtype : dtype
|
||||
Data type of the matrix
|
||||
shape : 2-tuple
|
||||
Shape of the matrix
|
||||
ndim : int
|
||||
Number of dimensions (this is always 2)
|
||||
nnz
|
||||
Number of nonzero elements
|
||||
data
|
||||
Data array of the matrix
|
||||
indices
|
||||
CSC format index array
|
||||
indptr
|
||||
CSC format index pointer array
|
||||
has_sorted_indices
|
||||
Whether indices are sorted
|
||||
|
||||
Notes
|
||||
-----
|
||||
|
||||
Sparse matrices can be used in arithmetic operations: they support
|
||||
addition, subtraction, multiplication, division, and matrix power.
|
||||
|
||||
Advantages of the CSC format
|
||||
- efficient arithmetic operations CSC + CSC, CSC * CSC, etc.
|
||||
- efficient column slicing
|
||||
- fast matrix vector products (CSR, BSR may be faster)
|
||||
|
||||
Disadvantages of the CSC format
|
||||
- slow row slicing operations (consider CSR)
|
||||
- changes to the sparsity structure are expensive (consider LIL or DOK)
|
||||
|
||||
|
||||
Examples
|
||||
--------
|
||||
|
||||
>>> import numpy as np
|
||||
>>> from scipy.sparse import csc_matrix
|
||||
>>> csc_matrix((3, 4), dtype=np.int8).toarray()
|
||||
array([[0, 0, 0, 0],
|
||||
[0, 0, 0, 0],
|
||||
[0, 0, 0, 0]], dtype=int8)
|
||||
|
||||
>>> row = np.array([0, 2, 2, 0, 1, 2])
|
||||
>>> col = np.array([0, 0, 1, 2, 2, 2])
|
||||
>>> data = np.array([1, 2, 3, 4, 5, 6])
|
||||
>>> csc_matrix((data, (row, col)), shape=(3, 3)).toarray()
|
||||
array([[1, 0, 4],
|
||||
[0, 0, 5],
|
||||
[2, 3, 6]])
|
||||
|
||||
>>> indptr = np.array([0, 2, 3, 6])
|
||||
>>> indices = np.array([0, 2, 2, 0, 1, 2])
|
||||
>>> data = np.array([1, 2, 3, 4, 5, 6])
|
||||
>>> csc_matrix((data, indices, indptr), shape=(3, 3)).toarray()
|
||||
array([[1, 0, 4],
|
||||
[0, 0, 5],
|
||||
[2, 3, 6]])
|
||||
|
||||
"""
|
||||
format = 'csc'
|
||||
|
||||
def transpose(self, axes=None, copy=False):
|
||||
if axes is not None:
|
||||
raise ValueError(("Sparse matrices do not support "
|
||||
"an 'axes' parameter because swapping "
|
||||
"dimensions is the only logical permutation."))
|
||||
|
||||
M, N = self.shape
|
||||
|
||||
from .csr import csr_matrix
|
||||
return csr_matrix((self.data, self.indices,
|
||||
self.indptr), (N, M), copy=copy)
|
||||
|
||||
transpose.__doc__ = spmatrix.transpose.__doc__
|
||||
|
||||
def __iter__(self):
|
||||
for r in self.tocsr():
|
||||
yield r
|
||||
|
||||
def tocsc(self, copy=False):
|
||||
if copy:
|
||||
return self.copy()
|
||||
else:
|
||||
return self
|
||||
|
||||
tocsc.__doc__ = spmatrix.tocsc.__doc__
|
||||
|
||||
def tocsr(self, copy=False):
|
||||
M,N = self.shape
|
||||
idx_dtype = get_index_dtype((self.indptr, self.indices),
|
||||
maxval=max(self.nnz, N))
|
||||
indptr = np.empty(M + 1, dtype=idx_dtype)
|
||||
indices = np.empty(self.nnz, dtype=idx_dtype)
|
||||
data = np.empty(self.nnz, dtype=upcast(self.dtype))
|
||||
|
||||
csc_tocsr(M, N,
|
||||
self.indptr.astype(idx_dtype),
|
||||
self.indices.astype(idx_dtype),
|
||||
self.data,
|
||||
indptr,
|
||||
indices,
|
||||
data)
|
||||
|
||||
from .csr import csr_matrix
|
||||
A = csr_matrix((data, indices, indptr), shape=self.shape, copy=False)
|
||||
A.has_sorted_indices = True
|
||||
return A
|
||||
|
||||
tocsr.__doc__ = spmatrix.tocsr.__doc__
|
||||
|
||||
def __getitem__(self, key):
|
||||
# Use CSR to implement fancy indexing.
|
||||
|
||||
row, col = self._unpack_index(key)
|
||||
# Things that return submatrices. row or col is a int or slice.
|
||||
if (isinstance(row, slice) or isinstance(col, slice) or
|
||||
isintlike(row) or isintlike(col)):
|
||||
return self.T[col, row].T
|
||||
# Things that return a sequence of values.
|
||||
else:
|
||||
return self.T[col, row]
|
||||
|
||||
def nonzero(self):
|
||||
# CSC can't use _cs_matrix's .nonzero method because it
|
||||
# returns the indices sorted for self transposed.
|
||||
|
||||
# Get row and col indices, from _cs_matrix.tocoo
|
||||
major_dim, minor_dim = self._swap(self.shape)
|
||||
minor_indices = self.indices
|
||||
major_indices = np.empty(len(minor_indices), dtype=self.indices.dtype)
|
||||
_sparsetools.expandptr(major_dim, self.indptr, major_indices)
|
||||
row, col = self._swap((major_indices, minor_indices))
|
||||
|
||||
# Remove explicit zeros
|
||||
nz_mask = self.data != 0
|
||||
row = row[nz_mask]
|
||||
col = col[nz_mask]
|
||||
|
||||
# Sort them to be in C-style order
|
||||
ind = np.argsort(row, kind='mergesort')
|
||||
row = row[ind]
|
||||
col = col[ind]
|
||||
|
||||
return row, col
|
||||
|
||||
nonzero.__doc__ = _cs_matrix.nonzero.__doc__
|
||||
|
||||
def getrow(self, i):
|
||||
"""Returns a copy of row i of the matrix, as a (1 x n)
|
||||
CSR matrix (row vector).
|
||||
"""
|
||||
# we convert to CSR to maintain compatibility with old impl.
|
||||
# in spmatrix.getrow()
|
||||
return self._get_submatrix(i, slice(None)).tocsr()
|
||||
|
||||
def getcol(self, i):
|
||||
"""Returns a copy of column i of the matrix, as a (m x 1)
|
||||
CSC matrix (column vector).
|
||||
"""
|
||||
M, N = self.shape
|
||||
i = int(i)
|
||||
if i < 0:
|
||||
i += N
|
||||
if i < 0 or i >= N:
|
||||
raise IndexError('index (%d) out of range' % i)
|
||||
idx = slice(*self.indptr[i:i+2])
|
||||
data = self.data[idx].copy()
|
||||
indices = self.indices[idx].copy()
|
||||
indptr = np.array([0, len(indices)], dtype=self.indptr.dtype)
|
||||
return csc_matrix((data, indices, indptr), shape=(M, 1),
|
||||
dtype=self.dtype, copy=False)
|
||||
|
||||
# these functions are used by the parent class (_cs_matrix)
|
||||
# to remove redudancy between csc_matrix and csr_matrix
|
||||
def _swap(self, x):
|
||||
"""swap the members of x if this is a column-oriented matrix
|
||||
"""
|
||||
return x[1], x[0]
|
||||
|
||||
|
||||
def isspmatrix_csc(x):
|
||||
"""Is x of csc_matrix type?
|
||||
|
||||
Parameters
|
||||
----------
|
||||
x
|
||||
object to check for being a csc matrix
|
||||
|
||||
Returns
|
||||
-------
|
||||
bool
|
||||
True if x is a csc matrix, False otherwise
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> from scipy.sparse import csc_matrix, isspmatrix_csc
|
||||
>>> isspmatrix_csc(csc_matrix([[5]]))
|
||||
True
|
||||
|
||||
>>> from scipy.sparse import csc_matrix, csr_matrix, isspmatrix_csc
|
||||
>>> isspmatrix_csc(csr_matrix([[5]]))
|
||||
False
|
||||
"""
|
||||
return isinstance(x, csc_matrix)
|
||||
@@ -0,0 +1,195 @@
|
||||
r"""
|
||||
==============================================================
|
||||
Compressed Sparse Graph Routines (:mod:`scipy.sparse.csgraph`)
|
||||
==============================================================
|
||||
|
||||
.. currentmodule:: scipy.sparse.csgraph
|
||||
|
||||
Fast graph algorithms based on sparse matrix representations.
|
||||
|
||||
Contents
|
||||
========
|
||||
|
||||
.. autosummary::
|
||||
:toctree: generated/
|
||||
|
||||
connected_components -- determine connected components of a graph
|
||||
laplacian -- compute the laplacian of a graph
|
||||
shortest_path -- compute the shortest path between points on a positive graph
|
||||
dijkstra -- use Dijkstra's algorithm for shortest path
|
||||
floyd_warshall -- use the Floyd-Warshall algorithm for shortest path
|
||||
bellman_ford -- use the Bellman-Ford algorithm for shortest path
|
||||
johnson -- use Johnson's algorithm for shortest path
|
||||
breadth_first_order -- compute a breadth-first order of nodes
|
||||
depth_first_order -- compute a depth-first order of nodes
|
||||
breadth_first_tree -- construct the breadth-first tree from a given node
|
||||
depth_first_tree -- construct a depth-first tree from a given node
|
||||
minimum_spanning_tree -- construct the minimum spanning tree of a graph
|
||||
reverse_cuthill_mckee -- compute permutation for reverse Cuthill-McKee ordering
|
||||
maximum_bipartite_matching -- compute permutation to make diagonal zero free
|
||||
structural_rank -- compute the structural rank of a graph
|
||||
NegativeCycleError
|
||||
|
||||
.. autosummary::
|
||||
:toctree: generated/
|
||||
|
||||
construct_dist_matrix
|
||||
csgraph_from_dense
|
||||
csgraph_from_masked
|
||||
csgraph_masked_from_dense
|
||||
csgraph_to_dense
|
||||
csgraph_to_masked
|
||||
reconstruct_path
|
||||
|
||||
Graph Representations
|
||||
=====================
|
||||
This module uses graphs which are stored in a matrix format. A
|
||||
graph with N nodes can be represented by an (N x N) adjacency matrix G.
|
||||
If there is a connection from node i to node j, then G[i, j] = w, where
|
||||
w is the weight of the connection. For nodes i and j which are
|
||||
not connected, the value depends on the representation:
|
||||
|
||||
- for dense array representations, non-edges are represented by
|
||||
G[i, j] = 0, infinity, or NaN.
|
||||
|
||||
- for dense masked representations (of type np.ma.MaskedArray), non-edges
|
||||
are represented by masked values. This can be useful when graphs with
|
||||
zero-weight edges are desired.
|
||||
|
||||
- for sparse array representations, non-edges are represented by
|
||||
non-entries in the matrix. This sort of sparse representation also
|
||||
allows for edges with zero weights.
|
||||
|
||||
As a concrete example, imagine that you would like to represent the following
|
||||
undirected graph::
|
||||
|
||||
G
|
||||
|
||||
(0)
|
||||
/ \
|
||||
1 2
|
||||
/ \
|
||||
(2) (1)
|
||||
|
||||
This graph has three nodes, where node 0 and 1 are connected by an edge of
|
||||
weight 2, and nodes 0 and 2 are connected by an edge of weight 1.
|
||||
We can construct the dense, masked, and sparse representations as follows,
|
||||
keeping in mind that an undirected graph is represented by a symmetric matrix::
|
||||
|
||||
>>> G_dense = np.array([[0, 2, 1],
|
||||
... [2, 0, 0],
|
||||
... [1, 0, 0]])
|
||||
>>> G_masked = np.ma.masked_values(G_dense, 0)
|
||||
>>> from scipy.sparse import csr_matrix
|
||||
>>> G_sparse = csr_matrix(G_dense)
|
||||
|
||||
This becomes more difficult when zero edges are significant. For example,
|
||||
consider the situation when we slightly modify the above graph::
|
||||
|
||||
G2
|
||||
|
||||
(0)
|
||||
/ \
|
||||
0 2
|
||||
/ \
|
||||
(2) (1)
|
||||
|
||||
This is identical to the previous graph, except nodes 0 and 2 are connected
|
||||
by an edge of zero weight. In this case, the dense representation above
|
||||
leads to ambiguities: how can non-edges be represented if zero is a meaningful
|
||||
value? In this case, either a masked or sparse representation must be used
|
||||
to eliminate the ambiguity::
|
||||
|
||||
>>> G2_data = np.array([[np.inf, 2, 0 ],
|
||||
... [2, np.inf, np.inf],
|
||||
... [0, np.inf, np.inf]])
|
||||
>>> G2_masked = np.ma.masked_invalid(G2_data)
|
||||
>>> from scipy.sparse.csgraph import csgraph_from_dense
|
||||
>>> # G2_sparse = csr_matrix(G2_data) would give the wrong result
|
||||
>>> G2_sparse = csgraph_from_dense(G2_data, null_value=np.inf)
|
||||
>>> G2_sparse.data
|
||||
array([ 2., 0., 2., 0.])
|
||||
|
||||
Here we have used a utility routine from the csgraph submodule in order to
|
||||
convert the dense representation to a sparse representation which can be
|
||||
understood by the algorithms in submodule. By viewing the data array, we
|
||||
can see that the zero values are explicitly encoded in the graph.
|
||||
|
||||
Directed vs. Undirected
|
||||
-----------------------
|
||||
Matrices may represent either directed or undirected graphs. This is
|
||||
specified throughout the csgraph module by a boolean keyword. Graphs are
|
||||
assumed to be directed by default. In a directed graph, traversal from node
|
||||
i to node j can be accomplished over the edge G[i, j], but not the edge
|
||||
G[j, i]. Consider the following dense graph::
|
||||
|
||||
>>> G_dense = np.array([[0, 1, 0],
|
||||
... [2, 0, 3],
|
||||
... [0, 4, 0]])
|
||||
|
||||
When ``directed=True`` we get the graph::
|
||||
|
||||
---1--> ---3-->
|
||||
(0) (1) (2)
|
||||
<--2--- <--4---
|
||||
|
||||
In a non-directed graph, traversal from node i to node j can be
|
||||
accomplished over either G[i, j] or G[j, i]. If both edges are not null,
|
||||
and the two have unequal weights, then the smaller of the two is used.
|
||||
|
||||
So for the same graph, when ``directed=False`` we get the graph::
|
||||
|
||||
(0)--1--(1)--2--(2)
|
||||
|
||||
Note that a symmetric matrix will represent an undirected graph, regardless
|
||||
of whether the 'directed' keyword is set to True or False. In this case,
|
||||
using ``directed=True`` generally leads to more efficient computation.
|
||||
|
||||
The routines in this module accept as input either scipy.sparse representations
|
||||
(csr, csc, or lil format), masked representations, or dense representations
|
||||
with non-edges indicated by zeros, infinities, and NaN entries.
|
||||
"""
|
||||
|
||||
from __future__ import division, print_function, absolute_import
|
||||
|
||||
__docformat__ = "restructuredtext en"
|
||||
|
||||
__all__ = ['connected_components',
|
||||
'laplacian',
|
||||
'shortest_path',
|
||||
'floyd_warshall',
|
||||
'dijkstra',
|
||||
'bellman_ford',
|
||||
'johnson',
|
||||
'breadth_first_order',
|
||||
'depth_first_order',
|
||||
'breadth_first_tree',
|
||||
'depth_first_tree',
|
||||
'minimum_spanning_tree',
|
||||
'reverse_cuthill_mckee',
|
||||
'maximum_bipartite_matching',
|
||||
'structural_rank',
|
||||
'construct_dist_matrix',
|
||||
'reconstruct_path',
|
||||
'csgraph_masked_from_dense',
|
||||
'csgraph_from_dense',
|
||||
'csgraph_from_masked',
|
||||
'csgraph_to_dense',
|
||||
'csgraph_to_masked',
|
||||
'NegativeCycleError']
|
||||
|
||||
from ._laplacian import laplacian
|
||||
from ._shortest_path import shortest_path, floyd_warshall, dijkstra,\
|
||||
bellman_ford, johnson, NegativeCycleError
|
||||
from ._traversal import breadth_first_order, depth_first_order, \
|
||||
breadth_first_tree, depth_first_tree, connected_components
|
||||
from ._min_spanning_tree import minimum_spanning_tree
|
||||
from ._reordering import reverse_cuthill_mckee, maximum_bipartite_matching, \
|
||||
structural_rank
|
||||
from ._tools import construct_dist_matrix, reconstruct_path,\
|
||||
csgraph_from_dense, csgraph_to_dense, csgraph_masked_from_dense,\
|
||||
csgraph_from_masked, csgraph_to_masked
|
||||
|
||||
from scipy._lib._testutils import PytestTester
|
||||
test = PytestTester(__name__)
|
||||
del PytestTester
|
||||
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
@@ -0,0 +1,128 @@
|
||||
"""
|
||||
Laplacian of a compressed-sparse graph
|
||||
"""
|
||||
|
||||
# Authors: Aric Hagberg <hagberg@lanl.gov>
|
||||
# Gael Varoquaux <gael.varoquaux@normalesup.org>
|
||||
# Jake Vanderplas <vanderplas@astro.washington.edu>
|
||||
# License: BSD
|
||||
|
||||
from __future__ import division, print_function, absolute_import
|
||||
|
||||
import numpy as np
|
||||
from scipy.sparse import isspmatrix
|
||||
|
||||
|
||||
###############################################################################
|
||||
# Graph laplacian
|
||||
def laplacian(csgraph, normed=False, return_diag=False, use_out_degree=False):
|
||||
"""
|
||||
Return the Laplacian matrix of a directed graph.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
csgraph : array_like or sparse matrix, 2 dimensions
|
||||
compressed-sparse graph, with shape (N, N).
|
||||
normed : bool, optional
|
||||
If True, then compute normalized Laplacian.
|
||||
return_diag : bool, optional
|
||||
If True, then also return an array related to vertex degrees.
|
||||
use_out_degree : bool, optional
|
||||
If True, then use out-degree instead of in-degree.
|
||||
This distinction matters only if the graph is asymmetric.
|
||||
Default: False.
|
||||
|
||||
Returns
|
||||
-------
|
||||
lap : ndarray or sparse matrix
|
||||
The N x N laplacian matrix of csgraph. It will be a numpy array (dense)
|
||||
if the input was dense, or a sparse matrix otherwise.
|
||||
diag : ndarray, optional
|
||||
The length-N diagonal of the Laplacian matrix.
|
||||
For the normalized Laplacian, this is the array of square roots
|
||||
of vertex degrees or 1 if the degree is zero.
|
||||
|
||||
Notes
|
||||
-----
|
||||
The Laplacian matrix of a graph is sometimes referred to as the
|
||||
"Kirchoff matrix" or the "admittance matrix", and is useful in many
|
||||
parts of spectral graph theory. In particular, the eigen-decomposition
|
||||
of the laplacian matrix can give insight into many properties of the graph.
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> from scipy.sparse import csgraph
|
||||
>>> G = np.arange(5) * np.arange(5)[:, np.newaxis]
|
||||
>>> G
|
||||
array([[ 0, 0, 0, 0, 0],
|
||||
[ 0, 1, 2, 3, 4],
|
||||
[ 0, 2, 4, 6, 8],
|
||||
[ 0, 3, 6, 9, 12],
|
||||
[ 0, 4, 8, 12, 16]])
|
||||
>>> csgraph.laplacian(G, normed=False)
|
||||
array([[ 0, 0, 0, 0, 0],
|
||||
[ 0, 9, -2, -3, -4],
|
||||
[ 0, -2, 16, -6, -8],
|
||||
[ 0, -3, -6, 21, -12],
|
||||
[ 0, -4, -8, -12, 24]])
|
||||
"""
|
||||
if csgraph.ndim != 2 or csgraph.shape[0] != csgraph.shape[1]:
|
||||
raise ValueError('csgraph must be a square matrix or array')
|
||||
|
||||
if normed and (np.issubdtype(csgraph.dtype, np.signedinteger)
|
||||
or np.issubdtype(csgraph.dtype, np.uint)):
|
||||
csgraph = csgraph.astype(float)
|
||||
|
||||
create_lap = _laplacian_sparse if isspmatrix(csgraph) else _laplacian_dense
|
||||
degree_axis = 1 if use_out_degree else 0
|
||||
lap, d = create_lap(csgraph, normed=normed, axis=degree_axis)
|
||||
if return_diag:
|
||||
return lap, d
|
||||
return lap
|
||||
|
||||
|
||||
def _setdiag_dense(A, d):
|
||||
A.flat[::len(d)+1] = d
|
||||
|
||||
|
||||
def _laplacian_sparse(graph, normed=False, axis=0):
|
||||
if graph.format in ('lil', 'dok'):
|
||||
m = graph.tocoo()
|
||||
needs_copy = False
|
||||
else:
|
||||
m = graph
|
||||
needs_copy = True
|
||||
w = m.sum(axis=axis).getA1() - m.diagonal()
|
||||
if normed:
|
||||
m = m.tocoo(copy=needs_copy)
|
||||
isolated_node_mask = (w == 0)
|
||||
w = np.where(isolated_node_mask, 1, np.sqrt(w))
|
||||
m.data /= w[m.row]
|
||||
m.data /= w[m.col]
|
||||
m.data *= -1
|
||||
m.setdiag(1 - isolated_node_mask)
|
||||
else:
|
||||
if m.format == 'dia':
|
||||
m = m.copy()
|
||||
else:
|
||||
m = m.tocoo(copy=needs_copy)
|
||||
m.data *= -1
|
||||
m.setdiag(w)
|
||||
return m, w
|
||||
|
||||
|
||||
def _laplacian_dense(graph, normed=False, axis=0):
|
||||
m = np.array(graph)
|
||||
np.fill_diagonal(m, 0)
|
||||
w = m.sum(axis=axis)
|
||||
if normed:
|
||||
isolated_node_mask = (w == 0)
|
||||
w = np.where(isolated_node_mask, 1, np.sqrt(w))
|
||||
m /= w
|
||||
m /= w[:, np.newaxis]
|
||||
m *= -1
|
||||
_setdiag_dense(m, 1 - isolated_node_mask)
|
||||
else:
|
||||
m *= -1
|
||||
_setdiag_dense(m, w)
|
||||
return m, w
|
||||
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
@@ -0,0 +1,58 @@
|
||||
from __future__ import division, print_function, absolute_import
|
||||
|
||||
import numpy as np
|
||||
from scipy.sparse import csr_matrix, isspmatrix, isspmatrix_csc
|
||||
from ._tools import csgraph_to_dense, csgraph_from_dense,\
|
||||
csgraph_masked_from_dense, csgraph_from_masked
|
||||
|
||||
DTYPE = np.float64
|
||||
|
||||
|
||||
def validate_graph(csgraph, directed, dtype=DTYPE,
|
||||
csr_output=True, dense_output=True,
|
||||
copy_if_dense=False, copy_if_sparse=False,
|
||||
null_value_in=0, null_value_out=np.inf,
|
||||
infinity_null=True, nan_null=True):
|
||||
"""Routine for validation and conversion of csgraph inputs"""
|
||||
if not (csr_output or dense_output):
|
||||
raise ValueError("Internal: dense or csr output must be true")
|
||||
|
||||
# if undirected and csc storage, then transposing in-place
|
||||
# is quicker than later converting to csr.
|
||||
if (not directed) and isspmatrix_csc(csgraph):
|
||||
csgraph = csgraph.T
|
||||
|
||||
if isspmatrix(csgraph):
|
||||
if csr_output:
|
||||
csgraph = csr_matrix(csgraph, dtype=DTYPE, copy=copy_if_sparse)
|
||||
else:
|
||||
csgraph = csgraph_to_dense(csgraph, null_value=null_value_out)
|
||||
elif np.ma.isMaskedArray(csgraph):
|
||||
if dense_output:
|
||||
mask = csgraph.mask
|
||||
csgraph = np.array(csgraph.data, dtype=DTYPE, copy=copy_if_dense)
|
||||
csgraph[mask] = null_value_out
|
||||
else:
|
||||
csgraph = csgraph_from_masked(csgraph)
|
||||
else:
|
||||
if dense_output:
|
||||
csgraph = csgraph_masked_from_dense(csgraph,
|
||||
copy=copy_if_dense,
|
||||
null_value=null_value_in,
|
||||
nan_null=nan_null,
|
||||
infinity_null=infinity_null)
|
||||
mask = csgraph.mask
|
||||
csgraph = np.asarray(csgraph.data, dtype=DTYPE)
|
||||
csgraph[mask] = null_value_out
|
||||
else:
|
||||
csgraph = csgraph_from_dense(csgraph, null_value=null_value_in,
|
||||
infinity_null=infinity_null,
|
||||
nan_null=nan_null)
|
||||
|
||||
if csgraph.ndim != 2:
|
||||
raise ValueError("compressed-sparse graph must be two dimensional")
|
||||
|
||||
if csgraph.shape[0] != csgraph.shape[1]:
|
||||
raise ValueError("compressed-sparse graph must be shape (N, N)")
|
||||
|
||||
return csgraph
|
||||
@@ -0,0 +1,32 @@
|
||||
from __future__ import division, print_function, absolute_import
|
||||
|
||||
|
||||
def configuration(parent_package='', top_path=None):
|
||||
import numpy
|
||||
from numpy.distutils.misc_util import Configuration
|
||||
|
||||
config = Configuration('csgraph', parent_package, top_path)
|
||||
|
||||
config.add_data_dir('tests')
|
||||
|
||||
config.add_extension('_shortest_path',
|
||||
sources=['_shortest_path.c'],
|
||||
include_dirs=[numpy.get_include()])
|
||||
|
||||
config.add_extension('_traversal',
|
||||
sources=['_traversal.c'],
|
||||
include_dirs=[numpy.get_include()])
|
||||
|
||||
config.add_extension('_min_spanning_tree',
|
||||
sources=['_min_spanning_tree.c'],
|
||||
include_dirs=[numpy.get_include()])
|
||||
|
||||
config.add_extension('_reordering',
|
||||
sources=['_reordering.c'],
|
||||
include_dirs=[numpy.get_include()])
|
||||
|
||||
config.add_extension('_tools',
|
||||
sources=['_tools.c'],
|
||||
include_dirs=[numpy.get_include()])
|
||||
|
||||
return config
|
||||
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
+101
@@ -0,0 +1,101 @@
|
||||
from __future__ import division, print_function, absolute_import
|
||||
|
||||
import numpy as np
|
||||
from numpy.testing import assert_equal, assert_array_almost_equal
|
||||
from scipy.sparse import csgraph
|
||||
|
||||
|
||||
def test_weak_connections():
|
||||
Xde = np.array([[0, 1, 0],
|
||||
[0, 0, 0],
|
||||
[0, 0, 0]])
|
||||
|
||||
Xsp = csgraph.csgraph_from_dense(Xde, null_value=0)
|
||||
|
||||
for X in Xsp, Xde:
|
||||
n_components, labels =\
|
||||
csgraph.connected_components(X, directed=True,
|
||||
connection='weak')
|
||||
|
||||
assert_equal(n_components, 2)
|
||||
assert_array_almost_equal(labels, [0, 0, 1])
|
||||
|
||||
|
||||
def test_strong_connections():
|
||||
X1de = np.array([[0, 1, 0],
|
||||
[0, 0, 0],
|
||||
[0, 0, 0]])
|
||||
X2de = X1de + X1de.T
|
||||
|
||||
X1sp = csgraph.csgraph_from_dense(X1de, null_value=0)
|
||||
X2sp = csgraph.csgraph_from_dense(X2de, null_value=0)
|
||||
|
||||
for X in X1sp, X1de:
|
||||
n_components, labels =\
|
||||
csgraph.connected_components(X, directed=True,
|
||||
connection='strong')
|
||||
|
||||
assert_equal(n_components, 3)
|
||||
labels.sort()
|
||||
assert_array_almost_equal(labels, [0, 1, 2])
|
||||
|
||||
for X in X2sp, X2de:
|
||||
n_components, labels =\
|
||||
csgraph.connected_components(X, directed=True,
|
||||
connection='strong')
|
||||
|
||||
assert_equal(n_components, 2)
|
||||
labels.sort()
|
||||
assert_array_almost_equal(labels, [0, 0, 1])
|
||||
|
||||
|
||||
def test_strong_connections2():
|
||||
X = np.array([[0, 0, 0, 0, 0, 0],
|
||||
[1, 0, 1, 0, 0, 0],
|
||||
[0, 0, 0, 1, 0, 0],
|
||||
[0, 0, 1, 0, 1, 0],
|
||||
[0, 0, 0, 0, 0, 0],
|
||||
[0, 0, 0, 0, 1, 0]])
|
||||
n_components, labels =\
|
||||
csgraph.connected_components(X, directed=True,
|
||||
connection='strong')
|
||||
assert_equal(n_components, 5)
|
||||
labels.sort()
|
||||
assert_array_almost_equal(labels, [0, 1, 2, 2, 3, 4])
|
||||
|
||||
|
||||
def test_weak_connections2():
|
||||
X = np.array([[0, 0, 0, 0, 0, 0],
|
||||
[1, 0, 0, 0, 0, 0],
|
||||
[0, 0, 0, 1, 0, 0],
|
||||
[0, 0, 1, 0, 1, 0],
|
||||
[0, 0, 0, 0, 0, 0],
|
||||
[0, 0, 0, 0, 1, 0]])
|
||||
n_components, labels =\
|
||||
csgraph.connected_components(X, directed=True,
|
||||
connection='weak')
|
||||
assert_equal(n_components, 2)
|
||||
labels.sort()
|
||||
assert_array_almost_equal(labels, [0, 0, 1, 1, 1, 1])
|
||||
|
||||
|
||||
def test_ticket1876():
|
||||
# Regression test: this failed in the original implementation
|
||||
# There should be two strongly-connected components; previously gave one
|
||||
g = np.array([[0, 1, 1, 0],
|
||||
[1, 0, 0, 1],
|
||||
[0, 0, 0, 1],
|
||||
[0, 0, 1, 0]])
|
||||
n_components, labels = csgraph.connected_components(g, connection='strong')
|
||||
|
||||
assert_equal(n_components, 2)
|
||||
assert_equal(labels[0], labels[1])
|
||||
assert_equal(labels[2], labels[3])
|
||||
|
||||
|
||||
def test_fully_connected_graph():
|
||||
# Fully connected dense matrices raised an exception.
|
||||
# https://github.com/scipy/scipy/issues/3818
|
||||
g = np.ones((4, 4))
|
||||
n_components, labels = csgraph.connected_components(g)
|
||||
assert_equal(n_components, 1)
|
||||
@@ -0,0 +1,69 @@
|
||||
from __future__ import division, print_function, absolute_import
|
||||
|
||||
import numpy as np
|
||||
from numpy.testing import assert_array_almost_equal
|
||||
from scipy.sparse import csr_matrix
|
||||
from scipy.sparse.csgraph import csgraph_from_dense, csgraph_to_dense
|
||||
|
||||
|
||||
def test_csgraph_from_dense():
|
||||
np.random.seed(1234)
|
||||
G = np.random.random((10, 10))
|
||||
some_nulls = (G < 0.4)
|
||||
all_nulls = (G < 0.8)
|
||||
|
||||
for null_value in [0, np.nan, np.inf]:
|
||||
G[all_nulls] = null_value
|
||||
olderr = np.seterr(invalid="ignore")
|
||||
try:
|
||||
G_csr = csgraph_from_dense(G, null_value=0)
|
||||
finally:
|
||||
np.seterr(**olderr)
|
||||
|
||||
G[all_nulls] = 0
|
||||
assert_array_almost_equal(G, G_csr.toarray())
|
||||
|
||||
for null_value in [np.nan, np.inf]:
|
||||
G[all_nulls] = 0
|
||||
G[some_nulls] = null_value
|
||||
olderr = np.seterr(invalid="ignore")
|
||||
try:
|
||||
G_csr = csgraph_from_dense(G, null_value=0)
|
||||
finally:
|
||||
np.seterr(**olderr)
|
||||
|
||||
G[all_nulls] = 0
|
||||
assert_array_almost_equal(G, G_csr.toarray())
|
||||
|
||||
|
||||
def test_csgraph_to_dense():
|
||||
np.random.seed(1234)
|
||||
G = np.random.random((10, 10))
|
||||
nulls = (G < 0.8)
|
||||
G[nulls] = np.inf
|
||||
|
||||
G_csr = csgraph_from_dense(G)
|
||||
|
||||
for null_value in [0, 10, -np.inf, np.inf]:
|
||||
G[nulls] = null_value
|
||||
assert_array_almost_equal(G, csgraph_to_dense(G_csr, null_value))
|
||||
|
||||
|
||||
def test_multiple_edges():
|
||||
# create a random sqare matrix with an even number of elements
|
||||
np.random.seed(1234)
|
||||
X = np.random.random((10, 10))
|
||||
Xcsr = csr_matrix(X)
|
||||
|
||||
# now double-up every other column
|
||||
Xcsr.indices[::2] = Xcsr.indices[1::2]
|
||||
|
||||
# normal sparse toarray() will sum the duplicated edges
|
||||
Xdense = Xcsr.toarray()
|
||||
assert_array_almost_equal(Xdense[:, 1::2],
|
||||
X[:, ::2] + X[:, 1::2])
|
||||
|
||||
# csgraph_to_dense chooses the minimum of each duplicated edge
|
||||
Xdense = csgraph_to_dense(Xcsr)
|
||||
assert_array_almost_equal(Xdense[:, 1::2],
|
||||
np.minimum(X[:, ::2], X[:, 1::2]))
|
||||
+136
@@ -0,0 +1,136 @@
|
||||
# Author: Gael Varoquaux <gael.varoquaux@normalesup.org>
|
||||
# Jake Vanderplas <vanderplas@astro.washington.edu>
|
||||
# License: BSD
|
||||
from __future__ import division, print_function, absolute_import
|
||||
|
||||
import numpy as np
|
||||
from numpy.testing import assert_allclose, assert_array_almost_equal
|
||||
from pytest import raises as assert_raises
|
||||
from scipy import sparse
|
||||
|
||||
from scipy.sparse import csgraph
|
||||
|
||||
|
||||
def _explicit_laplacian(x, normed=False):
|
||||
if sparse.issparse(x):
|
||||
x = x.todense()
|
||||
x = np.asarray(x)
|
||||
y = -1.0 * x
|
||||
for j in range(y.shape[0]):
|
||||
y[j,j] = x[j,j+1:].sum() + x[j,:j].sum()
|
||||
if normed:
|
||||
d = np.diag(y).copy()
|
||||
d[d == 0] = 1.0
|
||||
y /= d[:,None]**.5
|
||||
y /= d[None,:]**.5
|
||||
return y
|
||||
|
||||
|
||||
def _check_symmetric_graph_laplacian(mat, normed):
|
||||
if not hasattr(mat, 'shape'):
|
||||
mat = eval(mat, dict(np=np, sparse=sparse))
|
||||
|
||||
if sparse.issparse(mat):
|
||||
sp_mat = mat
|
||||
mat = sp_mat.todense()
|
||||
else:
|
||||
sp_mat = sparse.csr_matrix(mat)
|
||||
|
||||
laplacian = csgraph.laplacian(mat, normed=normed)
|
||||
n_nodes = mat.shape[0]
|
||||
if not normed:
|
||||
assert_array_almost_equal(laplacian.sum(axis=0), np.zeros(n_nodes))
|
||||
assert_array_almost_equal(laplacian.T, laplacian)
|
||||
assert_array_almost_equal(laplacian,
|
||||
csgraph.laplacian(sp_mat, normed=normed).todense())
|
||||
|
||||
assert_array_almost_equal(laplacian,
|
||||
_explicit_laplacian(mat, normed=normed))
|
||||
|
||||
|
||||
def test_laplacian_value_error():
|
||||
for t in int, float, complex:
|
||||
for m in ([1, 1],
|
||||
[[[1]]],
|
||||
[[1, 2, 3], [4, 5, 6]],
|
||||
[[1, 2], [3, 4], [5, 5]]):
|
||||
A = np.array(m, dtype=t)
|
||||
assert_raises(ValueError, csgraph.laplacian, A)
|
||||
|
||||
|
||||
def test_symmetric_graph_laplacian():
|
||||
symmetric_mats = ('np.arange(10) * np.arange(10)[:, np.newaxis]',
|
||||
'np.ones((7, 7))',
|
||||
'np.eye(19)',
|
||||
'sparse.diags([1, 1], [-1, 1], shape=(4,4))',
|
||||
'sparse.diags([1, 1], [-1, 1], shape=(4,4)).todense()',
|
||||
'np.asarray(sparse.diags([1, 1], [-1, 1], shape=(4,4)).todense())',
|
||||
'np.vander(np.arange(4)) + np.vander(np.arange(4)).T')
|
||||
for mat_str in symmetric_mats:
|
||||
for normed in True, False:
|
||||
_check_symmetric_graph_laplacian(mat_str, normed)
|
||||
|
||||
|
||||
def _assert_allclose_sparse(a, b, **kwargs):
|
||||
# helper function that can deal with sparse matrices
|
||||
if sparse.issparse(a):
|
||||
a = a.toarray()
|
||||
if sparse.issparse(b):
|
||||
b = a.toarray()
|
||||
assert_allclose(a, b, **kwargs)
|
||||
|
||||
|
||||
def _check_laplacian(A, desired_L, desired_d, normed, use_out_degree):
|
||||
for arr_type in np.array, sparse.csr_matrix, sparse.coo_matrix:
|
||||
for t in int, float, complex:
|
||||
adj = arr_type(A, dtype=t)
|
||||
L = csgraph.laplacian(adj, normed=normed, return_diag=False,
|
||||
use_out_degree=use_out_degree)
|
||||
_assert_allclose_sparse(L, desired_L, atol=1e-12)
|
||||
L, d = csgraph.laplacian(adj, normed=normed, return_diag=True,
|
||||
use_out_degree=use_out_degree)
|
||||
_assert_allclose_sparse(L, desired_L, atol=1e-12)
|
||||
_assert_allclose_sparse(d, desired_d, atol=1e-12)
|
||||
|
||||
|
||||
def test_asymmetric_laplacian():
|
||||
# adjacency matrix
|
||||
A = [[0, 1, 0],
|
||||
[4, 2, 0],
|
||||
[0, 0, 0]]
|
||||
|
||||
# Laplacian matrix using out-degree
|
||||
L = [[1, -1, 0],
|
||||
[-4, 4, 0],
|
||||
[0, 0, 0]]
|
||||
d = [1, 4, 0]
|
||||
_check_laplacian(A, L, d, normed=False, use_out_degree=True)
|
||||
|
||||
# normalized Laplacian matrix using out-degree
|
||||
L = [[1, -0.5, 0],
|
||||
[-2, 1, 0],
|
||||
[0, 0, 0]]
|
||||
d = [1, 2, 1]
|
||||
_check_laplacian(A, L, d, normed=True, use_out_degree=True)
|
||||
|
||||
# Laplacian matrix using in-degree
|
||||
L = [[4, -1, 0],
|
||||
[-4, 1, 0],
|
||||
[0, 0, 0]]
|
||||
d = [4, 1, 0]
|
||||
_check_laplacian(A, L, d, normed=False, use_out_degree=False)
|
||||
|
||||
# normalized Laplacian matrix using in-degree
|
||||
L = [[1, -0.5, 0],
|
||||
[-2, 1, 0],
|
||||
[0, 0, 0]]
|
||||
d = [2, 1, 1]
|
||||
_check_laplacian(A, L, d, normed=True, use_out_degree=False)
|
||||
|
||||
|
||||
def test_sparse_formats():
|
||||
for fmt in ('csr', 'csc', 'coo', 'lil', 'dok', 'dia', 'bsr'):
|
||||
mat = sparse.diags([1, 1], [-1, 1], shape=(4,4), format=fmt)
|
||||
for normed in True, False:
|
||||
_check_symmetric_graph_laplacian(mat, normed)
|
||||
|
||||
@@ -0,0 +1,121 @@
|
||||
from __future__ import division, print_function, absolute_import
|
||||
|
||||
import numpy as np
|
||||
from numpy.testing import assert_equal
|
||||
from scipy.sparse.csgraph import (reverse_cuthill_mckee,
|
||||
maximum_bipartite_matching, structural_rank)
|
||||
from scipy.sparse import diags, csc_matrix, csr_matrix, coo_matrix
|
||||
|
||||
def test_graph_reverse_cuthill_mckee():
|
||||
A = np.array([[1, 0, 0, 0, 1, 0, 0, 0],
|
||||
[0, 1, 1, 0, 0, 1, 0, 1],
|
||||
[0, 1, 1, 0, 1, 0, 0, 0],
|
||||
[0, 0, 0, 1, 0, 0, 1, 0],
|
||||
[1, 0, 1, 0, 1, 0, 0, 0],
|
||||
[0, 1, 0, 0, 0, 1, 0, 1],
|
||||
[0, 0, 0, 1, 0, 0, 1, 0],
|
||||
[0, 1, 0, 0, 0, 1, 0, 1]], dtype=int)
|
||||
|
||||
graph = csr_matrix(A)
|
||||
perm = reverse_cuthill_mckee(graph)
|
||||
correct_perm = np.array([6, 3, 7, 5, 1, 2, 4, 0])
|
||||
assert_equal(perm, correct_perm)
|
||||
|
||||
# Test int64 indices input
|
||||
graph.indices = graph.indices.astype('int64')
|
||||
graph.indptr = graph.indptr.astype('int64')
|
||||
perm = reverse_cuthill_mckee(graph, True)
|
||||
assert_equal(perm, correct_perm)
|
||||
|
||||
|
||||
def test_graph_reverse_cuthill_mckee_ordering():
|
||||
data = np.ones(63,dtype=int)
|
||||
rows = np.array([0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2,
|
||||
2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5,
|
||||
6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 8, 9, 9,
|
||||
9, 10, 10, 10, 10, 10, 11, 11, 11, 11,
|
||||
12, 12, 12, 13, 13, 13, 13, 14, 14, 14,
|
||||
14, 15, 15, 15, 15, 15])
|
||||
cols = np.array([0, 2, 5, 8, 10, 1, 3, 9, 11, 0, 2,
|
||||
7, 10, 1, 3, 11, 4, 6, 12, 14, 0, 7, 13,
|
||||
15, 4, 6, 14, 2, 5, 7, 15, 0, 8, 10, 13,
|
||||
1, 9, 11, 0, 2, 8, 10, 15, 1, 3, 9, 11,
|
||||
4, 12, 14, 5, 8, 13, 15, 4, 6, 12, 14,
|
||||
5, 7, 10, 13, 15])
|
||||
graph = coo_matrix((data, (rows,cols))).tocsr()
|
||||
perm = reverse_cuthill_mckee(graph)
|
||||
correct_perm = np.array([12, 14, 4, 6, 10, 8, 2, 15,
|
||||
0, 13, 7, 5, 9, 11, 1, 3])
|
||||
assert_equal(perm, correct_perm)
|
||||
|
||||
|
||||
def test_graph_maximum_bipartite_matching():
|
||||
A = diags(np.ones(25), offsets=0, format='csc')
|
||||
rand_perm = np.random.permutation(25)
|
||||
rand_perm2 = np.random.permutation(25)
|
||||
|
||||
Rrow = np.arange(25)
|
||||
Rcol = rand_perm
|
||||
Rdata = np.ones(25,dtype=int)
|
||||
Rmat = coo_matrix((Rdata,(Rrow,Rcol))).tocsc()
|
||||
|
||||
Crow = rand_perm2
|
||||
Ccol = np.arange(25)
|
||||
Cdata = np.ones(25,dtype=int)
|
||||
Cmat = coo_matrix((Cdata,(Crow,Ccol))).tocsc()
|
||||
# Randomly permute identity matrix
|
||||
B = Rmat*A*Cmat
|
||||
|
||||
# Row permute
|
||||
perm = maximum_bipartite_matching(B,perm_type='row')
|
||||
Rrow = np.arange(25)
|
||||
Rcol = perm
|
||||
Rdata = np.ones(25,dtype=int)
|
||||
Rmat = coo_matrix((Rdata,(Rrow,Rcol))).tocsc()
|
||||
C1 = Rmat*B
|
||||
|
||||
# Column permute
|
||||
perm2 = maximum_bipartite_matching(B,perm_type='column')
|
||||
Crow = perm2
|
||||
Ccol = np.arange(25)
|
||||
Cdata = np.ones(25,dtype=int)
|
||||
Cmat = coo_matrix((Cdata,(Crow,Ccol))).tocsc()
|
||||
C2 = B*Cmat
|
||||
|
||||
# Should get identity matrix back
|
||||
assert_equal(any(C1.diagonal() == 0), False)
|
||||
assert_equal(any(C2.diagonal() == 0), False)
|
||||
|
||||
# Test int64 indices input
|
||||
B.indices = B.indices.astype('int64')
|
||||
B.indptr = B.indptr.astype('int64')
|
||||
perm = maximum_bipartite_matching(B,perm_type='row')
|
||||
Rrow = np.arange(25)
|
||||
Rcol = perm
|
||||
Rdata = np.ones(25,dtype=int)
|
||||
Rmat = coo_matrix((Rdata,(Rrow,Rcol))).tocsc()
|
||||
C3 = Rmat*B
|
||||
assert_equal(any(C3.diagonal() == 0), False)
|
||||
|
||||
|
||||
def test_graph_structural_rank():
|
||||
# Test square matrix #1
|
||||
A = csc_matrix([[1, 1, 0],
|
||||
[1, 0, 1],
|
||||
[0, 1, 0]])
|
||||
assert_equal(structural_rank(A), 3)
|
||||
|
||||
# Test square matrix #2
|
||||
rows = np.array([0,0,0,0,0,1,1,2,2,3,3,3,3,3,3,4,4,5,5,6,6,7,7])
|
||||
cols = np.array([0,1,2,3,4,2,5,2,6,0,1,3,5,6,7,4,5,5,6,2,6,2,4])
|
||||
data = np.ones_like(rows)
|
||||
B = coo_matrix((data,(rows,cols)), shape=(8,8))
|
||||
assert_equal(structural_rank(B), 6)
|
||||
|
||||
#Test non-square matrix
|
||||
C = csc_matrix([[1, 0, 2, 0],
|
||||
[2, 0, 4, 0]])
|
||||
assert_equal(structural_rank(C), 2)
|
||||
|
||||
#Test tall matrix
|
||||
assert_equal(structural_rank(C.T), 2)
|
||||
+202
@@ -0,0 +1,202 @@
|
||||
from __future__ import division, print_function, absolute_import
|
||||
|
||||
import numpy as np
|
||||
from numpy.testing import assert_array_almost_equal, assert_array_equal
|
||||
from pytest import raises as assert_raises
|
||||
from scipy.sparse.csgraph import (shortest_path, dijkstra, johnson,
|
||||
bellman_ford, construct_dist_matrix, NegativeCycleError)
|
||||
|
||||
|
||||
directed_G = np.array([[0, 3, 3, 0, 0],
|
||||
[0, 0, 0, 2, 4],
|
||||
[0, 0, 0, 0, 0],
|
||||
[1, 0, 0, 0, 0],
|
||||
[2, 0, 0, 2, 0]], dtype=float)
|
||||
|
||||
undirected_G = np.array([[0, 3, 3, 1, 2],
|
||||
[3, 0, 0, 2, 4],
|
||||
[3, 0, 0, 0, 0],
|
||||
[1, 2, 0, 0, 2],
|
||||
[2, 4, 0, 2, 0]], dtype=float)
|
||||
|
||||
unweighted_G = (directed_G > 0).astype(float)
|
||||
|
||||
directed_SP = [[0, 3, 3, 5, 7],
|
||||
[3, 0, 6, 2, 4],
|
||||
[np.inf, np.inf, 0, np.inf, np.inf],
|
||||
[1, 4, 4, 0, 8],
|
||||
[2, 5, 5, 2, 0]]
|
||||
|
||||
directed_pred = np.array([[-9999, 0, 0, 1, 1],
|
||||
[3, -9999, 0, 1, 1],
|
||||
[-9999, -9999, -9999, -9999, -9999],
|
||||
[3, 0, 0, -9999, 1],
|
||||
[4, 0, 0, 4, -9999]], dtype=float)
|
||||
|
||||
undirected_SP = np.array([[0, 3, 3, 1, 2],
|
||||
[3, 0, 6, 2, 4],
|
||||
[3, 6, 0, 4, 5],
|
||||
[1, 2, 4, 0, 2],
|
||||
[2, 4, 5, 2, 0]], dtype=float)
|
||||
|
||||
undirected_SP_limit_2 = np.array([[0, np.inf, np.inf, 1, 2],
|
||||
[np.inf, 0, np.inf, 2, np.inf],
|
||||
[np.inf, np.inf, 0, np.inf, np.inf],
|
||||
[1, 2, np.inf, 0, 2],
|
||||
[2, np.inf, np.inf, 2, 0]], dtype=float)
|
||||
|
||||
undirected_SP_limit_0 = np.ones((5, 5), dtype=float) - np.eye(5)
|
||||
undirected_SP_limit_0[undirected_SP_limit_0 > 0] = np.inf
|
||||
|
||||
undirected_pred = np.array([[-9999, 0, 0, 0, 0],
|
||||
[1, -9999, 0, 1, 1],
|
||||
[2, 0, -9999, 0, 0],
|
||||
[3, 3, 0, -9999, 3],
|
||||
[4, 4, 0, 4, -9999]], dtype=float)
|
||||
|
||||
methods = ['auto', 'FW', 'D', 'BF', 'J']
|
||||
|
||||
|
||||
def test_dijkstra_limit():
|
||||
limits = [0, 2, np.inf]
|
||||
results = [undirected_SP_limit_0,
|
||||
undirected_SP_limit_2,
|
||||
undirected_SP]
|
||||
|
||||
def check(limit, result):
|
||||
SP = dijkstra(undirected_G, directed=False, limit=limit)
|
||||
assert_array_almost_equal(SP, result)
|
||||
|
||||
for limit, result in zip(limits, results):
|
||||
check(limit, result)
|
||||
|
||||
|
||||
def test_directed():
|
||||
def check(method):
|
||||
SP = shortest_path(directed_G, method=method, directed=True,
|
||||
overwrite=False)
|
||||
assert_array_almost_equal(SP, directed_SP)
|
||||
|
||||
for method in methods:
|
||||
check(method)
|
||||
|
||||
|
||||
def test_undirected():
|
||||
def check(method, directed_in):
|
||||
if directed_in:
|
||||
SP1 = shortest_path(directed_G, method=method, directed=False,
|
||||
overwrite=False)
|
||||
assert_array_almost_equal(SP1, undirected_SP)
|
||||
else:
|
||||
SP2 = shortest_path(undirected_G, method=method, directed=True,
|
||||
overwrite=False)
|
||||
assert_array_almost_equal(SP2, undirected_SP)
|
||||
|
||||
for method in methods:
|
||||
for directed_in in (True, False):
|
||||
check(method, directed_in)
|
||||
|
||||
|
||||
def test_shortest_path_indices():
|
||||
indices = np.arange(4)
|
||||
|
||||
def check(func, indshape):
|
||||
outshape = indshape + (5,)
|
||||
SP = func(directed_G, directed=False,
|
||||
indices=indices.reshape(indshape))
|
||||
assert_array_almost_equal(SP, undirected_SP[indices].reshape(outshape))
|
||||
|
||||
for indshape in [(4,), (4, 1), (2, 2)]:
|
||||
for func in (dijkstra, bellman_ford, johnson, shortest_path):
|
||||
check(func, indshape)
|
||||
|
||||
assert_raises(ValueError, shortest_path, directed_G, method='FW',
|
||||
indices=indices)
|
||||
|
||||
|
||||
def test_predecessors():
|
||||
SP_res = {True: directed_SP,
|
||||
False: undirected_SP}
|
||||
pred_res = {True: directed_pred,
|
||||
False: undirected_pred}
|
||||
|
||||
def check(method, directed):
|
||||
SP, pred = shortest_path(directed_G, method, directed=directed,
|
||||
overwrite=False,
|
||||
return_predecessors=True)
|
||||
assert_array_almost_equal(SP, SP_res[directed])
|
||||
assert_array_almost_equal(pred, pred_res[directed])
|
||||
|
||||
for method in methods:
|
||||
for directed in (True, False):
|
||||
check(method, directed)
|
||||
|
||||
|
||||
def test_construct_shortest_path():
|
||||
def check(method, directed):
|
||||
SP1, pred = shortest_path(directed_G,
|
||||
directed=directed,
|
||||
overwrite=False,
|
||||
return_predecessors=True)
|
||||
SP2 = construct_dist_matrix(directed_G, pred, directed=directed)
|
||||
assert_array_almost_equal(SP1, SP2)
|
||||
|
||||
for method in methods:
|
||||
for directed in (True, False):
|
||||
check(method, directed)
|
||||
|
||||
|
||||
def test_unweighted_path():
|
||||
def check(method, directed):
|
||||
SP1 = shortest_path(directed_G,
|
||||
directed=directed,
|
||||
overwrite=False,
|
||||
unweighted=True)
|
||||
SP2 = shortest_path(unweighted_G,
|
||||
directed=directed,
|
||||
overwrite=False,
|
||||
unweighted=False)
|
||||
assert_array_almost_equal(SP1, SP2)
|
||||
|
||||
for method in methods:
|
||||
for directed in (True, False):
|
||||
check(method, directed)
|
||||
|
||||
|
||||
def test_negative_cycles():
|
||||
# create a small graph with a negative cycle
|
||||
graph = np.ones([5, 5])
|
||||
graph.flat[::6] = 0
|
||||
graph[1, 2] = -2
|
||||
|
||||
def check(method, directed):
|
||||
assert_raises(NegativeCycleError, shortest_path, graph, method,
|
||||
directed)
|
||||
|
||||
for method in ['FW', 'J', 'BF']:
|
||||
for directed in (True, False):
|
||||
check(method, directed)
|
||||
|
||||
|
||||
def test_masked_input():
|
||||
G = np.ma.masked_equal(directed_G, 0)
|
||||
|
||||
def check(method):
|
||||
SP = shortest_path(directed_G, method=method, directed=True,
|
||||
overwrite=False)
|
||||
assert_array_almost_equal(SP, directed_SP)
|
||||
|
||||
for method in methods:
|
||||
check(method)
|
||||
|
||||
|
||||
def test_overwrite():
|
||||
G = np.array([[0, 3, 3, 1, 2],
|
||||
[3, 0, 0, 2, 4],
|
||||
[3, 0, 0, 0, 0],
|
||||
[1, 2, 0, 0, 2],
|
||||
[2, 4, 0, 2, 0]], dtype=float)
|
||||
foo = G.copy()
|
||||
shortest_path(foo, overwrite=False)
|
||||
assert_array_equal(foo, G)
|
||||
|
||||
+67
@@ -0,0 +1,67 @@
|
||||
"""Test the minimum spanning tree function"""
|
||||
from __future__ import division, print_function, absolute_import
|
||||
|
||||
import numpy as np
|
||||
from numpy.testing import assert_
|
||||
import numpy.testing as npt
|
||||
from scipy.sparse import csr_matrix
|
||||
from scipy.sparse.csgraph import minimum_spanning_tree
|
||||
|
||||
|
||||
def test_minimum_spanning_tree():
|
||||
|
||||
# Create a graph with two connected components.
|
||||
graph = [[0,1,0,0,0],
|
||||
[1,0,0,0,0],
|
||||
[0,0,0,8,5],
|
||||
[0,0,8,0,1],
|
||||
[0,0,5,1,0]]
|
||||
graph = np.asarray(graph)
|
||||
|
||||
# Create the expected spanning tree.
|
||||
expected = [[0,1,0,0,0],
|
||||
[0,0,0,0,0],
|
||||
[0,0,0,0,5],
|
||||
[0,0,0,0,1],
|
||||
[0,0,0,0,0]]
|
||||
expected = np.asarray(expected)
|
||||
|
||||
# Ensure minimum spanning tree code gives this expected output.
|
||||
csgraph = csr_matrix(graph)
|
||||
mintree = minimum_spanning_tree(csgraph)
|
||||
npt.assert_array_equal(mintree.todense(), expected,
|
||||
'Incorrect spanning tree found.')
|
||||
|
||||
# Ensure that the original graph was not modified.
|
||||
npt.assert_array_equal(csgraph.todense(), graph,
|
||||
'Original graph was modified.')
|
||||
|
||||
# Now let the algorithm modify the csgraph in place.
|
||||
mintree = minimum_spanning_tree(csgraph, overwrite=True)
|
||||
npt.assert_array_equal(mintree.todense(), expected,
|
||||
'Graph was not properly modified to contain MST.')
|
||||
|
||||
np.random.seed(1234)
|
||||
for N in (5, 10, 15, 20):
|
||||
|
||||
# Create a random graph.
|
||||
graph = 3 + np.random.random((N, N))
|
||||
csgraph = csr_matrix(graph)
|
||||
|
||||
# The spanning tree has at most N - 1 edges.
|
||||
mintree = minimum_spanning_tree(csgraph)
|
||||
assert_(mintree.nnz < N)
|
||||
|
||||
# Set the sub diagonal to 1 to create a known spanning tree.
|
||||
idx = np.arange(N-1)
|
||||
graph[idx,idx+1] = 1
|
||||
csgraph = csr_matrix(graph)
|
||||
mintree = minimum_spanning_tree(csgraph)
|
||||
|
||||
# We expect to see this pattern in the spanning tree and otherwise
|
||||
# have this zero.
|
||||
expected = np.zeros((N, N))
|
||||
expected[idx, idx+1] = 1
|
||||
|
||||
npt.assert_array_equal(mintree.todense(), expected,
|
||||
'Incorrect spanning tree found.')
|
||||
@@ -0,0 +1,70 @@
|
||||
from __future__ import division, print_function, absolute_import
|
||||
|
||||
import numpy as np
|
||||
from numpy.testing import assert_array_almost_equal
|
||||
from scipy.sparse.csgraph import (breadth_first_tree, depth_first_tree,
|
||||
csgraph_to_dense, csgraph_from_dense)
|
||||
|
||||
|
||||
def test_graph_breadth_first():
|
||||
csgraph = np.array([[0, 1, 2, 0, 0],
|
||||
[1, 0, 0, 0, 3],
|
||||
[2, 0, 0, 7, 0],
|
||||
[0, 0, 7, 0, 1],
|
||||
[0, 3, 0, 1, 0]])
|
||||
csgraph = csgraph_from_dense(csgraph, null_value=0)
|
||||
|
||||
bfirst = np.array([[0, 1, 2, 0, 0],
|
||||
[0, 0, 0, 0, 3],
|
||||
[0, 0, 0, 7, 0],
|
||||
[0, 0, 0, 0, 0],
|
||||
[0, 0, 0, 0, 0]])
|
||||
|
||||
for directed in [True, False]:
|
||||
bfirst_test = breadth_first_tree(csgraph, 0, directed)
|
||||
assert_array_almost_equal(csgraph_to_dense(bfirst_test),
|
||||
bfirst)
|
||||
|
||||
|
||||
def test_graph_depth_first():
|
||||
csgraph = np.array([[0, 1, 2, 0, 0],
|
||||
[1, 0, 0, 0, 3],
|
||||
[2, 0, 0, 7, 0],
|
||||
[0, 0, 7, 0, 1],
|
||||
[0, 3, 0, 1, 0]])
|
||||
csgraph = csgraph_from_dense(csgraph, null_value=0)
|
||||
|
||||
dfirst = np.array([[0, 1, 0, 0, 0],
|
||||
[0, 0, 0, 0, 3],
|
||||
[0, 0, 0, 0, 0],
|
||||
[0, 0, 7, 0, 0],
|
||||
[0, 0, 0, 1, 0]])
|
||||
|
||||
for directed in [True, False]:
|
||||
dfirst_test = depth_first_tree(csgraph, 0, directed)
|
||||
assert_array_almost_equal(csgraph_to_dense(dfirst_test),
|
||||
dfirst)
|
||||
|
||||
|
||||
def test_graph_breadth_first_trivial_graph():
|
||||
csgraph = np.array([[0]])
|
||||
csgraph = csgraph_from_dense(csgraph, null_value=0)
|
||||
|
||||
bfirst = np.array([[0]])
|
||||
|
||||
for directed in [True, False]:
|
||||
bfirst_test = breadth_first_tree(csgraph, 0, directed)
|
||||
assert_array_almost_equal(csgraph_to_dense(bfirst_test),
|
||||
bfirst)
|
||||
|
||||
|
||||
def test_graph_depth_first_trivial_graph():
|
||||
csgraph = np.array([[0]])
|
||||
csgraph = csgraph_from_dense(csgraph, null_value=0)
|
||||
|
||||
bfirst = np.array([[0]])
|
||||
|
||||
for directed in [True, False]:
|
||||
bfirst_test = depth_first_tree(csgraph, 0, directed)
|
||||
assert_array_almost_equal(csgraph_to_dense(bfirst_test),
|
||||
bfirst)
|
||||
@@ -0,0 +1,489 @@
|
||||
"""Compressed Sparse Row matrix format"""
|
||||
|
||||
from __future__ import division, print_function, absolute_import
|
||||
|
||||
__docformat__ = "restructuredtext en"
|
||||
|
||||
__all__ = ['csr_matrix', 'isspmatrix_csr']
|
||||
|
||||
|
||||
import numpy as np
|
||||
from scipy._lib.six import xrange
|
||||
|
||||
from .base import spmatrix
|
||||
|
||||
from ._sparsetools import csr_tocsc, csr_tobsr, csr_count_blocks, \
|
||||
get_csr_submatrix, csr_sample_values
|
||||
from .sputils import (upcast, isintlike, IndexMixin, issequence,
|
||||
get_index_dtype, ismatrix)
|
||||
|
||||
from .compressed import _cs_matrix
|
||||
|
||||
|
||||
class csr_matrix(_cs_matrix, IndexMixin):
|
||||
"""
|
||||
Compressed Sparse Row matrix
|
||||
|
||||
This can be instantiated in several ways:
|
||||
csr_matrix(D)
|
||||
with a dense matrix or rank-2 ndarray D
|
||||
|
||||
csr_matrix(S)
|
||||
with another sparse matrix S (equivalent to S.tocsr())
|
||||
|
||||
csr_matrix((M, N), [dtype])
|
||||
to construct an empty matrix with shape (M, N)
|
||||
dtype is optional, defaulting to dtype='d'.
|
||||
|
||||
csr_matrix((data, (row_ind, col_ind)), [shape=(M, N)])
|
||||
where ``data``, ``row_ind`` and ``col_ind`` satisfy the
|
||||
relationship ``a[row_ind[k], col_ind[k]] = data[k]``.
|
||||
|
||||
csr_matrix((data, indices, indptr), [shape=(M, N)])
|
||||
is the standard CSR representation where the column indices for
|
||||
row i are stored in ``indices[indptr[i]:indptr[i+1]]`` and their
|
||||
corresponding values are stored in ``data[indptr[i]:indptr[i+1]]``.
|
||||
If the shape parameter is not supplied, the matrix dimensions
|
||||
are inferred from the index arrays.
|
||||
|
||||
Attributes
|
||||
----------
|
||||
dtype : dtype
|
||||
Data type of the matrix
|
||||
shape : 2-tuple
|
||||
Shape of the matrix
|
||||
ndim : int
|
||||
Number of dimensions (this is always 2)
|
||||
nnz
|
||||
Number of nonzero elements
|
||||
data
|
||||
CSR format data array of the matrix
|
||||
indices
|
||||
CSR format index array of the matrix
|
||||
indptr
|
||||
CSR format index pointer array of the matrix
|
||||
has_sorted_indices
|
||||
Whether indices are sorted
|
||||
|
||||
Notes
|
||||
-----
|
||||
|
||||
Sparse matrices can be used in arithmetic operations: they support
|
||||
addition, subtraction, multiplication, division, and matrix power.
|
||||
|
||||
Advantages of the CSR format
|
||||
- efficient arithmetic operations CSR + CSR, CSR * CSR, etc.
|
||||
- efficient row slicing
|
||||
- fast matrix vector products
|
||||
|
||||
Disadvantages of the CSR format
|
||||
- slow column slicing operations (consider CSC)
|
||||
- changes to the sparsity structure are expensive (consider LIL or DOK)
|
||||
|
||||
Examples
|
||||
--------
|
||||
|
||||
>>> import numpy as np
|
||||
>>> from scipy.sparse import csr_matrix
|
||||
>>> csr_matrix((3, 4), dtype=np.int8).toarray()
|
||||
array([[0, 0, 0, 0],
|
||||
[0, 0, 0, 0],
|
||||
[0, 0, 0, 0]], dtype=int8)
|
||||
|
||||
>>> row = np.array([0, 0, 1, 2, 2, 2])
|
||||
>>> col = np.array([0, 2, 2, 0, 1, 2])
|
||||
>>> data = np.array([1, 2, 3, 4, 5, 6])
|
||||
>>> csr_matrix((data, (row, col)), shape=(3, 3)).toarray()
|
||||
array([[1, 0, 2],
|
||||
[0, 0, 3],
|
||||
[4, 5, 6]])
|
||||
|
||||
>>> indptr = np.array([0, 2, 3, 6])
|
||||
>>> indices = np.array([0, 2, 2, 0, 1, 2])
|
||||
>>> data = np.array([1, 2, 3, 4, 5, 6])
|
||||
>>> csr_matrix((data, indices, indptr), shape=(3, 3)).toarray()
|
||||
array([[1, 0, 2],
|
||||
[0, 0, 3],
|
||||
[4, 5, 6]])
|
||||
|
||||
As an example of how to construct a CSR matrix incrementally,
|
||||
the following snippet builds a term-document matrix from texts:
|
||||
|
||||
>>> docs = [["hello", "world", "hello"], ["goodbye", "cruel", "world"]]
|
||||
>>> indptr = [0]
|
||||
>>> indices = []
|
||||
>>> data = []
|
||||
>>> vocabulary = {}
|
||||
>>> for d in docs:
|
||||
... for term in d:
|
||||
... index = vocabulary.setdefault(term, len(vocabulary))
|
||||
... indices.append(index)
|
||||
... data.append(1)
|
||||
... indptr.append(len(indices))
|
||||
...
|
||||
>>> csr_matrix((data, indices, indptr), dtype=int).toarray()
|
||||
array([[2, 1, 0, 0],
|
||||
[0, 1, 1, 1]])
|
||||
|
||||
"""
|
||||
format = 'csr'
|
||||
|
||||
def transpose(self, axes=None, copy=False):
|
||||
if axes is not None:
|
||||
raise ValueError(("Sparse matrices do not support "
|
||||
"an 'axes' parameter because swapping "
|
||||
"dimensions is the only logical permutation."))
|
||||
|
||||
M, N = self.shape
|
||||
|
||||
from .csc import csc_matrix
|
||||
return csc_matrix((self.data, self.indices,
|
||||
self.indptr), shape=(N, M), copy=copy)
|
||||
|
||||
transpose.__doc__ = spmatrix.transpose.__doc__
|
||||
|
||||
def tolil(self, copy=False):
|
||||
from .lil import lil_matrix
|
||||
lil = lil_matrix(self.shape,dtype=self.dtype)
|
||||
|
||||
self.sum_duplicates()
|
||||
ptr,ind,dat = self.indptr,self.indices,self.data
|
||||
rows, data = lil.rows, lil.data
|
||||
|
||||
for n in xrange(self.shape[0]):
|
||||
start = ptr[n]
|
||||
end = ptr[n+1]
|
||||
rows[n] = ind[start:end].tolist()
|
||||
data[n] = dat[start:end].tolist()
|
||||
|
||||
return lil
|
||||
|
||||
tolil.__doc__ = spmatrix.tolil.__doc__
|
||||
|
||||
def tocsr(self, copy=False):
|
||||
if copy:
|
||||
return self.copy()
|
||||
else:
|
||||
return self
|
||||
|
||||
tocsr.__doc__ = spmatrix.tocsr.__doc__
|
||||
|
||||
def tocsc(self, copy=False):
|
||||
idx_dtype = get_index_dtype((self.indptr, self.indices),
|
||||
maxval=max(self.nnz, self.shape[0]))
|
||||
indptr = np.empty(self.shape[1] + 1, dtype=idx_dtype)
|
||||
indices = np.empty(self.nnz, dtype=idx_dtype)
|
||||
data = np.empty(self.nnz, dtype=upcast(self.dtype))
|
||||
|
||||
csr_tocsc(self.shape[0], self.shape[1],
|
||||
self.indptr.astype(idx_dtype),
|
||||
self.indices.astype(idx_dtype),
|
||||
self.data,
|
||||
indptr,
|
||||
indices,
|
||||
data)
|
||||
|
||||
from .csc import csc_matrix
|
||||
A = csc_matrix((data, indices, indptr), shape=self.shape)
|
||||
A.has_sorted_indices = True
|
||||
return A
|
||||
|
||||
tocsc.__doc__ = spmatrix.tocsc.__doc__
|
||||
|
||||
def tobsr(self, blocksize=None, copy=True):
|
||||
from .bsr import bsr_matrix
|
||||
|
||||
if blocksize is None:
|
||||
from .spfuncs import estimate_blocksize
|
||||
return self.tobsr(blocksize=estimate_blocksize(self))
|
||||
|
||||
elif blocksize == (1,1):
|
||||
arg1 = (self.data.reshape(-1,1,1),self.indices,self.indptr)
|
||||
return bsr_matrix(arg1, shape=self.shape, copy=copy)
|
||||
|
||||
else:
|
||||
R,C = blocksize
|
||||
M,N = self.shape
|
||||
|
||||
if R < 1 or C < 1 or M % R != 0 or N % C != 0:
|
||||
raise ValueError('invalid blocksize %s' % blocksize)
|
||||
|
||||
blks = csr_count_blocks(M,N,R,C,self.indptr,self.indices)
|
||||
|
||||
idx_dtype = get_index_dtype((self.indptr, self.indices),
|
||||
maxval=max(N//C, blks))
|
||||
indptr = np.empty(M//R+1, dtype=idx_dtype)
|
||||
indices = np.empty(blks, dtype=idx_dtype)
|
||||
data = np.zeros((blks,R,C), dtype=self.dtype)
|
||||
|
||||
csr_tobsr(M, N, R, C,
|
||||
self.indptr.astype(idx_dtype),
|
||||
self.indices.astype(idx_dtype),
|
||||
self.data,
|
||||
indptr, indices, data.ravel())
|
||||
|
||||
return bsr_matrix((data,indices,indptr), shape=self.shape)
|
||||
|
||||
tobsr.__doc__ = spmatrix.tobsr.__doc__
|
||||
|
||||
# these functions are used by the parent class (_cs_matrix)
|
||||
# to remove redudancy between csc_matrix and csr_matrix
|
||||
def _swap(self, x):
|
||||
"""swap the members of x if this is a column-oriented matrix
|
||||
"""
|
||||
return x
|
||||
|
||||
def __getitem__(self, key):
|
||||
def asindices(x):
|
||||
try:
|
||||
x = np.asarray(x)
|
||||
|
||||
# Check index contents to avoid creating 64bit arrays needlessly
|
||||
idx_dtype = get_index_dtype((x,), check_contents=True)
|
||||
if idx_dtype != x.dtype:
|
||||
x = x.astype(idx_dtype)
|
||||
except Exception:
|
||||
raise IndexError('invalid index')
|
||||
else:
|
||||
return x
|
||||
|
||||
def check_bounds(indices, N):
|
||||
if indices.size == 0:
|
||||
return (0, 0)
|
||||
|
||||
max_indx = indices.max()
|
||||
if max_indx >= N:
|
||||
raise IndexError('index (%d) out of range' % max_indx)
|
||||
|
||||
min_indx = indices.min()
|
||||
if min_indx < -N:
|
||||
raise IndexError('index (%d) out of range' % (N + min_indx))
|
||||
|
||||
return min_indx, max_indx
|
||||
|
||||
def extractor(indices,N):
|
||||
"""Return a sparse matrix P so that P*self implements
|
||||
slicing of the form self[[1,2,3],:]
|
||||
"""
|
||||
indices = asindices(indices).copy()
|
||||
|
||||
min_indx, max_indx = check_bounds(indices, N)
|
||||
|
||||
if min_indx < 0:
|
||||
indices[indices < 0] += N
|
||||
|
||||
indptr = np.arange(len(indices)+1, dtype=indices.dtype)
|
||||
data = np.ones(len(indices), dtype=self.dtype)
|
||||
shape = (len(indices),N)
|
||||
|
||||
return csr_matrix((data,indices,indptr), shape=shape,
|
||||
dtype=self.dtype, copy=False)
|
||||
|
||||
row, col = self._unpack_index(key)
|
||||
|
||||
# First attempt to use original row optimized methods
|
||||
# [1, ?]
|
||||
if isintlike(row):
|
||||
# [i, j]
|
||||
if isintlike(col):
|
||||
return self._get_single_element(row, col)
|
||||
# [i, 1:2]
|
||||
elif isinstance(col, slice):
|
||||
return self._get_row_slice(row, col)
|
||||
# [i, [1, 2]]
|
||||
elif issequence(col):
|
||||
P = extractor(col,self.shape[1]).T
|
||||
return self[row, :] * P
|
||||
elif isinstance(row, slice):
|
||||
# [1:2,??]
|
||||
if ((isintlike(col) and row.step in (1, None)) or
|
||||
(isinstance(col, slice) and
|
||||
col.step in (1, None) and
|
||||
row.step in (1, None))):
|
||||
# col is int or slice with step 1, row is slice with step 1.
|
||||
return self._get_submatrix(row, col)
|
||||
elif issequence(col):
|
||||
# row is slice, col is sequence.
|
||||
P = extractor(col,self.shape[1]).T # [1:2,[1,2]]
|
||||
sliced = self
|
||||
if row != slice(None, None, None):
|
||||
sliced = sliced[row,:]
|
||||
return sliced * P
|
||||
|
||||
elif issequence(row):
|
||||
# [[1,2],??]
|
||||
if isintlike(col) or isinstance(col,slice):
|
||||
P = extractor(row, self.shape[0]) # [[1,2],j] or [[1,2],1:2]
|
||||
extracted = P * self
|
||||
if col == slice(None, None, None):
|
||||
return extracted
|
||||
else:
|
||||
return extracted[:,col]
|
||||
|
||||
elif ismatrix(row) and issequence(col):
|
||||
if len(row[0]) == 1 and isintlike(row[0][0]):
|
||||
# [[[1],[2]], [1,2]], outer indexing
|
||||
row = asindices(row)
|
||||
P_row = extractor(row[:,0], self.shape[0])
|
||||
P_col = extractor(col, self.shape[1]).T
|
||||
return P_row * self * P_col
|
||||
|
||||
if not (issequence(col) and issequence(row)):
|
||||
# Sample elementwise
|
||||
row, col = self._index_to_arrays(row, col)
|
||||
|
||||
row = asindices(row)
|
||||
col = asindices(col)
|
||||
if row.shape != col.shape:
|
||||
raise IndexError('number of row and column indices differ')
|
||||
assert row.ndim <= 2
|
||||
|
||||
num_samples = np.size(row)
|
||||
if num_samples == 0:
|
||||
return csr_matrix(np.atleast_2d(row).shape, dtype=self.dtype)
|
||||
check_bounds(row, self.shape[0])
|
||||
check_bounds(col, self.shape[1])
|
||||
|
||||
val = np.empty(num_samples, dtype=self.dtype)
|
||||
csr_sample_values(self.shape[0], self.shape[1],
|
||||
self.indptr, self.indices, self.data,
|
||||
num_samples, row.ravel(), col.ravel(), val)
|
||||
if row.ndim == 1:
|
||||
# row and col are 1d
|
||||
return np.asmatrix(val)
|
||||
return self.__class__(val.reshape(row.shape))
|
||||
|
||||
def __iter__(self):
|
||||
indptr = np.zeros(2, dtype=self.indptr.dtype)
|
||||
shape = (1, self.shape[1])
|
||||
i0 = 0
|
||||
for i1 in self.indptr[1:]:
|
||||
indptr[1] = i1 - i0
|
||||
indices = self.indices[i0:i1]
|
||||
data = self.data[i0:i1]
|
||||
yield csr_matrix((data, indices, indptr), shape=shape, copy=True)
|
||||
i0 = i1
|
||||
|
||||
def getrow(self, i):
|
||||
"""Returns a copy of row i of the matrix, as a (1 x n)
|
||||
CSR matrix (row vector).
|
||||
"""
|
||||
M, N = self.shape
|
||||
i = int(i)
|
||||
if i < 0:
|
||||
i += M
|
||||
if i < 0 or i >= M:
|
||||
raise IndexError('index (%d) out of range' % i)
|
||||
idx = slice(*self.indptr[i:i+2])
|
||||
data = self.data[idx].copy()
|
||||
indices = self.indices[idx].copy()
|
||||
indptr = np.array([0, len(indices)], dtype=self.indptr.dtype)
|
||||
return csr_matrix((data, indices, indptr), shape=(1, N),
|
||||
dtype=self.dtype, copy=False)
|
||||
|
||||
def getcol(self, i):
|
||||
"""Returns a copy of column i of the matrix, as a (m x 1)
|
||||
CSR matrix (column vector).
|
||||
"""
|
||||
return self._get_submatrix(slice(None), i)
|
||||
|
||||
def _get_row_slice(self, i, cslice):
|
||||
"""Returns a copy of row self[i, cslice]
|
||||
"""
|
||||
M, N = self.shape
|
||||
|
||||
if i < 0:
|
||||
i += M
|
||||
|
||||
if i < 0 or i >= M:
|
||||
raise IndexError('index (%d) out of range' % i)
|
||||
|
||||
start, stop, stride = cslice.indices(N)
|
||||
|
||||
if stride == 1:
|
||||
# for stride == 1, get_csr_submatrix is faster
|
||||
row_indptr, row_indices, row_data = get_csr_submatrix(
|
||||
M, N, self.indptr, self.indices, self.data, i, i + 1,
|
||||
start, stop)
|
||||
else:
|
||||
# other strides need new code
|
||||
row_indices = self.indices[self.indptr[i]:self.indptr[i + 1]]
|
||||
row_data = self.data[self.indptr[i]:self.indptr[i + 1]]
|
||||
|
||||
if stride > 0:
|
||||
ind = (row_indices >= start) & (row_indices < stop)
|
||||
else:
|
||||
ind = (row_indices <= start) & (row_indices > stop)
|
||||
|
||||
if abs(stride) > 1:
|
||||
ind &= (row_indices - start) % stride == 0
|
||||
|
||||
row_indices = (row_indices[ind] - start) // stride
|
||||
row_data = row_data[ind]
|
||||
row_indptr = np.array([0, len(row_indices)])
|
||||
|
||||
if stride < 0:
|
||||
row_data = row_data[::-1]
|
||||
row_indices = abs(row_indices[::-1])
|
||||
|
||||
shape = (1, int(np.ceil(float(stop - start) / stride)))
|
||||
return csr_matrix((row_data, row_indices, row_indptr), shape=shape,
|
||||
dtype=self.dtype, copy=False)
|
||||
|
||||
def _get_submatrix(self, row_slice, col_slice):
|
||||
"""Return a submatrix of this matrix (new matrix is created)."""
|
||||
|
||||
def process_slice(sl, num):
|
||||
if isinstance(sl, slice):
|
||||
i0, i1, stride = sl.indices(num)
|
||||
if stride != 1:
|
||||
raise ValueError('slicing with step != 1 not supported')
|
||||
elif isintlike(sl):
|
||||
if sl < 0:
|
||||
sl += num
|
||||
i0, i1 = sl, sl + 1
|
||||
else:
|
||||
raise TypeError('expected slice or scalar')
|
||||
|
||||
if not (0 <= i0 <= num) or not (0 <= i1 <= num) or not (i0 <= i1):
|
||||
raise IndexError(
|
||||
"index out of bounds: 0 <= %d <= %d, 0 <= %d <= %d,"
|
||||
" %d <= %d" % (i0, num, i1, num, i0, i1))
|
||||
return i0, i1
|
||||
|
||||
M,N = self.shape
|
||||
i0, i1 = process_slice(row_slice, M)
|
||||
j0, j1 = process_slice(col_slice, N)
|
||||
|
||||
indptr, indices, data = get_csr_submatrix(
|
||||
M, N, self.indptr, self.indices, self.data, i0, i1, j0, j1)
|
||||
|
||||
shape = (i1 - i0, j1 - j0)
|
||||
return self.__class__((data, indices, indptr), shape=shape,
|
||||
dtype=self.dtype, copy=False)
|
||||
|
||||
|
||||
def isspmatrix_csr(x):
|
||||
"""Is x of csr_matrix type?
|
||||
|
||||
Parameters
|
||||
----------
|
||||
x
|
||||
object to check for being a csr matrix
|
||||
|
||||
Returns
|
||||
-------
|
||||
bool
|
||||
True if x is a csr matrix, False otherwise
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> from scipy.sparse import csr_matrix, isspmatrix_csr
|
||||
>>> isspmatrix_csr(csr_matrix([[5]]))
|
||||
True
|
||||
|
||||
>>> from scipy.sparse import csc_matrix, csr_matrix, isspmatrix_csc
|
||||
>>> isspmatrix_csr(csc_matrix([[5]]))
|
||||
False
|
||||
"""
|
||||
return isinstance(x, csr_matrix)
|
||||
@@ -0,0 +1,396 @@
|
||||
"""Base class for sparse matrice with a .data attribute
|
||||
|
||||
subclasses must provide a _with_data() method that
|
||||
creates a new matrix with the same sparsity pattern
|
||||
as self but with a different data array
|
||||
|
||||
"""
|
||||
|
||||
from __future__ import division, print_function, absolute_import
|
||||
|
||||
import numpy as np
|
||||
|
||||
from .base import spmatrix, _ufuncs_with_fixed_point_at_zero
|
||||
from .sputils import isscalarlike, validateaxis
|
||||
|
||||
__all__ = []
|
||||
|
||||
|
||||
# TODO implement all relevant operations
|
||||
# use .data.__methods__() instead of /=, *=, etc.
|
||||
class _data_matrix(spmatrix):
|
||||
def __init__(self):
|
||||
spmatrix.__init__(self)
|
||||
|
||||
def _get_dtype(self):
|
||||
return self.data.dtype
|
||||
|
||||
def _set_dtype(self, newtype):
|
||||
self.data.dtype = newtype
|
||||
dtype = property(fget=_get_dtype, fset=_set_dtype)
|
||||
|
||||
def _deduped_data(self):
|
||||
if hasattr(self, 'sum_duplicates'):
|
||||
self.sum_duplicates()
|
||||
return self.data
|
||||
|
||||
def __abs__(self):
|
||||
return self._with_data(abs(self._deduped_data()))
|
||||
|
||||
def _real(self):
|
||||
return self._with_data(self.data.real)
|
||||
|
||||
def _imag(self):
|
||||
return self._with_data(self.data.imag)
|
||||
|
||||
def __neg__(self):
|
||||
if self.dtype.kind == 'b':
|
||||
raise NotImplementedError('negating a sparse boolean '
|
||||
'matrix is not supported')
|
||||
return self._with_data(-self.data)
|
||||
|
||||
def __imul__(self, other): # self *= other
|
||||
if isscalarlike(other):
|
||||
self.data *= other
|
||||
return self
|
||||
else:
|
||||
return NotImplemented
|
||||
|
||||
def __itruediv__(self, other): # self /= other
|
||||
if isscalarlike(other):
|
||||
recip = 1.0 / other
|
||||
self.data *= recip
|
||||
return self
|
||||
else:
|
||||
return NotImplemented
|
||||
|
||||
def astype(self, dtype, casting='unsafe', copy=True):
|
||||
dtype = np.dtype(dtype)
|
||||
if self.dtype != dtype:
|
||||
return self._with_data(
|
||||
self._deduped_data().astype(dtype, casting=casting, copy=copy),
|
||||
copy=copy)
|
||||
elif copy:
|
||||
return self.copy()
|
||||
else:
|
||||
return self
|
||||
|
||||
astype.__doc__ = spmatrix.astype.__doc__
|
||||
|
||||
def conj(self, copy=True):
|
||||
if np.issubdtype(self.dtype, np.complexfloating):
|
||||
return self._with_data(self.data.conj(), copy=copy)
|
||||
elif copy:
|
||||
return self.copy()
|
||||
else:
|
||||
return self
|
||||
|
||||
conj.__doc__ = spmatrix.conj.__doc__
|
||||
|
||||
def copy(self):
|
||||
return self._with_data(self.data.copy(), copy=True)
|
||||
|
||||
copy.__doc__ = spmatrix.copy.__doc__
|
||||
|
||||
def count_nonzero(self):
|
||||
return np.count_nonzero(self._deduped_data())
|
||||
|
||||
count_nonzero.__doc__ = spmatrix.count_nonzero.__doc__
|
||||
|
||||
def power(self, n, dtype=None):
|
||||
"""
|
||||
This function performs element-wise power.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
n : n is a scalar
|
||||
|
||||
dtype : If dtype is not specified, the current dtype will be preserved.
|
||||
"""
|
||||
if not isscalarlike(n):
|
||||
raise NotImplementedError("input is not scalar")
|
||||
|
||||
data = self._deduped_data()
|
||||
if dtype is not None:
|
||||
data = data.astype(dtype)
|
||||
return self._with_data(data ** n)
|
||||
|
||||
###########################
|
||||
# Multiplication handlers #
|
||||
###########################
|
||||
|
||||
def _mul_scalar(self, other):
|
||||
return self._with_data(self.data * other)
|
||||
|
||||
|
||||
# Add the numpy unary ufuncs for which func(0) = 0 to _data_matrix.
|
||||
for npfunc in _ufuncs_with_fixed_point_at_zero:
|
||||
name = npfunc.__name__
|
||||
|
||||
def _create_method(op):
|
||||
def method(self):
|
||||
result = op(self._deduped_data())
|
||||
return self._with_data(result, copy=True)
|
||||
|
||||
method.__doc__ = ("Element-wise %s.\n\n"
|
||||
"See numpy.%s for more information." % (name, name))
|
||||
method.__name__ = name
|
||||
|
||||
return method
|
||||
|
||||
setattr(_data_matrix, name, _create_method(npfunc))
|
||||
|
||||
|
||||
def _find_missing_index(ind, n):
|
||||
for k, a in enumerate(ind):
|
||||
if k != a:
|
||||
return k
|
||||
|
||||
k += 1
|
||||
if k < n:
|
||||
return k
|
||||
else:
|
||||
return -1
|
||||
|
||||
|
||||
class _minmax_mixin(object):
|
||||
"""Mixin for min and max methods.
|
||||
|
||||
These are not implemented for dia_matrix, hence the separate class.
|
||||
"""
|
||||
|
||||
def _min_or_max_axis(self, axis, min_or_max):
|
||||
N = self.shape[axis]
|
||||
if N == 0:
|
||||
raise ValueError("zero-size array to reduction operation")
|
||||
M = self.shape[1 - axis]
|
||||
|
||||
mat = self.tocsc() if axis == 0 else self.tocsr()
|
||||
mat.sum_duplicates()
|
||||
|
||||
major_index, value = mat._minor_reduce(min_or_max)
|
||||
not_full = np.diff(mat.indptr)[major_index] < N
|
||||
value[not_full] = min_or_max(value[not_full], 0)
|
||||
|
||||
mask = value != 0
|
||||
major_index = np.compress(mask, major_index)
|
||||
value = np.compress(mask, value)
|
||||
|
||||
from . import coo_matrix
|
||||
if axis == 0:
|
||||
return coo_matrix((value, (np.zeros(len(value)), major_index)),
|
||||
dtype=self.dtype, shape=(1, M))
|
||||
else:
|
||||
return coo_matrix((value, (major_index, np.zeros(len(value)))),
|
||||
dtype=self.dtype, shape=(M, 1))
|
||||
|
||||
def _min_or_max(self, axis, out, min_or_max):
|
||||
if out is not None:
|
||||
raise ValueError(("Sparse matrices do not support "
|
||||
"an 'out' parameter."))
|
||||
|
||||
validateaxis(axis)
|
||||
|
||||
if axis is None:
|
||||
if 0 in self.shape:
|
||||
raise ValueError("zero-size array to reduction operation")
|
||||
|
||||
zero = self.dtype.type(0)
|
||||
if self.nnz == 0:
|
||||
return zero
|
||||
m = min_or_max.reduce(self._deduped_data().ravel())
|
||||
if self.nnz != np.product(self.shape):
|
||||
m = min_or_max(zero, m)
|
||||
return m
|
||||
|
||||
if axis < 0:
|
||||
axis += 2
|
||||
|
||||
if (axis == 0) or (axis == 1):
|
||||
return self._min_or_max_axis(axis, min_or_max)
|
||||
else:
|
||||
raise ValueError("axis out of range")
|
||||
|
||||
def _arg_min_or_max_axis(self, axis, op, compare):
|
||||
if self.shape[axis] == 0:
|
||||
raise ValueError("Can't apply the operation along a zero-sized "
|
||||
"dimension.")
|
||||
|
||||
if axis < 0:
|
||||
axis += 2
|
||||
|
||||
zero = self.dtype.type(0)
|
||||
|
||||
mat = self.tocsc() if axis == 0 else self.tocsr()
|
||||
mat.sum_duplicates()
|
||||
|
||||
ret_size, line_size = mat._swap(mat.shape)
|
||||
ret = np.zeros(ret_size, dtype=int)
|
||||
|
||||
nz_lines, = np.nonzero(np.diff(mat.indptr))
|
||||
for i in nz_lines:
|
||||
p, q = mat.indptr[i:i + 2]
|
||||
data = mat.data[p:q]
|
||||
indices = mat.indices[p:q]
|
||||
am = op(data)
|
||||
m = data[am]
|
||||
if compare(m, zero) or q - p == line_size:
|
||||
ret[i] = indices[am]
|
||||
else:
|
||||
zero_ind = _find_missing_index(indices, line_size)
|
||||
if m == zero:
|
||||
ret[i] = min(am, zero_ind)
|
||||
else:
|
||||
ret[i] = zero_ind
|
||||
|
||||
if axis == 1:
|
||||
ret = ret.reshape(-1, 1)
|
||||
|
||||
return np.asmatrix(ret)
|
||||
|
||||
def _arg_min_or_max(self, axis, out, op, compare):
|
||||
if out is not None:
|
||||
raise ValueError("Sparse matrices do not support "
|
||||
"an 'out' parameter.")
|
||||
|
||||
validateaxis(axis)
|
||||
|
||||
if axis is None:
|
||||
if 0 in self.shape:
|
||||
raise ValueError("Can't apply the operation to "
|
||||
"an empty matrix.")
|
||||
|
||||
if self.nnz == 0:
|
||||
return 0
|
||||
else:
|
||||
zero = self.dtype.type(0)
|
||||
mat = self.tocoo()
|
||||
mat.sum_duplicates()
|
||||
am = op(mat.data)
|
||||
m = mat.data[am]
|
||||
|
||||
if compare(m, zero):
|
||||
return mat.row[am] * mat.shape[1] + mat.col[am]
|
||||
else:
|
||||
size = np.product(mat.shape)
|
||||
if size == mat.nnz:
|
||||
return am
|
||||
else:
|
||||
ind = mat.row * mat.shape[1] + mat.col
|
||||
zero_ind = _find_missing_index(ind, size)
|
||||
if m == zero:
|
||||
return min(zero_ind, am)
|
||||
else:
|
||||
return zero_ind
|
||||
|
||||
return self._arg_min_or_max_axis(axis, op, compare)
|
||||
|
||||
def max(self, axis=None, out=None):
|
||||
"""
|
||||
Return the maximum of the matrix or maximum along an axis.
|
||||
This takes all elements into account, not just the non-zero ones.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
axis : {-2, -1, 0, 1, None} optional
|
||||
Axis along which the sum is computed. The default is to
|
||||
compute the maximum over all the matrix elements, returning
|
||||
a scalar (i.e. `axis` = `None`).
|
||||
|
||||
out : None, optional
|
||||
This argument is in the signature *solely* for NumPy
|
||||
compatibility reasons. Do not pass in anything except
|
||||
for the default value, as this argument is not used.
|
||||
|
||||
Returns
|
||||
-------
|
||||
amax : coo_matrix or scalar
|
||||
Maximum of `a`. If `axis` is None, the result is a scalar value.
|
||||
If `axis` is given, the result is a sparse.coo_matrix of dimension
|
||||
``a.ndim - 1``.
|
||||
|
||||
See Also
|
||||
--------
|
||||
min : The minimum value of a sparse matrix along a given axis.
|
||||
np.matrix.max : NumPy's implementation of 'max' for matrices
|
||||
|
||||
"""
|
||||
return self._min_or_max(axis, out, np.maximum)
|
||||
|
||||
def min(self, axis=None, out=None):
|
||||
"""
|
||||
Return the minimum of the matrix or maximum along an axis.
|
||||
This takes all elements into account, not just the non-zero ones.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
axis : {-2, -1, 0, 1, None} optional
|
||||
Axis along which the sum is computed. The default is to
|
||||
compute the minimum over all the matrix elements, returning
|
||||
a scalar (i.e. `axis` = `None`).
|
||||
|
||||
out : None, optional
|
||||
This argument is in the signature *solely* for NumPy
|
||||
compatibility reasons. Do not pass in anything except for
|
||||
the default value, as this argument is not used.
|
||||
|
||||
Returns
|
||||
-------
|
||||
amin : coo_matrix or scalar
|
||||
Minimum of `a`. If `axis` is None, the result is a scalar value.
|
||||
If `axis` is given, the result is a sparse.coo_matrix of dimension
|
||||
``a.ndim - 1``.
|
||||
|
||||
See Also
|
||||
--------
|
||||
max : The maximum value of a sparse matrix along a given axis.
|
||||
np.matrix.min : NumPy's implementation of 'min' for matrices
|
||||
|
||||
"""
|
||||
return self._min_or_max(axis, out, np.minimum)
|
||||
|
||||
def argmax(self, axis=None, out=None):
|
||||
"""Return indices of maximum elements along an axis.
|
||||
|
||||
Implicit zero elements are also taken into account. If there are
|
||||
several maximum values, the index of the first occurrence is returned.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
axis : {-2, -1, 0, 1, None}, optional
|
||||
Axis along which the argmax is computed. If None (default), index
|
||||
of the maximum element in the flatten data is returned.
|
||||
out : None, optional
|
||||
This argument is in the signature *solely* for NumPy
|
||||
compatibility reasons. Do not pass in anything except for
|
||||
the default value, as this argument is not used.
|
||||
|
||||
Returns
|
||||
-------
|
||||
ind : np.matrix or int
|
||||
Indices of maximum elements. If matrix, its size along `axis` is 1.
|
||||
"""
|
||||
return self._arg_min_or_max(axis, out, np.argmax, np.greater)
|
||||
|
||||
def argmin(self, axis=None, out=None):
|
||||
"""Return indices of minimum elements along an axis.
|
||||
|
||||
Implicit zero elements are also taken into account. If there are
|
||||
several minimum values, the index of the first occurrence is returned.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
axis : {-2, -1, 0, 1, None}, optional
|
||||
Axis along which the argmin is computed. If None (default), index
|
||||
of the minimum element in the flatten data is returned.
|
||||
out : None, optional
|
||||
This argument is in the signature *solely* for NumPy
|
||||
compatibility reasons. Do not pass in anything except for
|
||||
the default value, as this argument is not used.
|
||||
|
||||
Returns
|
||||
-------
|
||||
ind : np.matrix or int
|
||||
Indices of minimum elements. If matrix, its size along `axis` is 1.
|
||||
"""
|
||||
return self._arg_min_or_max(axis, out, np.argmin, np.less)
|
||||
@@ -0,0 +1,420 @@
|
||||
"""Sparse DIAgonal format"""
|
||||
|
||||
from __future__ import division, print_function, absolute_import
|
||||
|
||||
__docformat__ = "restructuredtext en"
|
||||
|
||||
__all__ = ['dia_matrix', 'isspmatrix_dia']
|
||||
|
||||
import numpy as np
|
||||
|
||||
from .base import isspmatrix, _formats, spmatrix
|
||||
from .data import _data_matrix
|
||||
from .sputils import (isshape, upcast_char, getdtype, get_index_dtype,
|
||||
get_sum_dtype, validateaxis, check_shape)
|
||||
from ._sparsetools import dia_matvec
|
||||
|
||||
|
||||
class dia_matrix(_data_matrix):
|
||||
"""Sparse matrix with DIAgonal storage
|
||||
|
||||
This can be instantiated in several ways:
|
||||
dia_matrix(D)
|
||||
with a dense matrix
|
||||
|
||||
dia_matrix(S)
|
||||
with another sparse matrix S (equivalent to S.todia())
|
||||
|
||||
dia_matrix((M, N), [dtype])
|
||||
to construct an empty matrix with shape (M, N),
|
||||
dtype is optional, defaulting to dtype='d'.
|
||||
|
||||
dia_matrix((data, offsets), shape=(M, N))
|
||||
where the ``data[k,:]`` stores the diagonal entries for
|
||||
diagonal ``offsets[k]`` (See example below)
|
||||
|
||||
Attributes
|
||||
----------
|
||||
dtype : dtype
|
||||
Data type of the matrix
|
||||
shape : 2-tuple
|
||||
Shape of the matrix
|
||||
ndim : int
|
||||
Number of dimensions (this is always 2)
|
||||
nnz
|
||||
Number of nonzero elements
|
||||
data
|
||||
DIA format data array of the matrix
|
||||
offsets
|
||||
DIA format offset array of the matrix
|
||||
|
||||
Notes
|
||||
-----
|
||||
|
||||
Sparse matrices can be used in arithmetic operations: they support
|
||||
addition, subtraction, multiplication, division, and matrix power.
|
||||
|
||||
Examples
|
||||
--------
|
||||
|
||||
>>> import numpy as np
|
||||
>>> from scipy.sparse import dia_matrix
|
||||
>>> dia_matrix((3, 4), dtype=np.int8).toarray()
|
||||
array([[0, 0, 0, 0],
|
||||
[0, 0, 0, 0],
|
||||
[0, 0, 0, 0]], dtype=int8)
|
||||
|
||||
>>> data = np.array([[1, 2, 3, 4]]).repeat(3, axis=0)
|
||||
>>> offsets = np.array([0, -1, 2])
|
||||
>>> dia_matrix((data, offsets), shape=(4, 4)).toarray()
|
||||
array([[1, 0, 3, 0],
|
||||
[1, 2, 0, 4],
|
||||
[0, 2, 3, 0],
|
||||
[0, 0, 3, 4]])
|
||||
|
||||
"""
|
||||
format = 'dia'
|
||||
|
||||
def __init__(self, arg1, shape=None, dtype=None, copy=False):
|
||||
_data_matrix.__init__(self)
|
||||
|
||||
if isspmatrix_dia(arg1):
|
||||
if copy:
|
||||
arg1 = arg1.copy()
|
||||
self.data = arg1.data
|
||||
self.offsets = arg1.offsets
|
||||
self._shape = check_shape(arg1.shape)
|
||||
elif isspmatrix(arg1):
|
||||
if isspmatrix_dia(arg1) and copy:
|
||||
A = arg1.copy()
|
||||
else:
|
||||
A = arg1.todia()
|
||||
self.data = A.data
|
||||
self.offsets = A.offsets
|
||||
self._shape = check_shape(A.shape)
|
||||
elif isinstance(arg1, tuple):
|
||||
if isshape(arg1):
|
||||
# It's a tuple of matrix dimensions (M, N)
|
||||
# create empty matrix
|
||||
self._shape = check_shape(arg1)
|
||||
self.data = np.zeros((0,0), getdtype(dtype, default=float))
|
||||
idx_dtype = get_index_dtype(maxval=max(self.shape))
|
||||
self.offsets = np.zeros((0), dtype=idx_dtype)
|
||||
else:
|
||||
try:
|
||||
# Try interpreting it as (data, offsets)
|
||||
data, offsets = arg1
|
||||
except Exception:
|
||||
raise ValueError('unrecognized form for dia_matrix constructor')
|
||||
else:
|
||||
if shape is None:
|
||||
raise ValueError('expected a shape argument')
|
||||
self.data = np.atleast_2d(np.array(arg1[0], dtype=dtype, copy=copy))
|
||||
self.offsets = np.atleast_1d(np.array(arg1[1],
|
||||
dtype=get_index_dtype(maxval=max(shape)),
|
||||
copy=copy))
|
||||
self._shape = check_shape(shape)
|
||||
else:
|
||||
#must be dense, convert to COO first, then to DIA
|
||||
try:
|
||||
arg1 = np.asarray(arg1)
|
||||
except Exception:
|
||||
raise ValueError("unrecognized form for"
|
||||
" %s_matrix constructor" % self.format)
|
||||
from .coo import coo_matrix
|
||||
A = coo_matrix(arg1, dtype=dtype, shape=shape).todia()
|
||||
self.data = A.data
|
||||
self.offsets = A.offsets
|
||||
self._shape = check_shape(A.shape)
|
||||
|
||||
if dtype is not None:
|
||||
self.data = self.data.astype(dtype)
|
||||
|
||||
#check format
|
||||
if self.offsets.ndim != 1:
|
||||
raise ValueError('offsets array must have rank 1')
|
||||
|
||||
if self.data.ndim != 2:
|
||||
raise ValueError('data array must have rank 2')
|
||||
|
||||
if self.data.shape[0] != len(self.offsets):
|
||||
raise ValueError('number of diagonals (%d) '
|
||||
'does not match the number of offsets (%d)'
|
||||
% (self.data.shape[0], len(self.offsets)))
|
||||
|
||||
if len(np.unique(self.offsets)) != len(self.offsets):
|
||||
raise ValueError('offset array contains duplicate values')
|
||||
|
||||
def __repr__(self):
|
||||
format = _formats[self.getformat()][1]
|
||||
return "<%dx%d sparse matrix of type '%s'\n" \
|
||||
"\twith %d stored elements (%d diagonals) in %s format>" % \
|
||||
(self.shape + (self.dtype.type, self.nnz, self.data.shape[0],
|
||||
format))
|
||||
|
||||
def _data_mask(self):
|
||||
"""Returns a mask of the same shape as self.data, where
|
||||
mask[i,j] is True when data[i,j] corresponds to a stored element."""
|
||||
num_rows, num_cols = self.shape
|
||||
offset_inds = np.arange(self.data.shape[1])
|
||||
row = offset_inds - self.offsets[:,None]
|
||||
mask = (row >= 0)
|
||||
mask &= (row < num_rows)
|
||||
mask &= (offset_inds < num_cols)
|
||||
return mask
|
||||
|
||||
def count_nonzero(self):
|
||||
mask = self._data_mask()
|
||||
return np.count_nonzero(self.data[mask])
|
||||
|
||||
def getnnz(self, axis=None):
|
||||
if axis is not None:
|
||||
raise NotImplementedError("getnnz over an axis is not implemented "
|
||||
"for DIA format")
|
||||
M,N = self.shape
|
||||
nnz = 0
|
||||
for k in self.offsets:
|
||||
if k > 0:
|
||||
nnz += min(M,N-k)
|
||||
else:
|
||||
nnz += min(M+k,N)
|
||||
return int(nnz)
|
||||
|
||||
getnnz.__doc__ = spmatrix.getnnz.__doc__
|
||||
count_nonzero.__doc__ = spmatrix.count_nonzero.__doc__
|
||||
|
||||
def sum(self, axis=None, dtype=None, out=None):
|
||||
validateaxis(axis)
|
||||
|
||||
if axis is not None and axis < 0:
|
||||
axis += 2
|
||||
|
||||
res_dtype = get_sum_dtype(self.dtype)
|
||||
num_rows, num_cols = self.shape
|
||||
ret = None
|
||||
|
||||
if axis == 0:
|
||||
mask = self._data_mask()
|
||||
x = (self.data * mask).sum(axis=0)
|
||||
if x.shape[0] == num_cols:
|
||||
res = x
|
||||
else:
|
||||
res = np.zeros(num_cols, dtype=x.dtype)
|
||||
res[:x.shape[0]] = x
|
||||
ret = np.matrix(res, dtype=res_dtype)
|
||||
|
||||
else:
|
||||
row_sums = np.zeros(num_rows, dtype=res_dtype)
|
||||
one = np.ones(num_cols, dtype=res_dtype)
|
||||
dia_matvec(num_rows, num_cols, len(self.offsets),
|
||||
self.data.shape[1], self.offsets, self.data, one, row_sums)
|
||||
|
||||
row_sums = np.matrix(row_sums)
|
||||
|
||||
if axis is None:
|
||||
return row_sums.sum(dtype=dtype, out=out)
|
||||
|
||||
if axis is not None:
|
||||
row_sums = row_sums.T
|
||||
|
||||
ret = np.matrix(row_sums.sum(axis=axis))
|
||||
|
||||
if out is not None and out.shape != ret.shape:
|
||||
raise ValueError("dimensions do not match")
|
||||
|
||||
return ret.sum(axis=(), dtype=dtype, out=out)
|
||||
|
||||
sum.__doc__ = spmatrix.sum.__doc__
|
||||
|
||||
def _mul_vector(self, other):
|
||||
x = other
|
||||
|
||||
y = np.zeros(self.shape[0], dtype=upcast_char(self.dtype.char,
|
||||
x.dtype.char))
|
||||
|
||||
L = self.data.shape[1]
|
||||
|
||||
M,N = self.shape
|
||||
|
||||
dia_matvec(M,N, len(self.offsets), L, self.offsets, self.data, x.ravel(), y.ravel())
|
||||
|
||||
return y
|
||||
|
||||
def _mul_multimatrix(self, other):
|
||||
return np.hstack([self._mul_vector(col).reshape(-1,1) for col in other.T])
|
||||
|
||||
def _setdiag(self, values, k=0):
|
||||
M, N = self.shape
|
||||
|
||||
if values.ndim == 0:
|
||||
# broadcast
|
||||
values_n = np.inf
|
||||
else:
|
||||
values_n = len(values)
|
||||
|
||||
if k < 0:
|
||||
n = min(M + k, N, values_n)
|
||||
min_index = 0
|
||||
max_index = n
|
||||
else:
|
||||
n = min(M, N - k, values_n)
|
||||
min_index = k
|
||||
max_index = k + n
|
||||
|
||||
if values.ndim != 0:
|
||||
# allow also longer sequences
|
||||
values = values[:n]
|
||||
|
||||
if k in self.offsets:
|
||||
self.data[self.offsets == k, min_index:max_index] = values
|
||||
else:
|
||||
self.offsets = np.append(self.offsets, self.offsets.dtype.type(k))
|
||||
m = max(max_index, self.data.shape[1])
|
||||
data = np.zeros((self.data.shape[0]+1, m), dtype=self.data.dtype)
|
||||
data[:-1,:self.data.shape[1]] = self.data
|
||||
data[-1, min_index:max_index] = values
|
||||
self.data = data
|
||||
|
||||
def todia(self, copy=False):
|
||||
if copy:
|
||||
return self.copy()
|
||||
else:
|
||||
return self
|
||||
|
||||
todia.__doc__ = spmatrix.todia.__doc__
|
||||
|
||||
def transpose(self, axes=None, copy=False):
|
||||
if axes is not None:
|
||||
raise ValueError(("Sparse matrices do not support "
|
||||
"an 'axes' parameter because swapping "
|
||||
"dimensions is the only logical permutation."))
|
||||
|
||||
num_rows, num_cols = self.shape
|
||||
max_dim = max(self.shape)
|
||||
|
||||
# flip diagonal offsets
|
||||
offsets = -self.offsets
|
||||
|
||||
# re-align the data matrix
|
||||
r = np.arange(len(offsets), dtype=np.intc)[:, None]
|
||||
c = np.arange(num_rows, dtype=np.intc) - (offsets % max_dim)[:, None]
|
||||
pad_amount = max(0, max_dim-self.data.shape[1])
|
||||
data = np.hstack((self.data, np.zeros((self.data.shape[0], pad_amount),
|
||||
dtype=self.data.dtype)))
|
||||
data = data[r, c]
|
||||
return dia_matrix((data, offsets), shape=(
|
||||
num_cols, num_rows), copy=copy)
|
||||
|
||||
transpose.__doc__ = spmatrix.transpose.__doc__
|
||||
|
||||
def diagonal(self, k=0):
|
||||
rows, cols = self.shape
|
||||
if k <= -rows or k >= cols:
|
||||
raise ValueError("k exceeds matrix dimensions")
|
||||
idx, = np.nonzero(self.offsets == k)
|
||||
first_col, last_col = max(0, k), min(rows + k, cols)
|
||||
if idx.size == 0:
|
||||
return np.zeros(last_col - first_col, dtype=self.data.dtype)
|
||||
return self.data[idx[0], first_col:last_col]
|
||||
|
||||
diagonal.__doc__ = spmatrix.diagonal.__doc__
|
||||
|
||||
def tocsc(self, copy=False):
|
||||
from .csc import csc_matrix
|
||||
if self.nnz == 0:
|
||||
return csc_matrix(self.shape, dtype=self.dtype)
|
||||
|
||||
num_rows, num_cols = self.shape
|
||||
num_offsets, offset_len = self.data.shape
|
||||
offset_inds = np.arange(offset_len)
|
||||
|
||||
row = offset_inds - self.offsets[:,None]
|
||||
mask = (row >= 0)
|
||||
mask &= (row < num_rows)
|
||||
mask &= (offset_inds < num_cols)
|
||||
mask &= (self.data != 0)
|
||||
|
||||
idx_dtype = get_index_dtype(maxval=max(self.shape))
|
||||
indptr = np.zeros(num_cols + 1, dtype=idx_dtype)
|
||||
indptr[1:offset_len+1] = np.cumsum(mask.sum(axis=0))
|
||||
indptr[offset_len+1:] = indptr[offset_len]
|
||||
indices = row.T[mask.T].astype(idx_dtype, copy=False)
|
||||
data = self.data.T[mask.T]
|
||||
return csc_matrix((data, indices, indptr), shape=self.shape,
|
||||
dtype=self.dtype)
|
||||
|
||||
tocsc.__doc__ = spmatrix.tocsc.__doc__
|
||||
|
||||
def tocoo(self, copy=False):
|
||||
num_rows, num_cols = self.shape
|
||||
num_offsets, offset_len = self.data.shape
|
||||
offset_inds = np.arange(offset_len)
|
||||
|
||||
row = offset_inds - self.offsets[:,None]
|
||||
mask = (row >= 0)
|
||||
mask &= (row < num_rows)
|
||||
mask &= (offset_inds < num_cols)
|
||||
mask &= (self.data != 0)
|
||||
row = row[mask]
|
||||
col = np.tile(offset_inds, num_offsets)[mask.ravel()]
|
||||
data = self.data[mask]
|
||||
|
||||
from .coo import coo_matrix
|
||||
A = coo_matrix((data,(row,col)), shape=self.shape, dtype=self.dtype)
|
||||
A.has_canonical_format = True
|
||||
return A
|
||||
|
||||
tocoo.__doc__ = spmatrix.tocoo.__doc__
|
||||
|
||||
# needed by _data_matrix
|
||||
def _with_data(self, data, copy=True):
|
||||
"""Returns a matrix with the same sparsity structure as self,
|
||||
but with different data. By default the structure arrays are copied.
|
||||
"""
|
||||
if copy:
|
||||
return dia_matrix((data, self.offsets.copy()), shape=self.shape)
|
||||
else:
|
||||
return dia_matrix((data,self.offsets), shape=self.shape)
|
||||
|
||||
def resize(self, *shape):
|
||||
shape = check_shape(shape)
|
||||
M, N = shape
|
||||
# we do not need to handle the case of expanding N
|
||||
self.data = self.data[:, :N]
|
||||
|
||||
if (M > self.shape[0] and
|
||||
np.any(self.offsets + self.shape[0] < self.data.shape[1])):
|
||||
# explicitly clear values that were previously hidden
|
||||
mask = (self.offsets[:, None] + self.shape[0] <=
|
||||
np.arange(self.data.shape[1]))
|
||||
self.data[mask] = 0
|
||||
|
||||
self._shape = shape
|
||||
|
||||
resize.__doc__ = spmatrix.resize.__doc__
|
||||
|
||||
|
||||
def isspmatrix_dia(x):
|
||||
"""Is x of dia_matrix type?
|
||||
|
||||
Parameters
|
||||
----------
|
||||
x
|
||||
object to check for being a dia matrix
|
||||
|
||||
Returns
|
||||
-------
|
||||
bool
|
||||
True if x is a dia matrix, False otherwise
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> from scipy.sparse import dia_matrix, isspmatrix_dia
|
||||
>>> isspmatrix_dia(dia_matrix([[5]]))
|
||||
True
|
||||
|
||||
>>> from scipy.sparse import dia_matrix, csr_matrix, isspmatrix_dia
|
||||
>>> isspmatrix_dia(csr_matrix([[5]]))
|
||||
False
|
||||
"""
|
||||
return isinstance(x, dia_matrix)
|
||||
@@ -0,0 +1,538 @@
|
||||
"""Dictionary Of Keys based matrix"""
|
||||
|
||||
from __future__ import division, print_function, absolute_import
|
||||
|
||||
__docformat__ = "restructuredtext en"
|
||||
|
||||
__all__ = ['dok_matrix', 'isspmatrix_dok']
|
||||
|
||||
import functools
|
||||
import operator
|
||||
import itertools
|
||||
|
||||
import numpy as np
|
||||
|
||||
from scipy._lib.six import zip as izip, xrange, iteritems, iterkeys, itervalues
|
||||
|
||||
from .base import spmatrix, isspmatrix
|
||||
from .sputils import (isdense, getdtype, isshape, isintlike, isscalarlike,
|
||||
upcast, upcast_scalar, IndexMixin, get_index_dtype,
|
||||
check_shape)
|
||||
|
||||
try:
|
||||
from operator import isSequenceType as _is_sequence
|
||||
except ImportError:
|
||||
def _is_sequence(x):
|
||||
return (hasattr(x, '__len__') or hasattr(x, '__next__')
|
||||
or hasattr(x, 'next'))
|
||||
|
||||
|
||||
class dok_matrix(spmatrix, IndexMixin, dict):
|
||||
"""
|
||||
Dictionary Of Keys based sparse matrix.
|
||||
|
||||
This is an efficient structure for constructing sparse
|
||||
matrices incrementally.
|
||||
|
||||
This can be instantiated in several ways:
|
||||
dok_matrix(D)
|
||||
with a dense matrix, D
|
||||
|
||||
dok_matrix(S)
|
||||
with a sparse matrix, S
|
||||
|
||||
dok_matrix((M,N), [dtype])
|
||||
create the matrix with initial shape (M,N)
|
||||
dtype is optional, defaulting to dtype='d'
|
||||
|
||||
Attributes
|
||||
----------
|
||||
dtype : dtype
|
||||
Data type of the matrix
|
||||
shape : 2-tuple
|
||||
Shape of the matrix
|
||||
ndim : int
|
||||
Number of dimensions (this is always 2)
|
||||
nnz
|
||||
Number of nonzero elements
|
||||
|
||||
Notes
|
||||
-----
|
||||
|
||||
Sparse matrices can be used in arithmetic operations: they support
|
||||
addition, subtraction, multiplication, division, and matrix power.
|
||||
|
||||
Allows for efficient O(1) access of individual elements.
|
||||
Duplicates are not allowed.
|
||||
Can be efficiently converted to a coo_matrix once constructed.
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> import numpy as np
|
||||
>>> from scipy.sparse import dok_matrix
|
||||
>>> S = dok_matrix((5, 5), dtype=np.float32)
|
||||
>>> for i in range(5):
|
||||
... for j in range(5):
|
||||
... S[i, j] = i + j # Update element
|
||||
|
||||
"""
|
||||
format = 'dok'
|
||||
|
||||
def __init__(self, arg1, shape=None, dtype=None, copy=False):
|
||||
dict.__init__(self)
|
||||
spmatrix.__init__(self)
|
||||
|
||||
self.dtype = getdtype(dtype, default=float)
|
||||
if isinstance(arg1, tuple) and isshape(arg1): # (M,N)
|
||||
M, N = arg1
|
||||
self._shape = check_shape((M, N))
|
||||
elif isspmatrix(arg1): # Sparse ctor
|
||||
if isspmatrix_dok(arg1) and copy:
|
||||
arg1 = arg1.copy()
|
||||
else:
|
||||
arg1 = arg1.todok()
|
||||
|
||||
if dtype is not None:
|
||||
arg1 = arg1.astype(dtype)
|
||||
|
||||
dict.update(self, arg1)
|
||||
self._shape = check_shape(arg1.shape)
|
||||
self.dtype = arg1.dtype
|
||||
else: # Dense ctor
|
||||
try:
|
||||
arg1 = np.asarray(arg1)
|
||||
except Exception:
|
||||
raise TypeError('Invalid input format.')
|
||||
|
||||
if len(arg1.shape) != 2:
|
||||
raise TypeError('Expected rank <=2 dense array or matrix.')
|
||||
|
||||
from .coo import coo_matrix
|
||||
d = coo_matrix(arg1, dtype=dtype).todok()
|
||||
dict.update(self, d)
|
||||
self._shape = check_shape(arg1.shape)
|
||||
self.dtype = d.dtype
|
||||
|
||||
def update(self, val):
|
||||
# Prevent direct usage of update
|
||||
raise NotImplementedError("Direct modification to dok_matrix element "
|
||||
"is not allowed.")
|
||||
|
||||
def _update(self, data):
|
||||
"""An update method for dict data defined for direct access to
|
||||
`dok_matrix` data. Main purpose is to be used for effcient conversion
|
||||
from other spmatrix classes. Has no checking if `data` is valid."""
|
||||
return dict.update(self, data)
|
||||
|
||||
def set_shape(self, shape):
|
||||
new_matrix = self.reshape(shape, copy=False).asformat(self.format)
|
||||
self.__dict__ = new_matrix.__dict__
|
||||
dict.clear(self)
|
||||
dict.update(self, new_matrix)
|
||||
|
||||
shape = property(fget=spmatrix.get_shape, fset=set_shape)
|
||||
|
||||
def getnnz(self, axis=None):
|
||||
if axis is not None:
|
||||
raise NotImplementedError("getnnz over an axis is not implemented "
|
||||
"for DOK format.")
|
||||
return dict.__len__(self)
|
||||
|
||||
def count_nonzero(self):
|
||||
return sum(x != 0 for x in itervalues(self))
|
||||
|
||||
getnnz.__doc__ = spmatrix.getnnz.__doc__
|
||||
count_nonzero.__doc__ = spmatrix.count_nonzero.__doc__
|
||||
|
||||
def __len__(self):
|
||||
return dict.__len__(self)
|
||||
|
||||
def get(self, key, default=0.):
|
||||
"""This overrides the dict.get method, providing type checking
|
||||
but otherwise equivalent functionality.
|
||||
"""
|
||||
try:
|
||||
i, j = key
|
||||
assert isintlike(i) and isintlike(j)
|
||||
except (AssertionError, TypeError, ValueError):
|
||||
raise IndexError('Index must be a pair of integers.')
|
||||
if (i < 0 or i >= self.shape[0] or j < 0 or j >= self.shape[1]):
|
||||
raise IndexError('Index out of bounds.')
|
||||
return dict.get(self, key, default)
|
||||
|
||||
def __getitem__(self, index):
|
||||
"""If key=(i, j) is a pair of integers, return the corresponding
|
||||
element. If either i or j is a slice or sequence, return a new sparse
|
||||
matrix with just these elements.
|
||||
"""
|
||||
zero = self.dtype.type(0)
|
||||
i, j = self._unpack_index(index)
|
||||
|
||||
i_intlike = isintlike(i)
|
||||
j_intlike = isintlike(j)
|
||||
|
||||
if i_intlike and j_intlike:
|
||||
i = int(i)
|
||||
j = int(j)
|
||||
if i < 0:
|
||||
i += self.shape[0]
|
||||
if i < 0 or i >= self.shape[0]:
|
||||
raise IndexError('Index out of bounds.')
|
||||
if j < 0:
|
||||
j += self.shape[1]
|
||||
if j < 0 or j >= self.shape[1]:
|
||||
raise IndexError('Index out of bounds.')
|
||||
return dict.get(self, (i,j), zero)
|
||||
elif ((i_intlike or isinstance(i, slice)) and
|
||||
(j_intlike or isinstance(j, slice))):
|
||||
# Fast path for slicing very sparse matrices
|
||||
i_slice = slice(i, i+1) if i_intlike else i
|
||||
j_slice = slice(j, j+1) if j_intlike else j
|
||||
i_indices = i_slice.indices(self.shape[0])
|
||||
j_indices = j_slice.indices(self.shape[1])
|
||||
i_seq = xrange(*i_indices)
|
||||
j_seq = xrange(*j_indices)
|
||||
newshape = (len(i_seq), len(j_seq))
|
||||
newsize = _prod(newshape)
|
||||
|
||||
if len(self) < 2*newsize and newsize != 0:
|
||||
# Switch to the fast path only when advantageous
|
||||
# (count the iterations in the loops, adjust for complexity)
|
||||
#
|
||||
# We also don't handle newsize == 0 here (if
|
||||
# i/j_intlike, it can mean index i or j was out of
|
||||
# bounds)
|
||||
return self._getitem_ranges(i_indices, j_indices, newshape)
|
||||
|
||||
i, j = self._index_to_arrays(i, j)
|
||||
|
||||
if i.size == 0:
|
||||
return dok_matrix(i.shape, dtype=self.dtype)
|
||||
|
||||
min_i = i.min()
|
||||
if min_i < -self.shape[0] or i.max() >= self.shape[0]:
|
||||
raise IndexError('Index (%d) out of range -%d to %d.' %
|
||||
(i.min(), self.shape[0], self.shape[0]-1))
|
||||
if min_i < 0:
|
||||
i = i.copy()
|
||||
i[i < 0] += self.shape[0]
|
||||
|
||||
min_j = j.min()
|
||||
if min_j < -self.shape[1] or j.max() >= self.shape[1]:
|
||||
raise IndexError('Index (%d) out of range -%d to %d.' %
|
||||
(j.min(), self.shape[1], self.shape[1]-1))
|
||||
if min_j < 0:
|
||||
j = j.copy()
|
||||
j[j < 0] += self.shape[1]
|
||||
|
||||
newdok = dok_matrix(i.shape, dtype=self.dtype)
|
||||
|
||||
for key in itertools.product(xrange(i.shape[0]), xrange(i.shape[1])):
|
||||
v = dict.get(self, (i[key], j[key]), zero)
|
||||
if v:
|
||||
dict.__setitem__(newdok, key, v)
|
||||
|
||||
return newdok
|
||||
|
||||
def _getitem_ranges(self, i_indices, j_indices, shape):
|
||||
# performance golf: we don't want Numpy scalars here, they are slow
|
||||
i_start, i_stop, i_stride = map(int, i_indices)
|
||||
j_start, j_stop, j_stride = map(int, j_indices)
|
||||
|
||||
newdok = dok_matrix(shape, dtype=self.dtype)
|
||||
|
||||
for (ii, jj) in iterkeys(self):
|
||||
# ditto for numpy scalars
|
||||
ii = int(ii)
|
||||
jj = int(jj)
|
||||
a, ra = divmod(ii - i_start, i_stride)
|
||||
if a < 0 or a >= shape[0] or ra != 0:
|
||||
continue
|
||||
b, rb = divmod(jj - j_start, j_stride)
|
||||
if b < 0 or b >= shape[1] or rb != 0:
|
||||
continue
|
||||
dict.__setitem__(newdok, (a, b),
|
||||
dict.__getitem__(self, (ii, jj)))
|
||||
return newdok
|
||||
|
||||
def __setitem__(self, index, x):
|
||||
if isinstance(index, tuple) and len(index) == 2:
|
||||
# Integer index fast path
|
||||
i, j = index
|
||||
if (isintlike(i) and isintlike(j) and 0 <= i < self.shape[0]
|
||||
and 0 <= j < self.shape[1]):
|
||||
v = np.asarray(x, dtype=self.dtype)
|
||||
if v.ndim == 0 and v != 0:
|
||||
dict.__setitem__(self, (int(i), int(j)), v[()])
|
||||
return
|
||||
|
||||
i, j = self._unpack_index(index)
|
||||
i, j = self._index_to_arrays(i, j)
|
||||
|
||||
if isspmatrix(x):
|
||||
x = x.toarray()
|
||||
|
||||
# Make x and i into the same shape
|
||||
x = np.asarray(x, dtype=self.dtype)
|
||||
x, _ = np.broadcast_arrays(x, i)
|
||||
|
||||
if x.shape != i.shape:
|
||||
raise ValueError("Shape mismatch in assignment.")
|
||||
|
||||
if np.size(x) == 0:
|
||||
return
|
||||
|
||||
min_i = i.min()
|
||||
if min_i < -self.shape[0] or i.max() >= self.shape[0]:
|
||||
raise IndexError('Index (%d) out of range -%d to %d.' %
|
||||
(i.min(), self.shape[0], self.shape[0]-1))
|
||||
if min_i < 0:
|
||||
i = i.copy()
|
||||
i[i < 0] += self.shape[0]
|
||||
|
||||
min_j = j.min()
|
||||
if min_j < -self.shape[1] or j.max() >= self.shape[1]:
|
||||
raise IndexError('Index (%d) out of range -%d to %d.' %
|
||||
(j.min(), self.shape[1], self.shape[1]-1))
|
||||
if min_j < 0:
|
||||
j = j.copy()
|
||||
j[j < 0] += self.shape[1]
|
||||
|
||||
dict.update(self, izip(izip(i.flat, j.flat), x.flat))
|
||||
|
||||
if 0 in x:
|
||||
zeroes = x == 0
|
||||
for key in izip(i[zeroes].flat, j[zeroes].flat):
|
||||
if dict.__getitem__(self, key) == 0:
|
||||
# may have been superseded by later update
|
||||
del self[key]
|
||||
|
||||
def __add__(self, other):
|
||||
if isscalarlike(other):
|
||||
res_dtype = upcast_scalar(self.dtype, other)
|
||||
new = dok_matrix(self.shape, dtype=res_dtype)
|
||||
# Add this scalar to every element.
|
||||
M, N = self.shape
|
||||
for key in itertools.product(xrange(M), xrange(N)):
|
||||
aij = dict.get(self, (key), 0) + other
|
||||
if aij:
|
||||
new[key] = aij
|
||||
# new.dtype.char = self.dtype.char
|
||||
elif isspmatrix_dok(other):
|
||||
if other.shape != self.shape:
|
||||
raise ValueError("Matrix dimensions are not equal.")
|
||||
# We could alternatively set the dimensions to the largest of
|
||||
# the two matrices to be summed. Would this be a good idea?
|
||||
res_dtype = upcast(self.dtype, other.dtype)
|
||||
new = dok_matrix(self.shape, dtype=res_dtype)
|
||||
dict.update(new, self)
|
||||
with np.errstate(over='ignore'):
|
||||
dict.update(new,
|
||||
((k, new[k] + other[k]) for k in iterkeys(other)))
|
||||
elif isspmatrix(other):
|
||||
csc = self.tocsc()
|
||||
new = csc + other
|
||||
elif isdense(other):
|
||||
new = self.todense() + other
|
||||
else:
|
||||
return NotImplemented
|
||||
return new
|
||||
|
||||
def __radd__(self, other):
|
||||
if isscalarlike(other):
|
||||
new = dok_matrix(self.shape, dtype=self.dtype)
|
||||
M, N = self.shape
|
||||
for key in itertools.product(xrange(M), xrange(N)):
|
||||
aij = dict.get(self, (key), 0) + other
|
||||
if aij:
|
||||
new[key] = aij
|
||||
elif isspmatrix_dok(other):
|
||||
if other.shape != self.shape:
|
||||
raise ValueError("Matrix dimensions are not equal.")
|
||||
new = dok_matrix(self.shape, dtype=self.dtype)
|
||||
dict.update(new, self)
|
||||
dict.update(new,
|
||||
((k, self[k] + other[k]) for k in iterkeys(other)))
|
||||
elif isspmatrix(other):
|
||||
csc = self.tocsc()
|
||||
new = csc + other
|
||||
elif isdense(other):
|
||||
new = other + self.todense()
|
||||
else:
|
||||
return NotImplemented
|
||||
return new
|
||||
|
||||
def __neg__(self):
|
||||
if self.dtype.kind == 'b':
|
||||
raise NotImplementedError('Negating a sparse boolean matrix is not'
|
||||
' supported.')
|
||||
new = dok_matrix(self.shape, dtype=self.dtype)
|
||||
dict.update(new, ((k, -self[k]) for k in iterkeys(self)))
|
||||
return new
|
||||
|
||||
def _mul_scalar(self, other):
|
||||
res_dtype = upcast_scalar(self.dtype, other)
|
||||
# Multiply this scalar by every element.
|
||||
new = dok_matrix(self.shape, dtype=res_dtype)
|
||||
dict.update(new, ((k, v * other) for k, v in iteritems(self)))
|
||||
return new
|
||||
|
||||
def _mul_vector(self, other):
|
||||
# matrix * vector
|
||||
result = np.zeros(self.shape[0], dtype=upcast(self.dtype, other.dtype))
|
||||
for (i, j), v in iteritems(self):
|
||||
result[i] += v * other[j]
|
||||
return result
|
||||
|
||||
def _mul_multivector(self, other):
|
||||
# matrix * multivector
|
||||
result_shape = (self.shape[0], other.shape[1])
|
||||
result_dtype = upcast(self.dtype, other.dtype)
|
||||
result = np.zeros(result_shape, dtype=result_dtype)
|
||||
for (i, j), v in iteritems(self):
|
||||
result[i,:] += v * other[j,:]
|
||||
return result
|
||||
|
||||
def __imul__(self, other):
|
||||
if isscalarlike(other):
|
||||
dict.update(self, ((k, v * other) for k, v in iteritems(self)))
|
||||
return self
|
||||
return NotImplemented
|
||||
|
||||
def __truediv__(self, other):
|
||||
if isscalarlike(other):
|
||||
res_dtype = upcast_scalar(self.dtype, other)
|
||||
new = dok_matrix(self.shape, dtype=res_dtype)
|
||||
dict.update(new, ((k, v / other) for k, v in iteritems(self)))
|
||||
return new
|
||||
return self.tocsr() / other
|
||||
|
||||
def __itruediv__(self, other):
|
||||
if isscalarlike(other):
|
||||
dict.update(self, ((k, v / other) for k, v in iteritems(self)))
|
||||
return self
|
||||
return NotImplemented
|
||||
|
||||
def __reduce__(self):
|
||||
# this approach is necessary because __setstate__ is called after
|
||||
# __setitem__ upon unpickling and since __init__ is not called there
|
||||
# is no shape attribute hence it is not possible to unpickle it.
|
||||
return dict.__reduce__(self)
|
||||
|
||||
# What should len(sparse) return? For consistency with dense matrices,
|
||||
# perhaps it should be the number of rows? For now it returns the number
|
||||
# of non-zeros.
|
||||
|
||||
def transpose(self, axes=None, copy=False):
|
||||
if axes is not None:
|
||||
raise ValueError("Sparse matrices do not support "
|
||||
"an 'axes' parameter because swapping "
|
||||
"dimensions is the only logical permutation.")
|
||||
|
||||
M, N = self.shape
|
||||
new = dok_matrix((N, M), dtype=self.dtype, copy=copy)
|
||||
dict.update(new, (((right, left), val)
|
||||
for (left, right), val in iteritems(self)))
|
||||
return new
|
||||
|
||||
transpose.__doc__ = spmatrix.transpose.__doc__
|
||||
|
||||
def conjtransp(self):
|
||||
"""Return the conjugate transpose."""
|
||||
M, N = self.shape
|
||||
new = dok_matrix((N, M), dtype=self.dtype)
|
||||
dict.update(new, (((right, left), np.conj(val))
|
||||
for (left, right), val in iteritems(self)))
|
||||
return new
|
||||
|
||||
def copy(self):
|
||||
new = dok_matrix(self.shape, dtype=self.dtype)
|
||||
dict.update(new, self)
|
||||
return new
|
||||
|
||||
copy.__doc__ = spmatrix.copy.__doc__
|
||||
|
||||
def getrow(self, i):
|
||||
"""Returns the i-th row as a (1 x n) DOK matrix."""
|
||||
new = dok_matrix((1, self.shape[1]), dtype=self.dtype)
|
||||
dict.update(new, (((0, j), self[i, j]) for j in xrange(self.shape[1])))
|
||||
return new
|
||||
|
||||
def getcol(self, j):
|
||||
"""Returns the j-th column as a (m x 1) DOK matrix."""
|
||||
new = dok_matrix((self.shape[0], 1), dtype=self.dtype)
|
||||
dict.update(new, (((i, 0), self[i, j]) for i in xrange(self.shape[0])))
|
||||
return new
|
||||
|
||||
def tocoo(self, copy=False):
|
||||
from .coo import coo_matrix
|
||||
if self.nnz == 0:
|
||||
return coo_matrix(self.shape, dtype=self.dtype)
|
||||
|
||||
idx_dtype = get_index_dtype(maxval=max(self.shape))
|
||||
data = np.fromiter(itervalues(self), dtype=self.dtype, count=self.nnz)
|
||||
row = np.fromiter((i for i, _ in iterkeys(self)), dtype=idx_dtype, count=self.nnz)
|
||||
col = np.fromiter((j for _, j in iterkeys(self)), dtype=idx_dtype, count=self.nnz)
|
||||
A = coo_matrix((data, (row, col)), shape=self.shape, dtype=self.dtype)
|
||||
A.has_canonical_format = True
|
||||
return A
|
||||
|
||||
tocoo.__doc__ = spmatrix.tocoo.__doc__
|
||||
|
||||
def todok(self, copy=False):
|
||||
if copy:
|
||||
return self.copy()
|
||||
return self
|
||||
|
||||
todok.__doc__ = spmatrix.todok.__doc__
|
||||
|
||||
def tocsc(self, copy=False):
|
||||
return self.tocoo(copy=False).tocsc(copy=copy)
|
||||
|
||||
tocsc.__doc__ = spmatrix.tocsc.__doc__
|
||||
|
||||
def resize(self, *shape):
|
||||
shape = check_shape(shape)
|
||||
newM, newN = shape
|
||||
M, N = self.shape
|
||||
if newM < M or newN < N:
|
||||
# Remove all elements outside new dimensions
|
||||
for (i, j) in list(iterkeys(self)):
|
||||
if i >= newM or j >= newN:
|
||||
del self[i, j]
|
||||
self._shape = shape
|
||||
|
||||
resize.__doc__ = spmatrix.resize.__doc__
|
||||
|
||||
|
||||
def isspmatrix_dok(x):
|
||||
"""Is x of dok_matrix type?
|
||||
|
||||
Parameters
|
||||
----------
|
||||
x
|
||||
object to check for being a dok matrix
|
||||
|
||||
Returns
|
||||
-------
|
||||
bool
|
||||
True if x is a dok matrix, False otherwise
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> from scipy.sparse import dok_matrix, isspmatrix_dok
|
||||
>>> isspmatrix_dok(dok_matrix([[5]]))
|
||||
True
|
||||
|
||||
>>> from scipy.sparse import dok_matrix, csr_matrix, isspmatrix_dok
|
||||
>>> isspmatrix_dok(csr_matrix([[5]]))
|
||||
False
|
||||
"""
|
||||
return isinstance(x, dok_matrix)
|
||||
|
||||
|
||||
def _prod(x):
|
||||
"""Product of a list of numbers; ~40x faster vs np.prod for Python tuples"""
|
||||
if len(x) == 0:
|
||||
return 1
|
||||
return functools.reduce(operator.mul, x)
|
||||
@@ -0,0 +1,171 @@
|
||||
"""Functions to extract parts of sparse matrices
|
||||
"""
|
||||
|
||||
from __future__ import division, print_function, absolute_import
|
||||
|
||||
__docformat__ = "restructuredtext en"
|
||||
|
||||
__all__ = ['find', 'tril', 'triu']
|
||||
|
||||
|
||||
from .coo import coo_matrix
|
||||
|
||||
|
||||
def find(A):
|
||||
"""Return the indices and values of the nonzero elements of a matrix
|
||||
|
||||
Parameters
|
||||
----------
|
||||
A : dense or sparse matrix
|
||||
Matrix whose nonzero elements are desired.
|
||||
|
||||
Returns
|
||||
-------
|
||||
(I,J,V) : tuple of arrays
|
||||
I,J, and V contain the row indices, column indices, and values
|
||||
of the nonzero matrix entries.
|
||||
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> from scipy.sparse import csr_matrix, find
|
||||
>>> A = csr_matrix([[7.0, 8.0, 0],[0, 0, 9.0]])
|
||||
>>> find(A)
|
||||
(array([0, 0, 1], dtype=int32), array([0, 1, 2], dtype=int32), array([ 7., 8., 9.]))
|
||||
|
||||
"""
|
||||
|
||||
A = coo_matrix(A, copy=True)
|
||||
A.sum_duplicates()
|
||||
# remove explicit zeros
|
||||
nz_mask = A.data != 0
|
||||
return A.row[nz_mask], A.col[nz_mask], A.data[nz_mask]
|
||||
|
||||
|
||||
def tril(A, k=0, format=None):
|
||||
"""Return the lower triangular portion of a matrix in sparse format
|
||||
|
||||
Returns the elements on or below the k-th diagonal of the matrix A.
|
||||
- k = 0 corresponds to the main diagonal
|
||||
- k > 0 is above the main diagonal
|
||||
- k < 0 is below the main diagonal
|
||||
|
||||
Parameters
|
||||
----------
|
||||
A : dense or sparse matrix
|
||||
Matrix whose lower trianglar portion is desired.
|
||||
k : integer : optional
|
||||
The top-most diagonal of the lower triangle.
|
||||
format : string
|
||||
Sparse format of the result, e.g. format="csr", etc.
|
||||
|
||||
Returns
|
||||
-------
|
||||
L : sparse matrix
|
||||
Lower triangular portion of A in sparse format.
|
||||
|
||||
See Also
|
||||
--------
|
||||
triu : upper triangle in sparse format
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> from scipy.sparse import csr_matrix, tril
|
||||
>>> A = csr_matrix([[1, 2, 0, 0, 3], [4, 5, 0, 6, 7], [0, 0, 8, 9, 0]],
|
||||
... dtype='int32')
|
||||
>>> A.toarray()
|
||||
array([[1, 2, 0, 0, 3],
|
||||
[4, 5, 0, 6, 7],
|
||||
[0, 0, 8, 9, 0]])
|
||||
>>> tril(A).toarray()
|
||||
array([[1, 0, 0, 0, 0],
|
||||
[4, 5, 0, 0, 0],
|
||||
[0, 0, 8, 0, 0]])
|
||||
>>> tril(A).nnz
|
||||
4
|
||||
>>> tril(A, k=1).toarray()
|
||||
array([[1, 2, 0, 0, 0],
|
||||
[4, 5, 0, 0, 0],
|
||||
[0, 0, 8, 9, 0]])
|
||||
>>> tril(A, k=-1).toarray()
|
||||
array([[0, 0, 0, 0, 0],
|
||||
[4, 0, 0, 0, 0],
|
||||
[0, 0, 0, 0, 0]])
|
||||
>>> tril(A, format='csc')
|
||||
<3x5 sparse matrix of type '<class 'numpy.int32'>'
|
||||
with 4 stored elements in Compressed Sparse Column format>
|
||||
|
||||
"""
|
||||
|
||||
# convert to COOrdinate format where things are easy
|
||||
A = coo_matrix(A, copy=False)
|
||||
mask = A.row + k >= A.col
|
||||
return _masked_coo(A, mask).asformat(format)
|
||||
|
||||
|
||||
def triu(A, k=0, format=None):
|
||||
"""Return the upper triangular portion of a matrix in sparse format
|
||||
|
||||
Returns the elements on or above the k-th diagonal of the matrix A.
|
||||
- k = 0 corresponds to the main diagonal
|
||||
- k > 0 is above the main diagonal
|
||||
- k < 0 is below the main diagonal
|
||||
|
||||
Parameters
|
||||
----------
|
||||
A : dense or sparse matrix
|
||||
Matrix whose upper trianglar portion is desired.
|
||||
k : integer : optional
|
||||
The bottom-most diagonal of the upper triangle.
|
||||
format : string
|
||||
Sparse format of the result, e.g. format="csr", etc.
|
||||
|
||||
Returns
|
||||
-------
|
||||
L : sparse matrix
|
||||
Upper triangular portion of A in sparse format.
|
||||
|
||||
See Also
|
||||
--------
|
||||
tril : lower triangle in sparse format
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> from scipy.sparse import csr_matrix, triu
|
||||
>>> A = csr_matrix([[1, 2, 0, 0, 3], [4, 5, 0, 6, 7], [0, 0, 8, 9, 0]],
|
||||
... dtype='int32')
|
||||
>>> A.toarray()
|
||||
array([[1, 2, 0, 0, 3],
|
||||
[4, 5, 0, 6, 7],
|
||||
[0, 0, 8, 9, 0]])
|
||||
>>> triu(A).toarray()
|
||||
array([[1, 2, 0, 0, 3],
|
||||
[0, 5, 0, 6, 7],
|
||||
[0, 0, 8, 9, 0]])
|
||||
>>> triu(A).nnz
|
||||
8
|
||||
>>> triu(A, k=1).toarray()
|
||||
array([[0, 2, 0, 0, 3],
|
||||
[0, 0, 0, 6, 7],
|
||||
[0, 0, 0, 9, 0]])
|
||||
>>> triu(A, k=-1).toarray()
|
||||
array([[1, 2, 0, 0, 3],
|
||||
[4, 5, 0, 6, 7],
|
||||
[0, 0, 8, 9, 0]])
|
||||
>>> triu(A, format='csc')
|
||||
<3x5 sparse matrix of type '<class 'numpy.int32'>'
|
||||
with 8 stored elements in Compressed Sparse Column format>
|
||||
|
||||
"""
|
||||
|
||||
# convert to COOrdinate format where things are easy
|
||||
A = coo_matrix(A, copy=False)
|
||||
mask = A.row + k <= A.col
|
||||
return _masked_coo(A, mask).asformat(format)
|
||||
|
||||
|
||||
def _masked_coo(A, mask):
|
||||
row = A.row[mask]
|
||||
col = A.col[mask]
|
||||
data = A.data[mask]
|
||||
return coo_matrix((data, (row, col)), shape=A.shape, dtype=A.dtype)
|
||||
@@ -0,0 +1,429 @@
|
||||
"""
|
||||
python generate_sparsetools.py
|
||||
|
||||
Generate manual wrappers for C++ sparsetools code.
|
||||
|
||||
Type codes used:
|
||||
|
||||
'i': integer scalar
|
||||
'I': integer array
|
||||
'T': data array
|
||||
'B': boolean array
|
||||
'V': std::vector<integer>*
|
||||
'W': std::vector<data>*
|
||||
'*': indicates that the next argument is an output argument
|
||||
'v': void
|
||||
'l': 64-bit integer scalar
|
||||
|
||||
See sparsetools.cxx for more details.
|
||||
|
||||
"""
|
||||
import optparse
|
||||
import os
|
||||
from distutils.dep_util import newer
|
||||
|
||||
#
|
||||
# List of all routines and their argument types.
|
||||
#
|
||||
# The first code indicates the return value, the rest the arguments.
|
||||
#
|
||||
|
||||
# bsr.h
|
||||
BSR_ROUTINES = """
|
||||
bsr_diagonal v iiiiiIIT*T
|
||||
bsr_tocsr v iiiiIIT*I*I*T
|
||||
bsr_scale_rows v iiiiII*TT
|
||||
bsr_scale_columns v iiiiII*TT
|
||||
bsr_sort_indices v iiii*I*I*T
|
||||
bsr_transpose v iiiiIIT*I*I*T
|
||||
bsr_matmat_pass2 v iiiiiIITIIT*I*I*T
|
||||
bsr_matvec v iiiiIITT*T
|
||||
bsr_matvecs v iiiiiIITT*T
|
||||
bsr_elmul_bsr v iiiiIITIIT*I*I*T
|
||||
bsr_eldiv_bsr v iiiiIITIIT*I*I*T
|
||||
bsr_plus_bsr v iiiiIITIIT*I*I*T
|
||||
bsr_minus_bsr v iiiiIITIIT*I*I*T
|
||||
bsr_maximum_bsr v iiiiIITIIT*I*I*T
|
||||
bsr_minimum_bsr v iiiiIITIIT*I*I*T
|
||||
bsr_ne_bsr v iiiiIITIIT*I*I*B
|
||||
bsr_lt_bsr v iiiiIITIIT*I*I*B
|
||||
bsr_gt_bsr v iiiiIITIIT*I*I*B
|
||||
bsr_le_bsr v iiiiIITIIT*I*I*B
|
||||
bsr_ge_bsr v iiiiIITIIT*I*I*B
|
||||
"""
|
||||
|
||||
# csc.h
|
||||
CSC_ROUTINES = """
|
||||
csc_diagonal v iiiIIT*T
|
||||
csc_tocsr v iiIIT*I*I*T
|
||||
csc_matmat_pass1 v iiIIII*I
|
||||
csc_matmat_pass2 v iiIITIIT*I*I*T
|
||||
csc_matvec v iiIITT*T
|
||||
csc_matvecs v iiiIITT*T
|
||||
csc_elmul_csc v iiIITIIT*I*I*T
|
||||
csc_eldiv_csc v iiIITIIT*I*I*T
|
||||
csc_plus_csc v iiIITIIT*I*I*T
|
||||
csc_minus_csc v iiIITIIT*I*I*T
|
||||
csc_maximum_csc v iiIITIIT*I*I*T
|
||||
csc_minimum_csc v iiIITIIT*I*I*T
|
||||
csc_ne_csc v iiIITIIT*I*I*B
|
||||
csc_lt_csc v iiIITIIT*I*I*B
|
||||
csc_gt_csc v iiIITIIT*I*I*B
|
||||
csc_le_csc v iiIITIIT*I*I*B
|
||||
csc_ge_csc v iiIITIIT*I*I*B
|
||||
"""
|
||||
|
||||
# csr.h
|
||||
CSR_ROUTINES = """
|
||||
csr_matmat_pass1 v iiIIII*I
|
||||
csr_matmat_pass2 v iiIITIIT*I*I*T
|
||||
csr_diagonal v iiiIIT*T
|
||||
csr_tocsc v iiIIT*I*I*T
|
||||
csr_tobsr v iiiiIIT*I*I*T
|
||||
csr_todense v iiIIT*T
|
||||
csr_matvec v iiIITT*T
|
||||
csr_matvecs v iiiIITT*T
|
||||
csr_elmul_csr v iiIITIIT*I*I*T
|
||||
csr_eldiv_csr v iiIITIIT*I*I*T
|
||||
csr_plus_csr v iiIITIIT*I*I*T
|
||||
csr_minus_csr v iiIITIIT*I*I*T
|
||||
csr_maximum_csr v iiIITIIT*I*I*T
|
||||
csr_minimum_csr v iiIITIIT*I*I*T
|
||||
csr_ne_csr v iiIITIIT*I*I*B
|
||||
csr_lt_csr v iiIITIIT*I*I*B
|
||||
csr_gt_csr v iiIITIIT*I*I*B
|
||||
csr_le_csr v iiIITIIT*I*I*B
|
||||
csr_ge_csr v iiIITIIT*I*I*B
|
||||
csr_scale_rows v iiII*TT
|
||||
csr_scale_columns v iiII*TT
|
||||
csr_sort_indices v iI*I*T
|
||||
csr_eliminate_zeros v ii*I*I*T
|
||||
csr_sum_duplicates v ii*I*I*T
|
||||
get_csr_submatrix v iiIITiiii*V*V*W
|
||||
csr_sample_values v iiIITiII*T
|
||||
csr_count_blocks i iiiiII
|
||||
csr_sample_offsets i iiIIiII*I
|
||||
expandptr v iI*I
|
||||
test_throw_error i
|
||||
csr_has_sorted_indices i iII
|
||||
csr_has_canonical_format i iII
|
||||
"""
|
||||
|
||||
# coo.h, dia.h, csgraph.h
|
||||
OTHER_ROUTINES = """
|
||||
coo_tocsr v iiiIIT*I*I*T
|
||||
coo_todense v iilIIT*Ti
|
||||
coo_matvec v lIITT*T
|
||||
dia_matvec v iiiiITT*T
|
||||
cs_graph_components i iII*I
|
||||
"""
|
||||
|
||||
# List of compilation units
|
||||
COMPILATION_UNITS = [
|
||||
('bsr', BSR_ROUTINES),
|
||||
('csr', CSR_ROUTINES),
|
||||
('csc', CSC_ROUTINES),
|
||||
('other', OTHER_ROUTINES),
|
||||
]
|
||||
|
||||
#
|
||||
# List of the supported index typenums and the corresponding C++ types
|
||||
#
|
||||
I_TYPES = [
|
||||
('NPY_INT32', 'npy_int32'),
|
||||
('NPY_INT64', 'npy_int64'),
|
||||
]
|
||||
|
||||
#
|
||||
# List of the supported data typenums and the corresponding C++ types
|
||||
#
|
||||
T_TYPES = [
|
||||
('NPY_BOOL', 'npy_bool_wrapper'),
|
||||
('NPY_BYTE', 'npy_byte'),
|
||||
('NPY_UBYTE', 'npy_ubyte'),
|
||||
('NPY_SHORT', 'npy_short'),
|
||||
('NPY_USHORT', 'npy_ushort'),
|
||||
('NPY_INT', 'npy_int'),
|
||||
('NPY_UINT', 'npy_uint'),
|
||||
('NPY_LONG', 'npy_long'),
|
||||
('NPY_ULONG', 'npy_ulong'),
|
||||
('NPY_LONGLONG', 'npy_longlong'),
|
||||
('NPY_ULONGLONG', 'npy_ulonglong'),
|
||||
('NPY_FLOAT', 'npy_float'),
|
||||
('NPY_DOUBLE', 'npy_double'),
|
||||
('NPY_LONGDOUBLE', 'npy_longdouble'),
|
||||
('NPY_CFLOAT', 'npy_cfloat_wrapper'),
|
||||
('NPY_CDOUBLE', 'npy_cdouble_wrapper'),
|
||||
('NPY_CLONGDOUBLE', 'npy_clongdouble_wrapper'),
|
||||
]
|
||||
|
||||
#
|
||||
# Code templates
|
||||
#
|
||||
|
||||
THUNK_TEMPLATE = """
|
||||
static PY_LONG_LONG %(name)s_thunk(int I_typenum, int T_typenum, void **a)
|
||||
{
|
||||
%(thunk_content)s
|
||||
}
|
||||
"""
|
||||
|
||||
METHOD_TEMPLATE = """
|
||||
NPY_VISIBILITY_HIDDEN PyObject *
|
||||
%(name)s_method(PyObject *self, PyObject *args)
|
||||
{
|
||||
return call_thunk('%(ret_spec)s', "%(arg_spec)s", %(name)s_thunk, args);
|
||||
}
|
||||
"""
|
||||
|
||||
GET_THUNK_CASE_TEMPLATE = """
|
||||
static int get_thunk_case(int I_typenum, int T_typenum)
|
||||
{
|
||||
%(content)s;
|
||||
return -1;
|
||||
}
|
||||
"""
|
||||
|
||||
|
||||
#
|
||||
# Code generation
|
||||
#
|
||||
|
||||
def get_thunk_type_set():
|
||||
"""
|
||||
Get a list containing cartesian product of data types, plus a getter routine.
|
||||
|
||||
Returns
|
||||
-------
|
||||
i_types : list [(j, I_typenum, None, I_type, None), ...]
|
||||
Pairing of index type numbers and the corresponding C++ types,
|
||||
and an unique index `j`. This is for routines that are parameterized
|
||||
only by I but not by T.
|
||||
it_types : list [(j, I_typenum, T_typenum, I_type, T_type), ...]
|
||||
Same as `i_types`, but for routines parameterized both by T and I.
|
||||
getter_code : str
|
||||
C++ code for a function that takes I_typenum, T_typenum and returns
|
||||
the unique index corresponding to the lists, or -1 if no match was
|
||||
found.
|
||||
|
||||
"""
|
||||
it_types = []
|
||||
i_types = []
|
||||
|
||||
j = 0
|
||||
|
||||
getter_code = " if (0) {}"
|
||||
|
||||
for I_typenum, I_type in I_TYPES:
|
||||
piece = """
|
||||
else if (I_typenum == %(I_typenum)s) {
|
||||
if (T_typenum == -1) { return %(j)s; }"""
|
||||
getter_code += piece % dict(I_typenum=I_typenum, j=j)
|
||||
|
||||
i_types.append((j, I_typenum, None, I_type, None))
|
||||
j += 1
|
||||
|
||||
for T_typenum, T_type in T_TYPES:
|
||||
piece = """
|
||||
else if (T_typenum == %(T_typenum)s) { return %(j)s; }"""
|
||||
getter_code += piece % dict(T_typenum=T_typenum, j=j)
|
||||
|
||||
it_types.append((j, I_typenum, T_typenum, I_type, T_type))
|
||||
j += 1
|
||||
|
||||
getter_code += """
|
||||
}"""
|
||||
|
||||
return i_types, it_types, GET_THUNK_CASE_TEMPLATE % dict(content=getter_code)
|
||||
|
||||
|
||||
def parse_routine(name, args, types):
|
||||
"""
|
||||
Generate thunk and method code for a given routine.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
name : str
|
||||
Name of the C++ routine
|
||||
args : str
|
||||
Argument list specification (in format explained above)
|
||||
types : list
|
||||
List of types to instantiate, as returned `get_thunk_type_set`
|
||||
|
||||
"""
|
||||
|
||||
ret_spec = args[0]
|
||||
arg_spec = args[1:]
|
||||
|
||||
def get_arglist(I_type, T_type):
|
||||
"""
|
||||
Generate argument list for calling the C++ function
|
||||
"""
|
||||
args = []
|
||||
next_is_writeable = False
|
||||
j = 0
|
||||
for t in arg_spec:
|
||||
const = '' if next_is_writeable else 'const '
|
||||
next_is_writeable = False
|
||||
if t == '*':
|
||||
next_is_writeable = True
|
||||
continue
|
||||
elif t == 'i':
|
||||
args.append("*(%s*)a[%d]" % (const + I_type, j))
|
||||
elif t == 'I':
|
||||
args.append("(%s*)a[%d]" % (const + I_type, j))
|
||||
elif t == 'T':
|
||||
args.append("(%s*)a[%d]" % (const + T_type, j))
|
||||
elif t == 'B':
|
||||
args.append("(npy_bool_wrapper*)a[%d]" % (j,))
|
||||
elif t == 'V':
|
||||
if const:
|
||||
raise ValueError("'V' argument must be an output arg")
|
||||
args.append("(std::vector<%s>*)a[%d]" % (I_type, j,))
|
||||
elif t == 'W':
|
||||
if const:
|
||||
raise ValueError("'W' argument must be an output arg")
|
||||
args.append("(std::vector<%s>*)a[%d]" % (T_type, j,))
|
||||
elif t == 'l':
|
||||
args.append("*(%snpy_int64*)a[%d]" % (const, j))
|
||||
else:
|
||||
raise ValueError("Invalid spec character %r" % (t,))
|
||||
j += 1
|
||||
return ", ".join(args)
|
||||
|
||||
# Generate thunk code: a giant switch statement with different
|
||||
# type combinations inside.
|
||||
thunk_content = """int j = get_thunk_case(I_typenum, T_typenum);
|
||||
switch (j) {"""
|
||||
for j, I_typenum, T_typenum, I_type, T_type in types:
|
||||
arglist = get_arglist(I_type, T_type)
|
||||
if T_type is None:
|
||||
dispatch = "%s" % (I_type,)
|
||||
else:
|
||||
dispatch = "%s,%s" % (I_type, T_type)
|
||||
if 'B' in arg_spec:
|
||||
dispatch += ",npy_bool_wrapper"
|
||||
|
||||
piece = """
|
||||
case %(j)s:"""
|
||||
if ret_spec == 'v':
|
||||
piece += """
|
||||
(void)%(name)s<%(dispatch)s>(%(arglist)s);
|
||||
return 0;"""
|
||||
else:
|
||||
piece += """
|
||||
return %(name)s<%(dispatch)s>(%(arglist)s);"""
|
||||
thunk_content += piece % dict(j=j, I_type=I_type, T_type=T_type,
|
||||
I_typenum=I_typenum, T_typenum=T_typenum,
|
||||
arglist=arglist, name=name,
|
||||
dispatch=dispatch)
|
||||
|
||||
thunk_content += """
|
||||
default:
|
||||
throw std::runtime_error("internal error: invalid argument typenums");
|
||||
}"""
|
||||
|
||||
thunk_code = THUNK_TEMPLATE % dict(name=name,
|
||||
thunk_content=thunk_content)
|
||||
|
||||
# Generate method code
|
||||
method_code = METHOD_TEMPLATE % dict(name=name,
|
||||
ret_spec=ret_spec,
|
||||
arg_spec=arg_spec)
|
||||
|
||||
return thunk_code, method_code
|
||||
|
||||
|
||||
def main():
|
||||
p = optparse.OptionParser(usage=(__doc__ or '').strip())
|
||||
p.add_option("--no-force", action="store_false",
|
||||
dest="force", default=True)
|
||||
options, args = p.parse_args()
|
||||
|
||||
names = []
|
||||
|
||||
i_types, it_types, getter_code = get_thunk_type_set()
|
||||
|
||||
# Generate *_impl.h for each compilation unit
|
||||
for unit_name, routines in COMPILATION_UNITS:
|
||||
thunks = []
|
||||
methods = []
|
||||
|
||||
# Generate thunks and methods for all routines
|
||||
for line in routines.splitlines():
|
||||
line = line.strip()
|
||||
if not line or line.startswith('#'):
|
||||
continue
|
||||
|
||||
try:
|
||||
name, args = line.split(None, 1)
|
||||
except ValueError:
|
||||
raise ValueError("Malformed line: %r" % (line,))
|
||||
|
||||
args = "".join(args.split())
|
||||
if 't' in args or 'T' in args:
|
||||
thunk, method = parse_routine(name, args, it_types)
|
||||
else:
|
||||
thunk, method = parse_routine(name, args, i_types)
|
||||
|
||||
if name in names:
|
||||
raise ValueError("Duplicate routine %r" % (name,))
|
||||
|
||||
names.append(name)
|
||||
thunks.append(thunk)
|
||||
methods.append(method)
|
||||
|
||||
# Produce output
|
||||
dst = os.path.join(os.path.dirname(__file__),
|
||||
'sparsetools',
|
||||
unit_name + '_impl.h')
|
||||
if newer(__file__, dst) or options.force:
|
||||
print("[generate_sparsetools] generating %r" % (dst,))
|
||||
with open(dst, 'w') as f:
|
||||
write_autogen_blurb(f)
|
||||
f.write(getter_code)
|
||||
for thunk in thunks:
|
||||
f.write(thunk)
|
||||
for method in methods:
|
||||
f.write(method)
|
||||
else:
|
||||
print("[generate_sparsetools] %r already up-to-date" % (dst,))
|
||||
|
||||
# Generate code for method struct
|
||||
method_defs = ""
|
||||
for name in names:
|
||||
method_defs += "NPY_VISIBILITY_HIDDEN PyObject *%s_method(PyObject *, PyObject *);\n" % (name,)
|
||||
|
||||
method_struct = """\nstatic struct PyMethodDef sparsetools_methods[] = {"""
|
||||
for name in names:
|
||||
method_struct += """
|
||||
{"%(name)s", (PyCFunction)%(name)s_method, METH_VARARGS, NULL},""" % dict(name=name)
|
||||
method_struct += """
|
||||
{NULL, NULL, 0, NULL}
|
||||
};"""
|
||||
|
||||
# Produce sparsetools_impl.h
|
||||
dst = os.path.join(os.path.dirname(__file__),
|
||||
'sparsetools',
|
||||
'sparsetools_impl.h')
|
||||
|
||||
if newer(__file__, dst) or options.force:
|
||||
print("[generate_sparsetools] generating %r" % (dst,))
|
||||
with open(dst, 'w') as f:
|
||||
write_autogen_blurb(f)
|
||||
f.write(method_defs)
|
||||
f.write(method_struct)
|
||||
else:
|
||||
print("[generate_sparsetools] %r already up-to-date" % (dst,))
|
||||
|
||||
|
||||
def write_autogen_blurb(stream):
|
||||
stream.write("""\
|
||||
/* This file is autogenerated by generate_sparsetools.py
|
||||
* Do not edit manually or check into VCS.
|
||||
*/
|
||||
""")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,548 @@
|
||||
"""LInked List sparse matrix class
|
||||
"""
|
||||
|
||||
from __future__ import division, print_function, absolute_import
|
||||
|
||||
__docformat__ = "restructuredtext en"
|
||||
|
||||
__all__ = ['lil_matrix','isspmatrix_lil']
|
||||
|
||||
from bisect import bisect_left
|
||||
|
||||
import numpy as np
|
||||
|
||||
from scipy._lib.six import xrange, zip
|
||||
from .base import spmatrix, isspmatrix
|
||||
from .sputils import (getdtype, isshape, isscalarlike, IndexMixin,
|
||||
upcast_scalar, get_index_dtype, isintlike, check_shape,
|
||||
check_reshape_kwargs)
|
||||
from . import _csparsetools
|
||||
|
||||
|
||||
class lil_matrix(spmatrix, IndexMixin):
|
||||
"""Row-based linked list sparse matrix
|
||||
|
||||
This is a structure for constructing sparse matrices incrementally.
|
||||
Note that inserting a single item can take linear time in the worst case;
|
||||
to construct a matrix efficiently, make sure the items are pre-sorted by
|
||||
index, per row.
|
||||
|
||||
This can be instantiated in several ways:
|
||||
lil_matrix(D)
|
||||
with a dense matrix or rank-2 ndarray D
|
||||
|
||||
lil_matrix(S)
|
||||
with another sparse matrix S (equivalent to S.tolil())
|
||||
|
||||
lil_matrix((M, N), [dtype])
|
||||
to construct an empty matrix with shape (M, N)
|
||||
dtype is optional, defaulting to dtype='d'.
|
||||
|
||||
Attributes
|
||||
----------
|
||||
dtype : dtype
|
||||
Data type of the matrix
|
||||
shape : 2-tuple
|
||||
Shape of the matrix
|
||||
ndim : int
|
||||
Number of dimensions (this is always 2)
|
||||
nnz
|
||||
Number of nonzero elements
|
||||
data
|
||||
LIL format data array of the matrix
|
||||
rows
|
||||
LIL format row index array of the matrix
|
||||
|
||||
Notes
|
||||
-----
|
||||
|
||||
Sparse matrices can be used in arithmetic operations: they support
|
||||
addition, subtraction, multiplication, division, and matrix power.
|
||||
|
||||
Advantages of the LIL format
|
||||
- supports flexible slicing
|
||||
- changes to the matrix sparsity structure are efficient
|
||||
|
||||
Disadvantages of the LIL format
|
||||
- arithmetic operations LIL + LIL are slow (consider CSR or CSC)
|
||||
- slow column slicing (consider CSC)
|
||||
- slow matrix vector products (consider CSR or CSC)
|
||||
|
||||
Intended Usage
|
||||
- LIL is a convenient format for constructing sparse matrices
|
||||
- once a matrix has been constructed, convert to CSR or
|
||||
CSC format for fast arithmetic and matrix vector operations
|
||||
- consider using the COO format when constructing large matrices
|
||||
|
||||
Data Structure
|
||||
- An array (``self.rows``) of rows, each of which is a sorted
|
||||
list of column indices of non-zero elements.
|
||||
- The corresponding nonzero values are stored in similar
|
||||
fashion in ``self.data``.
|
||||
|
||||
|
||||
"""
|
||||
format = 'lil'
|
||||
|
||||
def __init__(self, arg1, shape=None, dtype=None, copy=False):
|
||||
spmatrix.__init__(self)
|
||||
self.dtype = getdtype(dtype, arg1, default=float)
|
||||
|
||||
# First get the shape
|
||||
if isspmatrix(arg1):
|
||||
if isspmatrix_lil(arg1) and copy:
|
||||
A = arg1.copy()
|
||||
else:
|
||||
A = arg1.tolil()
|
||||
|
||||
if dtype is not None:
|
||||
A = A.astype(dtype)
|
||||
|
||||
self._shape = check_shape(A.shape)
|
||||
self.dtype = A.dtype
|
||||
self.rows = A.rows
|
||||
self.data = A.data
|
||||
elif isinstance(arg1,tuple):
|
||||
if isshape(arg1):
|
||||
if shape is not None:
|
||||
raise ValueError('invalid use of shape parameter')
|
||||
M, N = arg1
|
||||
self._shape = check_shape((M, N))
|
||||
self.rows = np.empty((M,), dtype=object)
|
||||
self.data = np.empty((M,), dtype=object)
|
||||
for i in range(M):
|
||||
self.rows[i] = []
|
||||
self.data[i] = []
|
||||
else:
|
||||
raise TypeError('unrecognized lil_matrix constructor usage')
|
||||
else:
|
||||
# assume A is dense
|
||||
try:
|
||||
A = np.asmatrix(arg1)
|
||||
except TypeError:
|
||||
raise TypeError('unsupported matrix type')
|
||||
else:
|
||||
from .csr import csr_matrix
|
||||
A = csr_matrix(A, dtype=dtype).tolil()
|
||||
|
||||
self._shape = check_shape(A.shape)
|
||||
self.dtype = A.dtype
|
||||
self.rows = A.rows
|
||||
self.data = A.data
|
||||
|
||||
def __iadd__(self,other):
|
||||
self[:,:] = self + other
|
||||
return self
|
||||
|
||||
def __isub__(self,other):
|
||||
self[:,:] = self - other
|
||||
return self
|
||||
|
||||
def __imul__(self,other):
|
||||
if isscalarlike(other):
|
||||
self[:,:] = self * other
|
||||
return self
|
||||
else:
|
||||
return NotImplemented
|
||||
|
||||
def __itruediv__(self,other):
|
||||
if isscalarlike(other):
|
||||
self[:,:] = self / other
|
||||
return self
|
||||
else:
|
||||
return NotImplemented
|
||||
|
||||
# Whenever the dimensions change, empty lists should be created for each
|
||||
# row
|
||||
|
||||
def getnnz(self, axis=None):
|
||||
if axis is None:
|
||||
return sum([len(rowvals) for rowvals in self.data])
|
||||
if axis < 0:
|
||||
axis += 2
|
||||
if axis == 0:
|
||||
out = np.zeros(self.shape[1], dtype=np.intp)
|
||||
for row in self.rows:
|
||||
out[row] += 1
|
||||
return out
|
||||
elif axis == 1:
|
||||
return np.array([len(rowvals) for rowvals in self.data], dtype=np.intp)
|
||||
else:
|
||||
raise ValueError('axis out of bounds')
|
||||
|
||||
def count_nonzero(self):
|
||||
return sum(np.count_nonzero(rowvals) for rowvals in self.data)
|
||||
|
||||
getnnz.__doc__ = spmatrix.getnnz.__doc__
|
||||
count_nonzero.__doc__ = spmatrix.count_nonzero.__doc__
|
||||
|
||||
def __str__(self):
|
||||
val = ''
|
||||
for i, row in enumerate(self.rows):
|
||||
for pos, j in enumerate(row):
|
||||
val += " %s\t%s\n" % (str((i, j)), str(self.data[i][pos]))
|
||||
return val[:-1]
|
||||
|
||||
def getrowview(self, i):
|
||||
"""Returns a view of the 'i'th row (without copying).
|
||||
"""
|
||||
new = lil_matrix((1, self.shape[1]), dtype=self.dtype)
|
||||
new.rows[0] = self.rows[i]
|
||||
new.data[0] = self.data[i]
|
||||
return new
|
||||
|
||||
def getrow(self, i):
|
||||
"""Returns a copy of the 'i'th row.
|
||||
"""
|
||||
i = self._check_row_bounds(i)
|
||||
new = lil_matrix((1, self.shape[1]), dtype=self.dtype)
|
||||
new.rows[0] = self.rows[i][:]
|
||||
new.data[0] = self.data[i][:]
|
||||
return new
|
||||
|
||||
def _check_row_bounds(self, i):
|
||||
if i < 0:
|
||||
i += self.shape[0]
|
||||
if i < 0 or i >= self.shape[0]:
|
||||
raise IndexError('row index out of bounds')
|
||||
return i
|
||||
|
||||
def _check_col_bounds(self, j):
|
||||
if j < 0:
|
||||
j += self.shape[1]
|
||||
if j < 0 or j >= self.shape[1]:
|
||||
raise IndexError('column index out of bounds')
|
||||
return j
|
||||
|
||||
def __getitem__(self, index):
|
||||
"""Return the element(s) index=(i, j), where j may be a slice.
|
||||
This always returns a copy for consistency, since slices into
|
||||
Python lists return copies.
|
||||
"""
|
||||
|
||||
# Scalar fast path first
|
||||
if isinstance(index, tuple) and len(index) == 2:
|
||||
i, j = index
|
||||
# Use isinstance checks for common index types; this is
|
||||
# ~25-50% faster than isscalarlike. Other types are
|
||||
# handled below.
|
||||
if ((isinstance(i, int) or isinstance(i, np.integer)) and
|
||||
(isinstance(j, int) or isinstance(j, np.integer))):
|
||||
v = _csparsetools.lil_get1(self.shape[0], self.shape[1],
|
||||
self.rows, self.data,
|
||||
i, j)
|
||||
return self.dtype.type(v)
|
||||
|
||||
# Utilities found in IndexMixin
|
||||
i, j = self._unpack_index(index)
|
||||
|
||||
# Proper check for other scalar index types
|
||||
i_intlike = isintlike(i)
|
||||
j_intlike = isintlike(j)
|
||||
|
||||
if i_intlike and j_intlike:
|
||||
v = _csparsetools.lil_get1(self.shape[0], self.shape[1],
|
||||
self.rows, self.data,
|
||||
i, j)
|
||||
return self.dtype.type(v)
|
||||
elif j_intlike or isinstance(j, slice):
|
||||
# column slicing fast path
|
||||
if j_intlike:
|
||||
j = self._check_col_bounds(j)
|
||||
j = slice(j, j+1)
|
||||
|
||||
if i_intlike:
|
||||
i = self._check_row_bounds(i)
|
||||
i = xrange(i, i+1)
|
||||
i_shape = None
|
||||
elif isinstance(i, slice):
|
||||
i = xrange(*i.indices(self.shape[0]))
|
||||
i_shape = None
|
||||
else:
|
||||
i = np.atleast_1d(i)
|
||||
i_shape = i.shape
|
||||
|
||||
if i_shape is None or len(i_shape) == 1:
|
||||
return self._get_row_ranges(i, j)
|
||||
|
||||
i, j = self._index_to_arrays(i, j)
|
||||
if i.size == 0:
|
||||
return lil_matrix(i.shape, dtype=self.dtype)
|
||||
|
||||
new = lil_matrix(i.shape, dtype=self.dtype)
|
||||
|
||||
i, j = _prepare_index_for_memoryview(i, j)
|
||||
_csparsetools.lil_fancy_get(self.shape[0], self.shape[1],
|
||||
self.rows, self.data,
|
||||
new.rows, new.data,
|
||||
i, j)
|
||||
return new
|
||||
|
||||
def _get_row_ranges(self, rows, col_slice):
|
||||
"""
|
||||
Fast path for indexing in the case where column index is slice.
|
||||
|
||||
This gains performance improvement over brute force by more
|
||||
efficient skipping of zeros, by accessing the elements
|
||||
column-wise in order.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
rows : sequence or xrange
|
||||
Rows indexed. If xrange, must be within valid bounds.
|
||||
col_slice : slice
|
||||
Columns indexed
|
||||
|
||||
"""
|
||||
j_start, j_stop, j_stride = col_slice.indices(self.shape[1])
|
||||
col_range = xrange(j_start, j_stop, j_stride)
|
||||
nj = len(col_range)
|
||||
new = lil_matrix((len(rows), nj), dtype=self.dtype)
|
||||
|
||||
_csparsetools.lil_get_row_ranges(self.shape[0], self.shape[1],
|
||||
self.rows, self.data,
|
||||
new.rows, new.data,
|
||||
rows,
|
||||
j_start, j_stop, j_stride, nj)
|
||||
|
||||
return new
|
||||
|
||||
def __setitem__(self, index, x):
|
||||
# Scalar fast path first
|
||||
if isinstance(index, tuple) and len(index) == 2:
|
||||
i, j = index
|
||||
# Use isinstance checks for common index types; this is
|
||||
# ~25-50% faster than isscalarlike. Scalar index
|
||||
# assignment for other types is handled below together
|
||||
# with fancy indexing.
|
||||
if ((isinstance(i, int) or isinstance(i, np.integer)) and
|
||||
(isinstance(j, int) or isinstance(j, np.integer))):
|
||||
x = self.dtype.type(x)
|
||||
if x.size > 1:
|
||||
# Triggered if input was an ndarray
|
||||
raise ValueError("Trying to assign a sequence to an item")
|
||||
_csparsetools.lil_insert(self.shape[0], self.shape[1],
|
||||
self.rows, self.data, i, j, x)
|
||||
return
|
||||
|
||||
# General indexing
|
||||
i, j = self._unpack_index(index)
|
||||
|
||||
# shortcut for common case of full matrix assign:
|
||||
if (isspmatrix(x) and isinstance(i, slice) and i == slice(None) and
|
||||
isinstance(j, slice) and j == slice(None)
|
||||
and x.shape == self.shape):
|
||||
x = lil_matrix(x, dtype=self.dtype)
|
||||
self.rows = x.rows
|
||||
self.data = x.data
|
||||
return
|
||||
|
||||
i, j = self._index_to_arrays(i, j)
|
||||
|
||||
if isspmatrix(x):
|
||||
x = x.toarray()
|
||||
|
||||
# Make x and i into the same shape
|
||||
x = np.asarray(x, dtype=self.dtype)
|
||||
x, _ = np.broadcast_arrays(x, i)
|
||||
|
||||
if x.shape != i.shape:
|
||||
raise ValueError("shape mismatch in assignment")
|
||||
|
||||
# Set values
|
||||
i, j, x = _prepare_index_for_memoryview(i, j, x)
|
||||
_csparsetools.lil_fancy_set(self.shape[0], self.shape[1],
|
||||
self.rows, self.data,
|
||||
i, j, x)
|
||||
|
||||
def _mul_scalar(self, other):
|
||||
if other == 0:
|
||||
# Multiply by zero: return the zero matrix
|
||||
new = lil_matrix(self.shape, dtype=self.dtype)
|
||||
else:
|
||||
res_dtype = upcast_scalar(self.dtype, other)
|
||||
|
||||
new = self.copy()
|
||||
new = new.astype(res_dtype)
|
||||
# Multiply this scalar by every element.
|
||||
for j, rowvals in enumerate(new.data):
|
||||
new.data[j] = [val*other for val in rowvals]
|
||||
return new
|
||||
|
||||
def __truediv__(self, other): # self / other
|
||||
if isscalarlike(other):
|
||||
new = self.copy()
|
||||
# Divide every element by this scalar
|
||||
for j, rowvals in enumerate(new.data):
|
||||
new.data[j] = [val/other for val in rowvals]
|
||||
return new
|
||||
else:
|
||||
return self.tocsr() / other
|
||||
|
||||
def copy(self):
|
||||
from copy import deepcopy
|
||||
new = lil_matrix(self.shape, dtype=self.dtype)
|
||||
new.data = deepcopy(self.data)
|
||||
new.rows = deepcopy(self.rows)
|
||||
return new
|
||||
|
||||
copy.__doc__ = spmatrix.copy.__doc__
|
||||
|
||||
def reshape(self, *args, **kwargs):
|
||||
shape = check_shape(args, self.shape)
|
||||
order, copy = check_reshape_kwargs(kwargs)
|
||||
|
||||
# Return early if reshape is not required
|
||||
if shape == self.shape:
|
||||
if copy:
|
||||
return self.copy()
|
||||
else:
|
||||
return self
|
||||
|
||||
new = lil_matrix(shape, dtype=self.dtype)
|
||||
|
||||
if order == 'C':
|
||||
ncols = self.shape[1]
|
||||
for i, row in enumerate(self.rows):
|
||||
for col, j in enumerate(row):
|
||||
new_r, new_c = np.unravel_index(i * ncols + j, shape)
|
||||
new[new_r, new_c] = self[i, j]
|
||||
elif order == 'F':
|
||||
nrows = self.shape[0]
|
||||
for i, row in enumerate(self.rows):
|
||||
for col, j in enumerate(row):
|
||||
new_r, new_c = np.unravel_index(i + j * nrows, shape, order)
|
||||
new[new_r, new_c] = self[i, j]
|
||||
else:
|
||||
raise ValueError("'order' must be 'C' or 'F'")
|
||||
|
||||
return new
|
||||
|
||||
reshape.__doc__ = spmatrix.reshape.__doc__
|
||||
|
||||
def resize(self, *shape):
|
||||
shape = check_shape(shape)
|
||||
new_M, new_N = shape
|
||||
M, N = self.shape
|
||||
|
||||
if new_M < M:
|
||||
self.rows = self.rows[:new_M]
|
||||
self.data = self.data[:new_M]
|
||||
elif new_M > M:
|
||||
self.rows = np.resize(self.rows, new_M)
|
||||
self.data = np.resize(self.data, new_M)
|
||||
for i in range(M, new_M):
|
||||
self.rows[i] = []
|
||||
self.data[i] = []
|
||||
|
||||
if new_N < N:
|
||||
for row, data in zip(self.rows, self.data):
|
||||
trunc = bisect_left(row, new_N)
|
||||
del row[trunc:]
|
||||
del data[trunc:]
|
||||
|
||||
self._shape = shape
|
||||
|
||||
resize.__doc__ = spmatrix.resize.__doc__
|
||||
|
||||
def toarray(self, order=None, out=None):
|
||||
d = self._process_toarray_args(order, out)
|
||||
for i, row in enumerate(self.rows):
|
||||
for pos, j in enumerate(row):
|
||||
d[i, j] = self.data[i][pos]
|
||||
return d
|
||||
|
||||
toarray.__doc__ = spmatrix.toarray.__doc__
|
||||
|
||||
def transpose(self, axes=None, copy=False):
|
||||
return self.tocsr(copy=copy).transpose(axes=axes, copy=False).tolil(copy=False)
|
||||
|
||||
transpose.__doc__ = spmatrix.transpose.__doc__
|
||||
|
||||
def tolil(self, copy=False):
|
||||
if copy:
|
||||
return self.copy()
|
||||
else:
|
||||
return self
|
||||
|
||||
tolil.__doc__ = spmatrix.tolil.__doc__
|
||||
|
||||
def tocsr(self, copy=False):
|
||||
lst = [len(x) for x in self.rows]
|
||||
idx_dtype = get_index_dtype(maxval=max(self.shape[1], sum(lst)))
|
||||
|
||||
indptr = np.cumsum([0] + lst, dtype=idx_dtype)
|
||||
indices = np.array([x for y in self.rows for x in y], dtype=idx_dtype)
|
||||
data = np.array([x for y in self.data for x in y], dtype=self.dtype)
|
||||
|
||||
from .csr import csr_matrix
|
||||
return csr_matrix((data, indices, indptr), shape=self.shape)
|
||||
|
||||
tocsr.__doc__ = spmatrix.tocsr.__doc__
|
||||
|
||||
|
||||
def _prepare_index_for_memoryview(i, j, x=None):
|
||||
"""
|
||||
Convert index and data arrays to form suitable for passing to the
|
||||
Cython fancy getset routines.
|
||||
|
||||
The conversions are necessary since to (i) ensure the integer
|
||||
index arrays are in one of the accepted types, and (ii) to ensure
|
||||
the arrays are writable so that Cython memoryview support doesn't
|
||||
choke on them.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
i, j
|
||||
Index arrays
|
||||
x : optional
|
||||
Data arrays
|
||||
|
||||
Returns
|
||||
-------
|
||||
i, j, x
|
||||
Re-formatted arrays (x is omitted, if input was None)
|
||||
|
||||
"""
|
||||
if i.dtype > j.dtype:
|
||||
j = j.astype(i.dtype)
|
||||
elif i.dtype < j.dtype:
|
||||
i = i.astype(j.dtype)
|
||||
|
||||
if not i.flags.writeable or i.dtype not in (np.int32, np.int64):
|
||||
i = i.astype(np.intp)
|
||||
if not j.flags.writeable or j.dtype not in (np.int32, np.int64):
|
||||
j = j.astype(np.intp)
|
||||
|
||||
if x is not None:
|
||||
if not x.flags.writeable:
|
||||
x = x.copy()
|
||||
return i, j, x
|
||||
else:
|
||||
return i, j
|
||||
|
||||
|
||||
def isspmatrix_lil(x):
|
||||
"""Is x of lil_matrix type?
|
||||
|
||||
Parameters
|
||||
----------
|
||||
x
|
||||
object to check for being a lil matrix
|
||||
|
||||
Returns
|
||||
-------
|
||||
bool
|
||||
True if x is a lil matrix, False otherwise
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> from scipy.sparse import lil_matrix, isspmatrix_lil
|
||||
>>> isspmatrix_lil(lil_matrix([[5]]))
|
||||
True
|
||||
|
||||
>>> from scipy.sparse import lil_matrix, csr_matrix, isspmatrix_lil
|
||||
>>> isspmatrix_lil(csr_matrix([[5]]))
|
||||
False
|
||||
"""
|
||||
return isinstance(x, lil_matrix)
|
||||
@@ -0,0 +1,127 @@
|
||||
"""
|
||||
==================================================
|
||||
Sparse linear algebra (:mod:`scipy.sparse.linalg`)
|
||||
==================================================
|
||||
|
||||
.. currentmodule:: scipy.sparse.linalg
|
||||
|
||||
Abstract linear operators
|
||||
-------------------------
|
||||
|
||||
.. autosummary::
|
||||
:toctree: generated/
|
||||
|
||||
LinearOperator -- abstract representation of a linear operator
|
||||
aslinearoperator -- convert an object to an abstract linear operator
|
||||
|
||||
Matrix Operations
|
||||
-----------------
|
||||
|
||||
.. autosummary::
|
||||
:toctree: generated/
|
||||
|
||||
inv -- compute the sparse matrix inverse
|
||||
expm -- compute the sparse matrix exponential
|
||||
expm_multiply -- compute the product of a matrix exponential and a matrix
|
||||
|
||||
Matrix norms
|
||||
------------
|
||||
|
||||
.. autosummary::
|
||||
:toctree: generated/
|
||||
|
||||
norm -- Norm of a sparse matrix
|
||||
onenormest -- Estimate the 1-norm of a sparse matrix
|
||||
|
||||
Solving linear problems
|
||||
-----------------------
|
||||
|
||||
Direct methods for linear equation systems:
|
||||
|
||||
.. autosummary::
|
||||
:toctree: generated/
|
||||
|
||||
spsolve -- Solve the sparse linear system Ax=b
|
||||
spsolve_triangular -- Solve the sparse linear system Ax=b for a triangular matrix
|
||||
factorized -- Pre-factorize matrix to a function solving a linear system
|
||||
MatrixRankWarning -- Warning on exactly singular matrices
|
||||
use_solver -- Select direct solver to use
|
||||
|
||||
Iterative methods for linear equation systems:
|
||||
|
||||
.. autosummary::
|
||||
:toctree: generated/
|
||||
|
||||
bicg -- Use BIConjugate Gradient iteration to solve A x = b
|
||||
bicgstab -- Use BIConjugate Gradient STABilized iteration to solve A x = b
|
||||
cg -- Use Conjugate Gradient iteration to solve A x = b
|
||||
cgs -- Use Conjugate Gradient Squared iteration to solve A x = b
|
||||
gmres -- Use Generalized Minimal RESidual iteration to solve A x = b
|
||||
lgmres -- Solve a matrix equation using the LGMRES algorithm
|
||||
minres -- Use MINimum RESidual iteration to solve Ax = b
|
||||
qmr -- Use Quasi-Minimal Residual iteration to solve A x = b
|
||||
gcrotmk -- Solve a matrix equation using the GCROT(m,k) algorithm
|
||||
|
||||
Iterative methods for least-squares problems:
|
||||
|
||||
.. autosummary::
|
||||
:toctree: generated/
|
||||
|
||||
lsqr -- Find the least-squares solution to a sparse linear equation system
|
||||
lsmr -- Find the least-squares solution to a sparse linear equation system
|
||||
|
||||
Matrix factorizations
|
||||
---------------------
|
||||
|
||||
Eigenvalue problems:
|
||||
|
||||
.. autosummary::
|
||||
:toctree: generated/
|
||||
|
||||
eigs -- Find k eigenvalues and eigenvectors of the square matrix A
|
||||
eigsh -- Find k eigenvalues and eigenvectors of a symmetric matrix
|
||||
lobpcg -- Solve symmetric partial eigenproblems with optional preconditioning
|
||||
|
||||
Singular values problems:
|
||||
|
||||
.. autosummary::
|
||||
:toctree: generated/
|
||||
|
||||
svds -- Compute k singular values/vectors for a sparse matrix
|
||||
|
||||
Complete or incomplete LU factorizations
|
||||
|
||||
.. autosummary::
|
||||
:toctree: generated/
|
||||
|
||||
splu -- Compute a LU decomposition for a sparse matrix
|
||||
spilu -- Compute an incomplete LU decomposition for a sparse matrix
|
||||
SuperLU -- Object representing an LU factorization
|
||||
|
||||
Exceptions
|
||||
----------
|
||||
|
||||
.. autosummary::
|
||||
:toctree: generated/
|
||||
|
||||
ArpackNoConvergence
|
||||
ArpackError
|
||||
|
||||
"""
|
||||
|
||||
from __future__ import division, print_function, absolute_import
|
||||
|
||||
from .isolve import *
|
||||
from .dsolve import *
|
||||
from .interface import *
|
||||
from .eigen import *
|
||||
from .matfuncs import *
|
||||
from ._onenormest import *
|
||||
from ._norm import *
|
||||
from ._expm_multiply import *
|
||||
|
||||
__all__ = [s for s in dir() if not s.startswith('_')]
|
||||
|
||||
from scipy._lib._testutils import PytestTester
|
||||
test = PytestTester(__name__)
|
||||
del PytestTester
|
||||
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
@@ -0,0 +1,703 @@
|
||||
"""Compute the action of the matrix exponential.
|
||||
"""
|
||||
|
||||
from __future__ import division, print_function, absolute_import
|
||||
|
||||
import numpy as np
|
||||
|
||||
import scipy.linalg
|
||||
import scipy.sparse.linalg
|
||||
from scipy.sparse.linalg import aslinearoperator
|
||||
|
||||
__all__ = ['expm_multiply']
|
||||
|
||||
|
||||
def _exact_inf_norm(A):
|
||||
# A compatibility function which should eventually disappear.
|
||||
if scipy.sparse.isspmatrix(A):
|
||||
return max(abs(A).sum(axis=1).flat)
|
||||
else:
|
||||
return np.linalg.norm(A, np.inf)
|
||||
|
||||
|
||||
def _exact_1_norm(A):
|
||||
# A compatibility function which should eventually disappear.
|
||||
if scipy.sparse.isspmatrix(A):
|
||||
return max(abs(A).sum(axis=0).flat)
|
||||
else:
|
||||
return np.linalg.norm(A, 1)
|
||||
|
||||
|
||||
def _trace(A):
|
||||
# A compatibility function which should eventually disappear.
|
||||
if scipy.sparse.isspmatrix(A):
|
||||
return A.diagonal().sum()
|
||||
else:
|
||||
return np.trace(A)
|
||||
|
||||
|
||||
def _ident_like(A):
|
||||
# A compatibility function which should eventually disappear.
|
||||
if scipy.sparse.isspmatrix(A):
|
||||
return scipy.sparse.construct.eye(A.shape[0], A.shape[1],
|
||||
dtype=A.dtype, format=A.format)
|
||||
else:
|
||||
return np.eye(A.shape[0], A.shape[1], dtype=A.dtype)
|
||||
|
||||
|
||||
def expm_multiply(A, B, start=None, stop=None, num=None, endpoint=None):
|
||||
"""
|
||||
Compute the action of the matrix exponential of A on B.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
A : transposable linear operator
|
||||
The operator whose exponential is of interest.
|
||||
B : ndarray
|
||||
The matrix or vector to be multiplied by the matrix exponential of A.
|
||||
start : scalar, optional
|
||||
The starting time point of the sequence.
|
||||
stop : scalar, optional
|
||||
The end time point of the sequence, unless `endpoint` is set to False.
|
||||
In that case, the sequence consists of all but the last of ``num + 1``
|
||||
evenly spaced time points, so that `stop` is excluded.
|
||||
Note that the step size changes when `endpoint` is False.
|
||||
num : int, optional
|
||||
Number of time points to use.
|
||||
endpoint : bool, optional
|
||||
If True, `stop` is the last time point. Otherwise, it is not included.
|
||||
|
||||
Returns
|
||||
-------
|
||||
expm_A_B : ndarray
|
||||
The result of the action :math:`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`.
|
||||
|
||||
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.
|
||||
It would be 3 if you want the action on a matrix with multiple
|
||||
columns at multiple time points.
|
||||
If multiple time points are requested, expm_A_B[0] will always
|
||||
be the action of the expm at the first time point,
|
||||
regardless of whether the action is on a vector or a matrix.
|
||||
|
||||
References
|
||||
----------
|
||||
.. [1] Awad H. Al-Mohy and Nicholas J. Higham (2011)
|
||||
"Computing the Action of the Matrix Exponential,
|
||||
with an Application to Exponential Integrators."
|
||||
SIAM Journal on Scientific Computing,
|
||||
33 (2). pp. 488-511. ISSN 1064-8275
|
||||
http://eprints.ma.man.ac.uk/1591/
|
||||
|
||||
.. [2] Nicholas J. Higham and Awad H. Al-Mohy (2010)
|
||||
"Computing Matrix Functions."
|
||||
Acta Numerica,
|
||||
19. 159-208. ISSN 0962-4929
|
||||
http://eprints.ma.man.ac.uk/1451/
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> from scipy.sparse import csc_matrix
|
||||
>>> from scipy.sparse.linalg import expm, expm_multiply
|
||||
>>> A = csc_matrix([[1, 0], [0, 1]])
|
||||
>>> A.todense()
|
||||
matrix([[1, 0],
|
||||
[0, 1]], dtype=int64)
|
||||
>>> B = np.array([np.exp(-1.), np.exp(-2.)])
|
||||
>>> B
|
||||
array([ 0.36787944, 0.13533528])
|
||||
>>> expm_multiply(A, B, start=1, stop=2, num=3, endpoint=True)
|
||||
array([[ 1. , 0.36787944],
|
||||
[ 1.64872127, 0.60653066],
|
||||
[ 2.71828183, 1. ]])
|
||||
>>> expm(A).dot(B) # Verify 1st timestep
|
||||
array([ 1. , 0.36787944])
|
||||
>>> expm(1.5*A).dot(B) # Verify 2nd timestep
|
||||
array([ 1.64872127, 0.60653066])
|
||||
>>> expm(2*A).dot(B) # Verify 3rd timestep
|
||||
array([ 2.71828183, 1. ])
|
||||
"""
|
||||
if all(arg is None for arg in (start, stop, num, endpoint)):
|
||||
X = _expm_multiply_simple(A, B)
|
||||
else:
|
||||
X, status = _expm_multiply_interval(A, B, start, stop, num, endpoint)
|
||||
return X
|
||||
|
||||
|
||||
def _expm_multiply_simple(A, B, t=1.0, balance=False):
|
||||
"""
|
||||
Compute the action of the matrix exponential at a single time point.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
A : transposable linear operator
|
||||
The operator whose exponential is of interest.
|
||||
B : ndarray
|
||||
The matrix to be multiplied by the matrix exponential of A.
|
||||
t : float
|
||||
A time point.
|
||||
balance : bool
|
||||
Indicates whether or not to apply balancing.
|
||||
|
||||
Returns
|
||||
-------
|
||||
F : ndarray
|
||||
:math:`e^{t A} B`
|
||||
|
||||
Notes
|
||||
-----
|
||||
This is algorithm (3.2) in Al-Mohy and Higham (2011).
|
||||
|
||||
"""
|
||||
if balance:
|
||||
raise NotImplementedError
|
||||
if len(A.shape) != 2 or A.shape[0] != A.shape[1]:
|
||||
raise ValueError('expected A to be like a square matrix')
|
||||
if A.shape[1] != B.shape[0]:
|
||||
raise ValueError('the matrices A and B have incompatible shapes')
|
||||
ident = _ident_like(A)
|
||||
n = A.shape[0]
|
||||
if len(B.shape) == 1:
|
||||
n0 = 1
|
||||
elif len(B.shape) == 2:
|
||||
n0 = B.shape[1]
|
||||
else:
|
||||
raise ValueError('expected B to be like a matrix or a vector')
|
||||
u_d = 2**-53
|
||||
tol = u_d
|
||||
mu = _trace(A) / float(n)
|
||||
A = A - mu * ident
|
||||
A_1_norm = _exact_1_norm(A)
|
||||
if t*A_1_norm == 0:
|
||||
m_star, s = 0, 1
|
||||
else:
|
||||
ell = 2
|
||||
norm_info = LazyOperatorNormInfo(t*A, A_1_norm=t*A_1_norm, ell=ell)
|
||||
m_star, s = _fragment_3_1(norm_info, n0, tol, ell=ell)
|
||||
return _expm_multiply_simple_core(A, B, t, mu, m_star, s, tol, balance)
|
||||
|
||||
|
||||
def _expm_multiply_simple_core(A, B, t, mu, m_star, s, tol=None, balance=False):
|
||||
"""
|
||||
A helper function.
|
||||
"""
|
||||
if balance:
|
||||
raise NotImplementedError
|
||||
if tol is None:
|
||||
u_d = 2 ** -53
|
||||
tol = u_d
|
||||
F = B
|
||||
eta = np.exp(t*mu / float(s))
|
||||
for i in range(s):
|
||||
c1 = _exact_inf_norm(B)
|
||||
for j in range(m_star):
|
||||
coeff = t / float(s*(j+1))
|
||||
B = coeff * A.dot(B)
|
||||
c2 = _exact_inf_norm(B)
|
||||
F = F + B
|
||||
if c1 + c2 <= tol * _exact_inf_norm(F):
|
||||
break
|
||||
c1 = c2
|
||||
F = eta * F
|
||||
B = F
|
||||
return F
|
||||
|
||||
|
||||
# This table helps to compute bounds.
|
||||
# They seem to have been difficult to calculate, involving symbolic
|
||||
# manipulation of equations, followed by numerical root finding.
|
||||
_theta = {
|
||||
# The first 30 values are from table A.3 of Computing Matrix Functions.
|
||||
1: 2.29e-16,
|
||||
2: 2.58e-8,
|
||||
3: 1.39e-5,
|
||||
4: 3.40e-4,
|
||||
5: 2.40e-3,
|
||||
6: 9.07e-3,
|
||||
7: 2.38e-2,
|
||||
8: 5.00e-2,
|
||||
9: 8.96e-2,
|
||||
10: 1.44e-1,
|
||||
# 11
|
||||
11: 2.14e-1,
|
||||
12: 3.00e-1,
|
||||
13: 4.00e-1,
|
||||
14: 5.14e-1,
|
||||
15: 6.41e-1,
|
||||
16: 7.81e-1,
|
||||
17: 9.31e-1,
|
||||
18: 1.09,
|
||||
19: 1.26,
|
||||
20: 1.44,
|
||||
# 21
|
||||
21: 1.62,
|
||||
22: 1.82,
|
||||
23: 2.01,
|
||||
24: 2.22,
|
||||
25: 2.43,
|
||||
26: 2.64,
|
||||
27: 2.86,
|
||||
28: 3.08,
|
||||
29: 3.31,
|
||||
30: 3.54,
|
||||
# The rest are from table 3.1 of
|
||||
# Computing the Action of the Matrix Exponential.
|
||||
35: 4.7,
|
||||
40: 6.0,
|
||||
45: 7.2,
|
||||
50: 8.5,
|
||||
55: 9.9,
|
||||
}
|
||||
|
||||
|
||||
def _onenormest_matrix_power(A, p,
|
||||
t=2, itmax=5, compute_v=False, compute_w=False):
|
||||
"""
|
||||
Efficiently estimate the 1-norm of A^p.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
A : ndarray
|
||||
Matrix whose 1-norm of a power is to be computed.
|
||||
p : int
|
||||
Non-negative integer power.
|
||||
t : int, optional
|
||||
A positive parameter controlling the tradeoff between
|
||||
accuracy versus time and memory usage.
|
||||
Larger values take longer and use more memory
|
||||
but give more accurate output.
|
||||
itmax : int, optional
|
||||
Use at most this many iterations.
|
||||
compute_v : bool, optional
|
||||
Request a norm-maximizing linear operator input vector if True.
|
||||
compute_w : bool, optional
|
||||
Request a norm-maximizing linear operator output vector if True.
|
||||
|
||||
Returns
|
||||
-------
|
||||
est : float
|
||||
An underestimate of the 1-norm of the sparse matrix.
|
||||
v : ndarray, optional
|
||||
The vector such that ||Av||_1 == est*||v||_1.
|
||||
It can be thought of as an input to the linear operator
|
||||
that gives an output with particularly large norm.
|
||||
w : ndarray, optional
|
||||
The vector Av which has relatively large 1-norm.
|
||||
It can be thought of as an output of the linear operator
|
||||
that is relatively large in norm compared to the input.
|
||||
|
||||
"""
|
||||
#XXX Eventually turn this into an API function in the _onenormest module,
|
||||
#XXX and remove its underscore,
|
||||
#XXX but wait until expm_multiply goes into scipy.
|
||||
return scipy.sparse.linalg.onenormest(aslinearoperator(A) ** p)
|
||||
|
||||
class LazyOperatorNormInfo:
|
||||
"""
|
||||
Information about an operator is lazily computed.
|
||||
|
||||
The information includes the exact 1-norm of the operator,
|
||||
in addition to estimates of 1-norms of powers of the operator.
|
||||
This uses the notation of Computing the Action (2011).
|
||||
This class is specialized enough to probably not be of general interest
|
||||
outside of this module.
|
||||
|
||||
"""
|
||||
def __init__(self, A, A_1_norm=None, ell=2, scale=1):
|
||||
"""
|
||||
Provide the operator and some norm-related information.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
A : linear operator
|
||||
The operator of interest.
|
||||
A_1_norm : float, optional
|
||||
The exact 1-norm of A.
|
||||
ell : int, optional
|
||||
A technical parameter controlling norm estimation quality.
|
||||
scale : int, optional
|
||||
If specified, return the norms of scale*A instead of A.
|
||||
|
||||
"""
|
||||
self._A = A
|
||||
self._A_1_norm = A_1_norm
|
||||
self._ell = ell
|
||||
self._d = {}
|
||||
self._scale = scale
|
||||
|
||||
def set_scale(self,scale):
|
||||
"""
|
||||
Set the scale parameter.
|
||||
"""
|
||||
self._scale = scale
|
||||
|
||||
def onenorm(self):
|
||||
"""
|
||||
Compute the exact 1-norm.
|
||||
"""
|
||||
if self._A_1_norm is None:
|
||||
self._A_1_norm = _exact_1_norm(self._A)
|
||||
return self._scale*self._A_1_norm
|
||||
|
||||
def d(self, p):
|
||||
"""
|
||||
Lazily estimate d_p(A) ~= || A^p ||^(1/p) where ||.|| is the 1-norm.
|
||||
"""
|
||||
if p not in self._d:
|
||||
est = _onenormest_matrix_power(self._A, p, self._ell)
|
||||
self._d[p] = est ** (1.0 / p)
|
||||
return self._scale*self._d[p]
|
||||
|
||||
def alpha(self, p):
|
||||
"""
|
||||
Lazily compute max(d(p), d(p+1)).
|
||||
"""
|
||||
return max(self.d(p), self.d(p+1))
|
||||
|
||||
def _compute_cost_div_m(m, p, norm_info):
|
||||
"""
|
||||
A helper function for computing bounds.
|
||||
|
||||
This is equation (3.10).
|
||||
It measures cost in terms of the number of required matrix products.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
m : int
|
||||
A valid key of _theta.
|
||||
p : int
|
||||
A matrix power.
|
||||
norm_info : LazyOperatorNormInfo
|
||||
Information about 1-norms of related operators.
|
||||
|
||||
Returns
|
||||
-------
|
||||
cost_div_m : int
|
||||
Required number of matrix products divided by m.
|
||||
|
||||
"""
|
||||
return int(np.ceil(norm_info.alpha(p) / _theta[m]))
|
||||
|
||||
|
||||
def _compute_p_max(m_max):
|
||||
"""
|
||||
Compute the largest positive integer p such that p*(p-1) <= m_max + 1.
|
||||
|
||||
Do this in a slightly dumb way, but safe and not too slow.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
m_max : int
|
||||
A count related to bounds.
|
||||
|
||||
"""
|
||||
sqrt_m_max = np.sqrt(m_max)
|
||||
p_low = int(np.floor(sqrt_m_max))
|
||||
p_high = int(np.ceil(sqrt_m_max + 1))
|
||||
return max(p for p in range(p_low, p_high+1) if p*(p-1) <= m_max + 1)
|
||||
|
||||
|
||||
def _fragment_3_1(norm_info, n0, tol, m_max=55, ell=2):
|
||||
"""
|
||||
A helper function for the _expm_multiply_* functions.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
norm_info : LazyOperatorNormInfo
|
||||
Information about norms of certain linear operators of interest.
|
||||
n0 : int
|
||||
Number of columns in the _expm_multiply_* B matrix.
|
||||
tol : float
|
||||
Expected to be
|
||||
:math:`2^{-24}` for single precision or
|
||||
:math:`2^{-53}` for double precision.
|
||||
m_max : int
|
||||
A value related to a bound.
|
||||
ell : int
|
||||
The number of columns used in the 1-norm approximation.
|
||||
This is usually taken to be small, maybe between 1 and 5.
|
||||
|
||||
Returns
|
||||
-------
|
||||
best_m : int
|
||||
Related to bounds for error control.
|
||||
best_s : int
|
||||
Amount of scaling.
|
||||
|
||||
Notes
|
||||
-----
|
||||
This is code fragment (3.1) in Al-Mohy and Higham (2011).
|
||||
The discussion of default values for m_max and ell
|
||||
is given between the definitions of equation (3.11)
|
||||
and the definition of equation (3.12).
|
||||
|
||||
"""
|
||||
if ell < 1:
|
||||
raise ValueError('expected ell to be a positive integer')
|
||||
best_m = None
|
||||
best_s = None
|
||||
if _condition_3_13(norm_info.onenorm(), n0, m_max, ell):
|
||||
for m, theta in _theta.items():
|
||||
s = int(np.ceil(norm_info.onenorm() / theta))
|
||||
if best_m is None or m * s < best_m * best_s:
|
||||
best_m = m
|
||||
best_s = s
|
||||
else:
|
||||
# Equation (3.11).
|
||||
for p in range(2, _compute_p_max(m_max) + 1):
|
||||
for m in range(p*(p-1)-1, m_max+1):
|
||||
if m in _theta:
|
||||
s = _compute_cost_div_m(m, p, norm_info)
|
||||
if best_m is None or m * s < best_m * best_s:
|
||||
best_m = m
|
||||
best_s = s
|
||||
best_s = max(best_s, 1)
|
||||
return best_m, best_s
|
||||
|
||||
|
||||
def _condition_3_13(A_1_norm, n0, m_max, ell):
|
||||
"""
|
||||
A helper function for the _expm_multiply_* functions.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
A_1_norm : float
|
||||
The precomputed 1-norm of A.
|
||||
n0 : int
|
||||
Number of columns in the _expm_multiply_* B matrix.
|
||||
m_max : int
|
||||
A value related to a bound.
|
||||
ell : int
|
||||
The number of columns used in the 1-norm approximation.
|
||||
This is usually taken to be small, maybe between 1 and 5.
|
||||
|
||||
Returns
|
||||
-------
|
||||
value : bool
|
||||
Indicates whether or not the condition has been met.
|
||||
|
||||
Notes
|
||||
-----
|
||||
This is condition (3.13) in Al-Mohy and Higham (2011).
|
||||
|
||||
"""
|
||||
|
||||
# This is the rhs of equation (3.12).
|
||||
p_max = _compute_p_max(m_max)
|
||||
a = 2 * ell * p_max * (p_max + 3)
|
||||
|
||||
# Evaluate the condition (3.13).
|
||||
b = _theta[m_max] / float(n0 * m_max)
|
||||
return A_1_norm <= a * b
|
||||
|
||||
|
||||
def _expm_multiply_interval(A, B, start=None, stop=None,
|
||||
num=None, endpoint=None, balance=False, status_only=False):
|
||||
"""
|
||||
Compute the action of the matrix exponential at multiple time points.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
A : transposable linear operator
|
||||
The operator whose exponential is of interest.
|
||||
B : ndarray
|
||||
The matrix to be multiplied by the matrix exponential of A.
|
||||
start : scalar, optional
|
||||
The starting time point of the sequence.
|
||||
stop : scalar, optional
|
||||
The end time point of the sequence, unless `endpoint` is set to False.
|
||||
In that case, the sequence consists of all but the last of ``num + 1``
|
||||
evenly spaced time points, so that `stop` is excluded.
|
||||
Note that the step size changes when `endpoint` is False.
|
||||
num : int, optional
|
||||
Number of time points to use.
|
||||
endpoint : bool, optional
|
||||
If True, `stop` is the last time point. Otherwise, it is not included.
|
||||
balance : bool
|
||||
Indicates whether or not to apply balancing.
|
||||
status_only : bool
|
||||
A flag that is set to True for some debugging and testing operations.
|
||||
|
||||
Returns
|
||||
-------
|
||||
F : ndarray
|
||||
:math:`e^{t_k A} B`
|
||||
status : int
|
||||
An integer status for testing and debugging.
|
||||
|
||||
Notes
|
||||
-----
|
||||
This is algorithm (5.2) in Al-Mohy and Higham (2011).
|
||||
|
||||
There seems to be a typo, where line 15 of the algorithm should be
|
||||
moved to line 6.5 (between lines 6 and 7).
|
||||
|
||||
"""
|
||||
if balance:
|
||||
raise NotImplementedError
|
||||
if len(A.shape) != 2 or A.shape[0] != A.shape[1]:
|
||||
raise ValueError('expected A to be like a square matrix')
|
||||
if A.shape[1] != B.shape[0]:
|
||||
raise ValueError('the matrices A and B have incompatible shapes')
|
||||
ident = _ident_like(A)
|
||||
n = A.shape[0]
|
||||
if len(B.shape) == 1:
|
||||
n0 = 1
|
||||
elif len(B.shape) == 2:
|
||||
n0 = B.shape[1]
|
||||
else:
|
||||
raise ValueError('expected B to be like a matrix or a vector')
|
||||
u_d = 2**-53
|
||||
tol = u_d
|
||||
mu = _trace(A) / float(n)
|
||||
|
||||
# Get the linspace samples, attempting to preserve the linspace defaults.
|
||||
linspace_kwargs = {'retstep': True}
|
||||
if num is not None:
|
||||
linspace_kwargs['num'] = num
|
||||
if endpoint is not None:
|
||||
linspace_kwargs['endpoint'] = endpoint
|
||||
samples, step = np.linspace(start, stop, **linspace_kwargs)
|
||||
|
||||
# Convert the linspace output to the notation used by the publication.
|
||||
nsamples = len(samples)
|
||||
if nsamples < 2:
|
||||
raise ValueError('at least two time points are required')
|
||||
q = nsamples - 1
|
||||
h = step
|
||||
t_0 = samples[0]
|
||||
t_q = samples[q]
|
||||
|
||||
# Define the output ndarray.
|
||||
# Use an ndim=3 shape, such that the last two indices
|
||||
# are the ones that may be involved in level 3 BLAS operations.
|
||||
X_shape = (nsamples,) + B.shape
|
||||
X = np.empty(X_shape, dtype=np.result_type(A.dtype, B.dtype, float))
|
||||
t = t_q - t_0
|
||||
A = A - mu * ident
|
||||
A_1_norm = _exact_1_norm(A)
|
||||
ell = 2
|
||||
norm_info = LazyOperatorNormInfo(t*A, A_1_norm=t*A_1_norm, ell=ell)
|
||||
if t*A_1_norm == 0:
|
||||
m_star, s = 0, 1
|
||||
else:
|
||||
m_star, s = _fragment_3_1(norm_info, n0, tol, ell=ell)
|
||||
|
||||
# Compute the expm action up to the initial time point.
|
||||
X[0] = _expm_multiply_simple_core(A, B, t_0, mu, m_star, s)
|
||||
|
||||
# Compute the expm action at the rest of the time points.
|
||||
if q <= s:
|
||||
if status_only:
|
||||
return 0
|
||||
else:
|
||||
return _expm_multiply_interval_core_0(A, X,
|
||||
h, mu, q, norm_info, tol, ell,n0)
|
||||
elif not (q % s):
|
||||
if status_only:
|
||||
return 1
|
||||
else:
|
||||
return _expm_multiply_interval_core_1(A, X,
|
||||
h, mu, m_star, s, q, tol)
|
||||
elif (q % s):
|
||||
if status_only:
|
||||
return 2
|
||||
else:
|
||||
return _expm_multiply_interval_core_2(A, X,
|
||||
h, mu, m_star, s, q, tol)
|
||||
else:
|
||||
raise Exception('internal error')
|
||||
|
||||
|
||||
def _expm_multiply_interval_core_0(A, X, h, mu, q, norm_info, tol, ell, n0):
|
||||
"""
|
||||
A helper function, for the case q <= s.
|
||||
"""
|
||||
|
||||
# Compute the new values of m_star and s which should be applied
|
||||
# over intervals of size t/q
|
||||
if norm_info.onenorm() == 0:
|
||||
m_star, s = 0, 1
|
||||
else:
|
||||
norm_info.set_scale(1./q)
|
||||
m_star, s = _fragment_3_1(norm_info, n0, tol, ell=ell)
|
||||
norm_info.set_scale(1)
|
||||
|
||||
for k in range(q):
|
||||
X[k+1] = _expm_multiply_simple_core(A, X[k], h, mu, m_star, s)
|
||||
return X, 0
|
||||
|
||||
|
||||
def _expm_multiply_interval_core_1(A, X, h, mu, m_star, s, q, tol):
|
||||
"""
|
||||
A helper function, for the case q > s and q % s == 0.
|
||||
"""
|
||||
d = q // s
|
||||
input_shape = X.shape[1:]
|
||||
K_shape = (m_star + 1, ) + input_shape
|
||||
K = np.empty(K_shape, dtype=X.dtype)
|
||||
for i in range(s):
|
||||
Z = X[i*d]
|
||||
K[0] = Z
|
||||
high_p = 0
|
||||
for k in range(1, d+1):
|
||||
F = K[0]
|
||||
c1 = _exact_inf_norm(F)
|
||||
for p in range(1, m_star+1):
|
||||
if p > high_p:
|
||||
K[p] = h * A.dot(K[p-1]) / float(p)
|
||||
coeff = float(pow(k, p))
|
||||
F = F + coeff * K[p]
|
||||
inf_norm_K_p_1 = _exact_inf_norm(K[p])
|
||||
c2 = coeff * inf_norm_K_p_1
|
||||
if c1 + c2 <= tol * _exact_inf_norm(F):
|
||||
break
|
||||
c1 = c2
|
||||
X[k + i*d] = np.exp(k*h*mu) * F
|
||||
return X, 1
|
||||
|
||||
|
||||
def _expm_multiply_interval_core_2(A, X, h, mu, m_star, s, q, tol):
|
||||
"""
|
||||
A helper function, for the case q > s and q % s > 0.
|
||||
"""
|
||||
d = q // s
|
||||
j = q // d
|
||||
r = q - d * j
|
||||
input_shape = X.shape[1:]
|
||||
K_shape = (m_star + 1, ) + input_shape
|
||||
K = np.empty(K_shape, dtype=X.dtype)
|
||||
for i in range(j + 1):
|
||||
Z = X[i*d]
|
||||
K[0] = Z
|
||||
high_p = 0
|
||||
if i < j:
|
||||
effective_d = d
|
||||
else:
|
||||
effective_d = r
|
||||
for k in range(1, effective_d+1):
|
||||
F = K[0]
|
||||
c1 = _exact_inf_norm(F)
|
||||
for p in range(1, m_star+1):
|
||||
if p == high_p + 1:
|
||||
K[p] = h * A.dot(K[p-1]) / float(p)
|
||||
high_p = p
|
||||
coeff = float(pow(k, p))
|
||||
F = F + coeff * K[p]
|
||||
inf_norm_K_p_1 = _exact_inf_norm(K[p])
|
||||
c2 = coeff * inf_norm_K_p_1
|
||||
if c1 + c2 <= tol * _exact_inf_norm(F):
|
||||
break
|
||||
c1 = c2
|
||||
X[k + i*d] = np.exp(k*h*mu) * F
|
||||
return X, 2
|
||||
@@ -0,0 +1,184 @@
|
||||
"""Sparse matrix norms.
|
||||
|
||||
"""
|
||||
from __future__ import division, print_function, absolute_import
|
||||
|
||||
import numpy as np
|
||||
from scipy.sparse import issparse
|
||||
|
||||
from numpy.core import Inf, sqrt, abs
|
||||
|
||||
__all__ = ['norm']
|
||||
|
||||
|
||||
def _sparse_frobenius_norm(x):
|
||||
if np.issubdtype(x.dtype, np.complexfloating):
|
||||
sqnorm = abs(x).power(2).sum()
|
||||
else:
|
||||
sqnorm = x.power(2).sum()
|
||||
return sqrt(sqnorm)
|
||||
|
||||
|
||||
def norm(x, ord=None, axis=None):
|
||||
"""
|
||||
Norm of a sparse matrix
|
||||
|
||||
This function is able to return one of seven different matrix norms,
|
||||
depending on the value of the ``ord`` parameter.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
x : a sparse matrix
|
||||
Input sparse matrix.
|
||||
ord : {non-zero int, inf, -inf, 'fro'}, optional
|
||||
Order of the norm (see table under ``Notes``). inf means numpy's
|
||||
`inf` object.
|
||||
axis : {int, 2-tuple of ints, None}, optional
|
||||
If `axis` is an integer, it specifies the axis of `x` along which to
|
||||
compute the vector norms. If `axis` is a 2-tuple, it specifies the
|
||||
axes that hold 2-D matrices, and the matrix norms of these matrices
|
||||
are computed. If `axis` is None then either a vector norm (when `x`
|
||||
is 1-D) or a matrix norm (when `x` is 2-D) is returned.
|
||||
|
||||
Returns
|
||||
-------
|
||||
n : float or ndarray
|
||||
|
||||
Notes
|
||||
-----
|
||||
Some of the ord are not implemented because some associated functions like,
|
||||
_multi_svd_norm, are not yet available for sparse matrix.
|
||||
|
||||
This docstring is modified based on numpy.linalg.norm.
|
||||
https://github.com/numpy/numpy/blob/master/numpy/linalg/linalg.py
|
||||
|
||||
The following norms can be calculated:
|
||||
|
||||
===== ============================
|
||||
ord norm for sparse matrices
|
||||
===== ============================
|
||||
None Frobenius norm
|
||||
'fro' Frobenius norm
|
||||
inf max(sum(abs(x), axis=1))
|
||||
-inf min(sum(abs(x), axis=1))
|
||||
0 abs(x).sum(axis=axis)
|
||||
1 max(sum(abs(x), axis=0))
|
||||
-1 min(sum(abs(x), axis=0))
|
||||
2 Not implemented
|
||||
-2 Not implemented
|
||||
other Not implemented
|
||||
===== ============================
|
||||
|
||||
The Frobenius norm is given by [1]_:
|
||||
|
||||
:math:`||A||_F = [\\sum_{i,j} abs(a_{i,j})^2]^{1/2}`
|
||||
|
||||
References
|
||||
----------
|
||||
.. [1] G. H. Golub and C. F. Van Loan, *Matrix Computations*,
|
||||
Baltimore, MD, Johns Hopkins University Press, 1985, pg. 15
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> from scipy.sparse import *
|
||||
>>> import numpy as np
|
||||
>>> from scipy.sparse.linalg import norm
|
||||
>>> a = np.arange(9) - 4
|
||||
>>> a
|
||||
array([-4, -3, -2, -1, 0, 1, 2, 3, 4])
|
||||
>>> b = a.reshape((3, 3))
|
||||
>>> b
|
||||
array([[-4, -3, -2],
|
||||
[-1, 0, 1],
|
||||
[ 2, 3, 4]])
|
||||
|
||||
>>> b = csr_matrix(b)
|
||||
>>> norm(b)
|
||||
7.745966692414834
|
||||
>>> norm(b, 'fro')
|
||||
7.745966692414834
|
||||
>>> norm(b, np.inf)
|
||||
9
|
||||
>>> norm(b, -np.inf)
|
||||
2
|
||||
>>> norm(b, 1)
|
||||
7
|
||||
>>> norm(b, -1)
|
||||
6
|
||||
|
||||
"""
|
||||
if not issparse(x):
|
||||
raise TypeError("input is not sparse. use numpy.linalg.norm")
|
||||
|
||||
# Check the default case first and handle it immediately.
|
||||
if axis is None and ord in (None, 'fro', 'f'):
|
||||
return _sparse_frobenius_norm(x)
|
||||
|
||||
# Some norms require functions that are not implemented for all types.
|
||||
x = x.tocsr()
|
||||
|
||||
if axis is None:
|
||||
axis = (0, 1)
|
||||
elif not isinstance(axis, tuple):
|
||||
msg = "'axis' must be None, an integer or a tuple of integers"
|
||||
try:
|
||||
int_axis = int(axis)
|
||||
except TypeError:
|
||||
raise TypeError(msg)
|
||||
if axis != int_axis:
|
||||
raise TypeError(msg)
|
||||
axis = (int_axis,)
|
||||
|
||||
nd = 2
|
||||
if len(axis) == 2:
|
||||
row_axis, col_axis = axis
|
||||
if not (-nd <= row_axis < nd and -nd <= col_axis < nd):
|
||||
raise ValueError('Invalid axis %r for an array with shape %r' %
|
||||
(axis, x.shape))
|
||||
if row_axis % nd == col_axis % nd:
|
||||
raise ValueError('Duplicate axes given.')
|
||||
if ord == 2:
|
||||
raise NotImplementedError
|
||||
#return _multi_svd_norm(x, row_axis, col_axis, amax)
|
||||
elif ord == -2:
|
||||
raise NotImplementedError
|
||||
#return _multi_svd_norm(x, row_axis, col_axis, amin)
|
||||
elif ord == 1:
|
||||
return abs(x).sum(axis=row_axis).max(axis=col_axis)[0,0]
|
||||
elif ord == Inf:
|
||||
return abs(x).sum(axis=col_axis).max(axis=row_axis)[0,0]
|
||||
elif ord == -1:
|
||||
return abs(x).sum(axis=row_axis).min(axis=col_axis)[0,0]
|
||||
elif ord == -Inf:
|
||||
return abs(x).sum(axis=col_axis).min(axis=row_axis)[0,0]
|
||||
elif ord in (None, 'f', 'fro'):
|
||||
# The axis order does not matter for this norm.
|
||||
return _sparse_frobenius_norm(x)
|
||||
else:
|
||||
raise ValueError("Invalid norm order for matrices.")
|
||||
elif len(axis) == 1:
|
||||
a, = axis
|
||||
if not (-nd <= a < nd):
|
||||
raise ValueError('Invalid axis %r for an array with shape %r' %
|
||||
(axis, x.shape))
|
||||
if ord == Inf:
|
||||
M = abs(x).max(axis=a)
|
||||
elif ord == -Inf:
|
||||
M = abs(x).min(axis=a)
|
||||
elif ord == 0:
|
||||
# Zero norm
|
||||
M = (x != 0).sum(axis=a)
|
||||
elif ord == 1:
|
||||
# special case for speedup
|
||||
M = abs(x).sum(axis=a)
|
||||
elif ord in (2, None):
|
||||
M = sqrt(abs(x).power(2).sum(axis=a))
|
||||
else:
|
||||
try:
|
||||
ord + 1
|
||||
except TypeError:
|
||||
raise ValueError('Invalid norm order for vectors.')
|
||||
M = np.power(abs(x).power(ord).sum(axis=a), 1 / ord)
|
||||
return M.A.ravel()
|
||||
else:
|
||||
raise ValueError("Improper number of dimensions to norm.")
|
||||
@@ -0,0 +1,468 @@
|
||||
"""Sparse block 1-norm estimator.
|
||||
"""
|
||||
|
||||
from __future__ import division, print_function, absolute_import
|
||||
|
||||
import numpy as np
|
||||
from scipy.sparse.linalg import aslinearoperator
|
||||
|
||||
|
||||
__all__ = ['onenormest']
|
||||
|
||||
|
||||
def onenormest(A, t=2, itmax=5, compute_v=False, compute_w=False):
|
||||
"""
|
||||
Compute a lower bound of the 1-norm of a sparse matrix.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
A : ndarray or other linear operator
|
||||
A linear operator that can be transposed and that can
|
||||
produce matrix products.
|
||||
t : int, optional
|
||||
A positive parameter controlling the tradeoff between
|
||||
accuracy versus time and memory usage.
|
||||
Larger values take longer and use more memory
|
||||
but give more accurate output.
|
||||
itmax : int, optional
|
||||
Use at most this many iterations.
|
||||
compute_v : bool, optional
|
||||
Request a norm-maximizing linear operator input vector if True.
|
||||
compute_w : bool, optional
|
||||
Request a norm-maximizing linear operator output vector if True.
|
||||
|
||||
Returns
|
||||
-------
|
||||
est : float
|
||||
An underestimate of the 1-norm of the sparse matrix.
|
||||
v : ndarray, optional
|
||||
The vector such that ||Av||_1 == est*||v||_1.
|
||||
It can be thought of as an input to the linear operator
|
||||
that gives an output with particularly large norm.
|
||||
w : ndarray, optional
|
||||
The vector Av which has relatively large 1-norm.
|
||||
It can be thought of as an output of the linear operator
|
||||
that is relatively large in norm compared to the input.
|
||||
|
||||
Notes
|
||||
-----
|
||||
This is algorithm 2.4 of [1].
|
||||
|
||||
In [2] it is described as follows.
|
||||
"This algorithm typically requires the evaluation of
|
||||
about 4t matrix-vector products and almost invariably
|
||||
produces a norm estimate (which is, in fact, a lower
|
||||
bound on the norm) correct to within a factor 3."
|
||||
|
||||
.. versionadded:: 0.13.0
|
||||
|
||||
References
|
||||
----------
|
||||
.. [1] Nicholas J. Higham and Francoise Tisseur (2000),
|
||||
"A Block Algorithm for Matrix 1-Norm Estimation,
|
||||
with an Application to 1-Norm Pseudospectra."
|
||||
SIAM J. Matrix Anal. Appl. Vol. 21, No. 4, pp. 1185-1201.
|
||||
|
||||
.. [2] Awad H. Al-Mohy and Nicholas J. Higham (2009),
|
||||
"A new scaling and squaring algorithm for the matrix exponential."
|
||||
SIAM J. Matrix Anal. Appl. Vol. 31, No. 3, pp. 970-989.
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> from scipy.sparse import csc_matrix
|
||||
>>> from scipy.sparse.linalg import onenormest
|
||||
>>> A = csc_matrix([[1., 0., 0.], [5., 8., 2.], [0., -1., 0.]], dtype=float)
|
||||
>>> A.todense()
|
||||
matrix([[ 1., 0., 0.],
|
||||
[ 5., 8., 2.],
|
||||
[ 0., -1., 0.]])
|
||||
>>> onenormest(A)
|
||||
9.0
|
||||
>>> np.linalg.norm(A.todense(), ord=1)
|
||||
9.0
|
||||
"""
|
||||
|
||||
# Check the input.
|
||||
A = aslinearoperator(A)
|
||||
if A.shape[0] != A.shape[1]:
|
||||
raise ValueError('expected the operator to act like a square matrix')
|
||||
|
||||
# If the operator size is small compared to t,
|
||||
# then it is easier to compute the exact norm.
|
||||
# Otherwise estimate the norm.
|
||||
n = A.shape[1]
|
||||
if t >= n:
|
||||
A_explicit = np.asarray(aslinearoperator(A).matmat(np.identity(n)))
|
||||
if A_explicit.shape != (n, n):
|
||||
raise Exception('internal error: ',
|
||||
'unexpected shape ' + str(A_explicit.shape))
|
||||
col_abs_sums = abs(A_explicit).sum(axis=0)
|
||||
if col_abs_sums.shape != (n, ):
|
||||
raise Exception('internal error: ',
|
||||
'unexpected shape ' + str(col_abs_sums.shape))
|
||||
argmax_j = np.argmax(col_abs_sums)
|
||||
v = elementary_vector(n, argmax_j)
|
||||
w = A_explicit[:, argmax_j]
|
||||
est = col_abs_sums[argmax_j]
|
||||
else:
|
||||
est, v, w, nmults, nresamples = _onenormest_core(A, A.H, t, itmax)
|
||||
|
||||
# Report the norm estimate along with some certificates of the estimate.
|
||||
if compute_v or compute_w:
|
||||
result = (est,)
|
||||
if compute_v:
|
||||
result += (v,)
|
||||
if compute_w:
|
||||
result += (w,)
|
||||
return result
|
||||
else:
|
||||
return est
|
||||
|
||||
|
||||
def _blocked_elementwise(func):
|
||||
"""
|
||||
Decorator for an elementwise function, to apply it blockwise along
|
||||
first dimension, to avoid excessive memory usage in temporaries.
|
||||
"""
|
||||
block_size = 2**20
|
||||
|
||||
def wrapper(x):
|
||||
if x.shape[0] < block_size:
|
||||
return func(x)
|
||||
else:
|
||||
y0 = func(x[:block_size])
|
||||
y = np.zeros((x.shape[0],) + y0.shape[1:], dtype=y0.dtype)
|
||||
y[:block_size] = y0
|
||||
del y0
|
||||
for j in range(block_size, x.shape[0], block_size):
|
||||
y[j:j+block_size] = func(x[j:j+block_size])
|
||||
return y
|
||||
return wrapper
|
||||
|
||||
|
||||
@_blocked_elementwise
|
||||
def sign_round_up(X):
|
||||
"""
|
||||
This should do the right thing for both real and complex matrices.
|
||||
|
||||
From Higham and Tisseur:
|
||||
"Everything in this section remains valid for complex matrices
|
||||
provided that sign(A) is redefined as the matrix (aij / |aij|)
|
||||
(and sign(0) = 1) transposes are replaced by conjugate transposes."
|
||||
|
||||
"""
|
||||
Y = X.copy()
|
||||
Y[Y == 0] = 1
|
||||
Y /= np.abs(Y)
|
||||
return Y
|
||||
|
||||
|
||||
@_blocked_elementwise
|
||||
def _max_abs_axis1(X):
|
||||
return np.max(np.abs(X), axis=1)
|
||||
|
||||
|
||||
def _sum_abs_axis0(X):
|
||||
block_size = 2**20
|
||||
r = None
|
||||
for j in range(0, X.shape[0], block_size):
|
||||
y = np.sum(np.abs(X[j:j+block_size]), axis=0)
|
||||
if r is None:
|
||||
r = y
|
||||
else:
|
||||
r += y
|
||||
return r
|
||||
|
||||
|
||||
def elementary_vector(n, i):
|
||||
v = np.zeros(n, dtype=float)
|
||||
v[i] = 1
|
||||
return v
|
||||
|
||||
|
||||
def vectors_are_parallel(v, w):
|
||||
# Columns are considered parallel when they are equal or negative.
|
||||
# Entries are required to be in {-1, 1},
|
||||
# which guarantees that the magnitudes of the vectors are identical.
|
||||
if v.ndim != 1 or v.shape != w.shape:
|
||||
raise ValueError('expected conformant vectors with entries in {-1,1}')
|
||||
n = v.shape[0]
|
||||
return np.dot(v, w) == n
|
||||
|
||||
|
||||
def every_col_of_X_is_parallel_to_a_col_of_Y(X, Y):
|
||||
for v in X.T:
|
||||
if not any(vectors_are_parallel(v, w) for w in Y.T):
|
||||
return False
|
||||
return True
|
||||
|
||||
|
||||
def column_needs_resampling(i, X, Y=None):
|
||||
# column i of X needs resampling if either
|
||||
# it is parallel to a previous column of X or
|
||||
# it is parallel to a column of Y
|
||||
n, t = X.shape
|
||||
v = X[:, i]
|
||||
if any(vectors_are_parallel(v, X[:, j]) for j in range(i)):
|
||||
return True
|
||||
if Y is not None:
|
||||
if any(vectors_are_parallel(v, w) for w in Y.T):
|
||||
return True
|
||||
return False
|
||||
|
||||
|
||||
def resample_column(i, X):
|
||||
X[:, i] = np.random.randint(0, 2, size=X.shape[0])*2 - 1
|
||||
|
||||
|
||||
def less_than_or_close(a, b):
|
||||
return np.allclose(a, b) or (a < b)
|
||||
|
||||
|
||||
def _algorithm_2_2(A, AT, t):
|
||||
"""
|
||||
This is Algorithm 2.2.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
A : ndarray or other linear operator
|
||||
A linear operator that can produce matrix products.
|
||||
AT : ndarray or other linear operator
|
||||
The transpose of A.
|
||||
t : int, optional
|
||||
A positive parameter controlling the tradeoff between
|
||||
accuracy versus time and memory usage.
|
||||
|
||||
Returns
|
||||
-------
|
||||
g : sequence
|
||||
A non-negative decreasing vector
|
||||
such that g[j] is a lower bound for the 1-norm
|
||||
of the column of A of jth largest 1-norm.
|
||||
The first entry of this vector is therefore a lower bound
|
||||
on the 1-norm of the linear operator A.
|
||||
This sequence has length t.
|
||||
ind : sequence
|
||||
The ith entry of ind is the index of the column A whose 1-norm
|
||||
is given by g[i].
|
||||
This sequence of indices has length t, and its entries are
|
||||
chosen from range(n), possibly with repetition,
|
||||
where n is the order of the operator A.
|
||||
|
||||
Notes
|
||||
-----
|
||||
This algorithm is mainly for testing.
|
||||
It uses the 'ind' array in a way that is similar to
|
||||
its usage in algorithm 2.4. This algorithm 2.2 may be easier to test,
|
||||
so it gives a chance of uncovering bugs related to indexing
|
||||
which could have propagated less noticeably to algorithm 2.4.
|
||||
|
||||
"""
|
||||
A_linear_operator = aslinearoperator(A)
|
||||
AT_linear_operator = aslinearoperator(AT)
|
||||
n = A_linear_operator.shape[0]
|
||||
|
||||
# Initialize the X block with columns of unit 1-norm.
|
||||
X = np.ones((n, t))
|
||||
if t > 1:
|
||||
X[:, 1:] = np.random.randint(0, 2, size=(n, t-1))*2 - 1
|
||||
X /= float(n)
|
||||
|
||||
# Iteratively improve the lower bounds.
|
||||
# Track extra things, to assert invariants for debugging.
|
||||
g_prev = None
|
||||
h_prev = None
|
||||
k = 1
|
||||
ind = range(t)
|
||||
while True:
|
||||
Y = np.asarray(A_linear_operator.matmat(X))
|
||||
g = _sum_abs_axis0(Y)
|
||||
best_j = np.argmax(g)
|
||||
g.sort()
|
||||
g = g[::-1]
|
||||
S = sign_round_up(Y)
|
||||
Z = np.asarray(AT_linear_operator.matmat(S))
|
||||
h = _max_abs_axis1(Z)
|
||||
|
||||
# If this algorithm runs for fewer than two iterations,
|
||||
# then its return values do not have the properties indicated
|
||||
# in the description of the algorithm.
|
||||
# In particular, the entries of g are not 1-norms of any
|
||||
# column of A until the second iteration.
|
||||
# Therefore we will require the algorithm to run for at least
|
||||
# two iterations, even though this requirement is not stated
|
||||
# in the description of the algorithm.
|
||||
if k >= 2:
|
||||
if less_than_or_close(max(h), np.dot(Z[:, best_j], X[:, best_j])):
|
||||
break
|
||||
ind = np.argsort(h)[::-1][:t]
|
||||
h = h[ind]
|
||||
for j in range(t):
|
||||
X[:, j] = elementary_vector(n, ind[j])
|
||||
|
||||
# Check invariant (2.2).
|
||||
if k >= 2:
|
||||
if not less_than_or_close(g_prev[0], h_prev[0]):
|
||||
raise Exception('invariant (2.2) is violated')
|
||||
if not less_than_or_close(h_prev[0], g[0]):
|
||||
raise Exception('invariant (2.2) is violated')
|
||||
|
||||
# Check invariant (2.3).
|
||||
if k >= 3:
|
||||
for j in range(t):
|
||||
if not less_than_or_close(g[j], g_prev[j]):
|
||||
raise Exception('invariant (2.3) is violated')
|
||||
|
||||
# Update for the next iteration.
|
||||
g_prev = g
|
||||
h_prev = h
|
||||
k += 1
|
||||
|
||||
# Return the lower bounds and the corresponding column indices.
|
||||
return g, ind
|
||||
|
||||
|
||||
def _onenormest_core(A, AT, t, itmax):
|
||||
"""
|
||||
Compute a lower bound of the 1-norm of a sparse matrix.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
A : ndarray or other linear operator
|
||||
A linear operator that can produce matrix products.
|
||||
AT : ndarray or other linear operator
|
||||
The transpose of A.
|
||||
t : int, optional
|
||||
A positive parameter controlling the tradeoff between
|
||||
accuracy versus time and memory usage.
|
||||
itmax : int, optional
|
||||
Use at most this many iterations.
|
||||
|
||||
Returns
|
||||
-------
|
||||
est : float
|
||||
An underestimate of the 1-norm of the sparse matrix.
|
||||
v : ndarray, optional
|
||||
The vector such that ||Av||_1 == est*||v||_1.
|
||||
It can be thought of as an input to the linear operator
|
||||
that gives an output with particularly large norm.
|
||||
w : ndarray, optional
|
||||
The vector Av which has relatively large 1-norm.
|
||||
It can be thought of as an output of the linear operator
|
||||
that is relatively large in norm compared to the input.
|
||||
nmults : int, optional
|
||||
The number of matrix products that were computed.
|
||||
nresamples : int, optional
|
||||
The number of times a parallel column was observed,
|
||||
necessitating a re-randomization of the column.
|
||||
|
||||
Notes
|
||||
-----
|
||||
This is algorithm 2.4.
|
||||
|
||||
"""
|
||||
# This function is a more or less direct translation
|
||||
# of Algorithm 2.4 from the Higham and Tisseur (2000) paper.
|
||||
A_linear_operator = aslinearoperator(A)
|
||||
AT_linear_operator = aslinearoperator(AT)
|
||||
if itmax < 2:
|
||||
raise ValueError('at least two iterations are required')
|
||||
if t < 1:
|
||||
raise ValueError('at least one column is required')
|
||||
n = A.shape[0]
|
||||
if t >= n:
|
||||
raise ValueError('t should be smaller than the order of A')
|
||||
# Track the number of big*small matrix multiplications
|
||||
# and the number of resamplings.
|
||||
nmults = 0
|
||||
nresamples = 0
|
||||
# "We now explain our choice of starting matrix. We take the first
|
||||
# column of X to be the vector of 1s [...] This has the advantage that
|
||||
# for a matrix with nonnegative elements the algorithm converges
|
||||
# with an exact estimate on the second iteration, and such matrices
|
||||
# arise in applications [...]"
|
||||
X = np.ones((n, t), dtype=float)
|
||||
# "The remaining columns are chosen as rand{-1,1},
|
||||
# with a check for and correction of parallel columns,
|
||||
# exactly as for S in the body of the algorithm."
|
||||
if t > 1:
|
||||
for i in range(1, t):
|
||||
# These are technically initial samples, not resamples,
|
||||
# so the resampling count is not incremented.
|
||||
resample_column(i, X)
|
||||
for i in range(t):
|
||||
while column_needs_resampling(i, X):
|
||||
resample_column(i, X)
|
||||
nresamples += 1
|
||||
# "Choose starting matrix X with columns of unit 1-norm."
|
||||
X /= float(n)
|
||||
# "indices of used unit vectors e_j"
|
||||
ind_hist = np.zeros(0, dtype=np.intp)
|
||||
est_old = 0
|
||||
S = np.zeros((n, t), dtype=float)
|
||||
k = 1
|
||||
ind = None
|
||||
while True:
|
||||
Y = np.asarray(A_linear_operator.matmat(X))
|
||||
nmults += 1
|
||||
mags = _sum_abs_axis0(Y)
|
||||
est = np.max(mags)
|
||||
best_j = np.argmax(mags)
|
||||
if est > est_old or k == 2:
|
||||
if k >= 2:
|
||||
ind_best = ind[best_j]
|
||||
w = Y[:, best_j]
|
||||
# (1)
|
||||
if k >= 2 and est <= est_old:
|
||||
est = est_old
|
||||
break
|
||||
est_old = est
|
||||
S_old = S
|
||||
if k > itmax:
|
||||
break
|
||||
S = sign_round_up(Y)
|
||||
del Y
|
||||
# (2)
|
||||
if every_col_of_X_is_parallel_to_a_col_of_Y(S, S_old):
|
||||
break
|
||||
if t > 1:
|
||||
# "Ensure that no column of S is parallel to another column of S
|
||||
# or to a column of S_old by replacing columns of S by rand{-1,1}."
|
||||
for i in range(t):
|
||||
while column_needs_resampling(i, S, S_old):
|
||||
resample_column(i, S)
|
||||
nresamples += 1
|
||||
del S_old
|
||||
# (3)
|
||||
Z = np.asarray(AT_linear_operator.matmat(S))
|
||||
nmults += 1
|
||||
h = _max_abs_axis1(Z)
|
||||
del Z
|
||||
# (4)
|
||||
if k >= 2 and max(h) == h[ind_best]:
|
||||
break
|
||||
# "Sort h so that h_first >= ... >= h_last
|
||||
# and re-order ind correspondingly."
|
||||
#
|
||||
# Later on, we will need at most t+len(ind_hist) largest
|
||||
# entries, so drop the rest
|
||||
ind = np.argsort(h)[::-1][:t+len(ind_hist)].copy()
|
||||
del h
|
||||
if t > 1:
|
||||
# (5)
|
||||
# Break if the most promising t vectors have been visited already.
|
||||
if np.in1d(ind[:t], ind_hist).all():
|
||||
break
|
||||
# Put the most promising unvisited vectors at the front of the list
|
||||
# and put the visited vectors at the end of the list.
|
||||
# Preserve the order of the indices induced by the ordering of h.
|
||||
seen = np.in1d(ind, ind_hist)
|
||||
ind = np.concatenate((ind[~seen], ind[seen]))
|
||||
for j in range(t):
|
||||
X[:, j] = elementary_vector(n, ind[j])
|
||||
|
||||
new_ind = ind[:t][~np.in1d(ind[:t], ind_hist)]
|
||||
ind_hist = np.concatenate((ind_hist, new_ind))
|
||||
k += 1
|
||||
v = elementary_vector(n, ind_best)
|
||||
return est, v, w, nmults, nresamples
|
||||
@@ -0,0 +1,29 @@
|
||||
Copyright (c) 2003, The Regents of the University of California, through
|
||||
Lawrence Berkeley National Laboratory (subject to receipt of any required
|
||||
approvals from U.S. Dept. of Energy)
|
||||
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
(1) Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions and the following disclaimer.
|
||||
(2) Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
(3) Neither the name of Lawrence Berkeley National Laboratory, U.S. Dept. of
|
||||
Energy nor the names of its contributors may be used to endorse or promote
|
||||
products derived from this software without specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
|
||||
IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
|
||||
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
||||
PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
|
||||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
||||
EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
||||
PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
|
||||
PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
|
||||
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
|
||||
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
@@ -0,0 +1,68 @@
|
||||
"""
|
||||
Linear Solvers
|
||||
==============
|
||||
|
||||
The default solver is SuperLU (included in the scipy distribution),
|
||||
which can solve real or complex linear systems in both single and
|
||||
double precisions. It is automatically replaced by UMFPACK, if
|
||||
available. Note that UMFPACK works in double precision only, so
|
||||
switch it off by::
|
||||
|
||||
>>> use_solver(useUmfpack=False)
|
||||
|
||||
to solve in the single precision. See also use_solver documentation.
|
||||
|
||||
Example session::
|
||||
|
||||
>>> from scipy.sparse import csc_matrix, spdiags
|
||||
>>> from numpy import array
|
||||
>>> from scipy.sparse.linalg import spsolve, use_solver
|
||||
>>>
|
||||
>>> print("Inverting a sparse linear system:")
|
||||
>>> print("The sparse matrix (constructed from diagonals):")
|
||||
>>> a = spdiags([[1, 2, 3, 4, 5], [6, 5, 8, 9, 10]], [0, 1], 5, 5)
|
||||
>>> b = array([1, 2, 3, 4, 5])
|
||||
>>> print("Solve: single precision complex:")
|
||||
>>> use_solver( useUmfpack = False )
|
||||
>>> a = a.astype('F')
|
||||
>>> x = spsolve(a, b)
|
||||
>>> print(x)
|
||||
>>> print("Error: ", a*x-b)
|
||||
>>>
|
||||
>>> print("Solve: double precision complex:")
|
||||
>>> use_solver( useUmfpack = True )
|
||||
>>> a = a.astype('D')
|
||||
>>> x = spsolve(a, b)
|
||||
>>> print(x)
|
||||
>>> print("Error: ", a*x-b)
|
||||
>>>
|
||||
>>> print("Solve: double precision:")
|
||||
>>> a = a.astype('d')
|
||||
>>> x = spsolve(a, b)
|
||||
>>> print(x)
|
||||
>>> print("Error: ", a*x-b)
|
||||
>>>
|
||||
>>> print("Solve: single precision:")
|
||||
>>> use_solver( useUmfpack = False )
|
||||
>>> a = a.astype('f')
|
||||
>>> x = spsolve(a, b.astype('f'))
|
||||
>>> print(x)
|
||||
>>> print("Error: ", a*x-b)
|
||||
|
||||
"""
|
||||
|
||||
from __future__ import division, print_function, absolute_import
|
||||
|
||||
#import umfpack
|
||||
#__doc__ = '\n\n'.join( (__doc__, umfpack.__doc__) )
|
||||
#del umfpack
|
||||
|
||||
from .linsolve import *
|
||||
from ._superlu import SuperLU
|
||||
from . import _add_newdocs
|
||||
|
||||
__all__ = [s for s in dir() if not s.startswith('_')]
|
||||
|
||||
from scipy._lib._testutils import PytestTester
|
||||
test = PytestTester(__name__)
|
||||
del PytestTester
|
||||
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
@@ -0,0 +1,154 @@
|
||||
from numpy.lib import add_newdoc
|
||||
|
||||
add_newdoc('scipy.sparse.linalg.dsolve._superlu', 'SuperLU',
|
||||
"""
|
||||
LU factorization of a sparse matrix.
|
||||
|
||||
Factorization is represented as::
|
||||
|
||||
Pr * A * Pc = L * U
|
||||
|
||||
To construct these `SuperLU` objects, call the `splu` and `spilu`
|
||||
functions.
|
||||
|
||||
Attributes
|
||||
----------
|
||||
shape
|
||||
nnz
|
||||
perm_c
|
||||
perm_r
|
||||
L
|
||||
U
|
||||
|
||||
Methods
|
||||
-------
|
||||
solve
|
||||
|
||||
Notes
|
||||
-----
|
||||
|
||||
.. versionadded:: 0.14.0
|
||||
|
||||
Examples
|
||||
--------
|
||||
The LU decomposition can be used to solve matrix equations. Consider:
|
||||
|
||||
>>> import numpy as np
|
||||
>>> from scipy.sparse import csc_matrix, linalg as sla
|
||||
>>> A = csc_matrix([[1,2,0,4],[1,0,0,1],[1,0,2,1],[2,2,1,0.]])
|
||||
|
||||
This can be solved for a given right-hand side:
|
||||
|
||||
>>> lu = sla.splu(A)
|
||||
>>> b = np.array([1, 2, 3, 4])
|
||||
>>> x = lu.solve(b)
|
||||
>>> A.dot(x)
|
||||
array([ 1., 2., 3., 4.])
|
||||
|
||||
The ``lu`` object also contains an explicit representation of the
|
||||
decomposition. The permutations are represented as mappings of
|
||||
indices:
|
||||
|
||||
>>> lu.perm_r
|
||||
array([0, 2, 1, 3], dtype=int32)
|
||||
>>> lu.perm_c
|
||||
array([2, 0, 1, 3], dtype=int32)
|
||||
|
||||
The L and U factors are sparse matrices in CSC format:
|
||||
|
||||
>>> lu.L.A
|
||||
array([[ 1. , 0. , 0. , 0. ],
|
||||
[ 0. , 1. , 0. , 0. ],
|
||||
[ 0. , 0. , 1. , 0. ],
|
||||
[ 1. , 0.5, 0.5, 1. ]])
|
||||
>>> lu.U.A
|
||||
array([[ 2., 0., 1., 4.],
|
||||
[ 0., 2., 1., 1.],
|
||||
[ 0., 0., 1., 1.],
|
||||
[ 0., 0., 0., -5.]])
|
||||
|
||||
The permutation matrices can be constructed:
|
||||
|
||||
>>> Pr = csc_matrix((4, 4))
|
||||
>>> Pr[lu.perm_r, np.arange(4)] = 1
|
||||
>>> Pc = csc_matrix((4, 4))
|
||||
>>> Pc[np.arange(4), lu.perm_c] = 1
|
||||
|
||||
We can reassemble the original matrix:
|
||||
|
||||
>>> (Pr.T * (lu.L * lu.U) * Pc.T).A
|
||||
array([[ 1., 2., 0., 4.],
|
||||
[ 1., 0., 0., 1.],
|
||||
[ 1., 0., 2., 1.],
|
||||
[ 2., 2., 1., 0.]])
|
||||
""")
|
||||
|
||||
add_newdoc('scipy.sparse.linalg.dsolve._superlu', 'SuperLU', ('solve',
|
||||
"""
|
||||
solve(rhs[, trans])
|
||||
|
||||
Solves linear system of equations with one or several right-hand sides.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
rhs : ndarray, shape (n,) or (n, k)
|
||||
Right hand side(s) of equation
|
||||
trans : {'N', 'T', 'H'}, optional
|
||||
Type of system to solve::
|
||||
|
||||
'N': A * x == rhs (default)
|
||||
'T': A^T * x == rhs
|
||||
'H': A^H * x == rhs
|
||||
|
||||
i.e., normal, transposed, and hermitian conjugate.
|
||||
|
||||
Returns
|
||||
-------
|
||||
x : ndarray, shape ``rhs.shape``
|
||||
Solution vector(s)
|
||||
"""))
|
||||
|
||||
add_newdoc('scipy.sparse.linalg.dsolve._superlu', 'SuperLU', ('L',
|
||||
"""
|
||||
Lower triangular factor with unit diagonal as a
|
||||
`scipy.sparse.csc_matrix`.
|
||||
|
||||
.. versionadded:: 0.14.0
|
||||
"""))
|
||||
|
||||
add_newdoc('scipy.sparse.linalg.dsolve._superlu', 'SuperLU', ('U',
|
||||
"""
|
||||
Upper triangular factor as a `scipy.sparse.csc_matrix`.
|
||||
|
||||
.. versionadded:: 0.14.0
|
||||
"""))
|
||||
|
||||
add_newdoc('scipy.sparse.linalg.dsolve._superlu', 'SuperLU', ('shape',
|
||||
"""
|
||||
Shape of the original matrix as a tuple of ints.
|
||||
"""))
|
||||
|
||||
add_newdoc('scipy.sparse.linalg.dsolve._superlu', 'SuperLU', ('nnz',
|
||||
"""
|
||||
Number of nonzero elements in the matrix.
|
||||
"""))
|
||||
|
||||
add_newdoc('scipy.sparse.linalg.dsolve._superlu', 'SuperLU', ('perm_c',
|
||||
"""
|
||||
Permutation Pc represented as an array of indices.
|
||||
|
||||
The column permutation matrix can be reconstructed via:
|
||||
|
||||
>>> Pc = np.zeros((n, n))
|
||||
>>> Pc[np.arange(n), perm_c] = 1
|
||||
"""))
|
||||
|
||||
add_newdoc('scipy.sparse.linalg.dsolve._superlu', 'SuperLU', ('perm_r',
|
||||
"""
|
||||
Permutation Pr represented as an array of indices.
|
||||
|
||||
The row permutation matrix can be reconstructed via:
|
||||
|
||||
>>> Pr = np.zeros((n, n))
|
||||
>>> Pr[perm_r, np.arange(n)] = 1
|
||||
"""))
|
||||
BIN
Binary file not shown.
@@ -0,0 +1,570 @@
|
||||
from __future__ import division, print_function, absolute_import
|
||||
|
||||
from warnings import warn
|
||||
|
||||
import numpy as np
|
||||
from numpy import asarray
|
||||
from scipy.sparse import (isspmatrix_csc, isspmatrix_csr, isspmatrix,
|
||||
SparseEfficiencyWarning, csc_matrix, csr_matrix)
|
||||
from scipy.linalg import LinAlgError
|
||||
|
||||
from . import _superlu
|
||||
|
||||
noScikit = False
|
||||
try:
|
||||
import scikits.umfpack as umfpack
|
||||
except ImportError:
|
||||
noScikit = True
|
||||
|
||||
useUmfpack = not noScikit
|
||||
|
||||
__all__ = ['use_solver', 'spsolve', 'splu', 'spilu', 'factorized',
|
||||
'MatrixRankWarning', 'spsolve_triangular']
|
||||
|
||||
|
||||
class MatrixRankWarning(UserWarning):
|
||||
pass
|
||||
|
||||
|
||||
def use_solver(**kwargs):
|
||||
"""
|
||||
Select default sparse direct solver to be used.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
useUmfpack : bool, optional
|
||||
Use UMFPACK over SuperLU. Has effect only if scikits.umfpack is
|
||||
installed. Default: True
|
||||
assumeSortedIndices : bool, optional
|
||||
Allow UMFPACK to skip the step of sorting indices for a CSR/CSC matrix.
|
||||
Has effect only if useUmfpack is True and scikits.umfpack is installed.
|
||||
Default: False
|
||||
|
||||
Notes
|
||||
-----
|
||||
The default sparse solver is umfpack when available
|
||||
(scikits.umfpack is installed). This can be changed by passing
|
||||
useUmfpack = False, which then causes the always present SuperLU
|
||||
based solver to be used.
|
||||
|
||||
Umfpack requires a CSR/CSC matrix to have sorted column/row indices. If
|
||||
sure that the matrix fulfills this, pass ``assumeSortedIndices=True``
|
||||
to gain some speed.
|
||||
|
||||
"""
|
||||
if 'useUmfpack' in kwargs:
|
||||
globals()['useUmfpack'] = kwargs['useUmfpack']
|
||||
if useUmfpack and 'assumeSortedIndices' in kwargs:
|
||||
umfpack.configure(assumeSortedIndices=kwargs['assumeSortedIndices'])
|
||||
|
||||
def _get_umf_family(A):
|
||||
"""Get umfpack family string given the sparse matrix dtype."""
|
||||
_families = {
|
||||
(np.float64, np.int32): 'di',
|
||||
(np.complex128, np.int32): 'zi',
|
||||
(np.float64, np.int64): 'dl',
|
||||
(np.complex128, np.int64): 'zl'
|
||||
}
|
||||
|
||||
f_type = np.sctypeDict[A.dtype.name]
|
||||
i_type = np.sctypeDict[A.indices.dtype.name]
|
||||
|
||||
try:
|
||||
family = _families[(f_type, i_type)]
|
||||
|
||||
except KeyError:
|
||||
msg = 'only float64 or complex128 matrices with int32 or int64' \
|
||||
' indices are supported! (got: matrix: %s, indices: %s)' \
|
||||
% (f_type, i_type)
|
||||
raise ValueError(msg)
|
||||
|
||||
return family
|
||||
|
||||
def spsolve(A, b, permc_spec=None, use_umfpack=True):
|
||||
"""Solve the sparse linear system Ax=b, where b may be a vector or a matrix.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
A : ndarray or sparse matrix
|
||||
The square matrix A will be converted into CSC or CSR form
|
||||
b : ndarray or sparse matrix
|
||||
The matrix or vector representing the right hand side of the equation.
|
||||
If a vector, b.shape must be (n,) or (n, 1).
|
||||
permc_spec : str, optional
|
||||
How to permute the columns of the matrix for sparsity preservation.
|
||||
(default: 'COLAMD')
|
||||
|
||||
- ``NATURAL``: natural ordering.
|
||||
- ``MMD_ATA``: minimum degree ordering on the structure of A^T A.
|
||||
- ``MMD_AT_PLUS_A``: minimum degree ordering on the structure of A^T+A.
|
||||
- ``COLAMD``: approximate minimum degree column ordering
|
||||
use_umfpack : bool, optional
|
||||
if True (default) then use umfpack for the solution. This is
|
||||
only referenced if b is a vector and ``scikit-umfpack`` is installed.
|
||||
|
||||
Returns
|
||||
-------
|
||||
x : ndarray or sparse matrix
|
||||
the solution of the sparse linear equation.
|
||||
If b is a vector, then x is a vector of size A.shape[1]
|
||||
If b is a matrix, then x is a matrix of size (A.shape[1], b.shape[1])
|
||||
|
||||
Notes
|
||||
-----
|
||||
For solving the matrix expression AX = B, this solver assumes the resulting
|
||||
matrix X is sparse, as is often the case for very sparse inputs. If the
|
||||
resulting X is dense, the construction of this sparse result will be
|
||||
relatively expensive. In that case, consider converting A to a dense
|
||||
matrix and using scipy.linalg.solve or its variants.
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> from scipy.sparse import csc_matrix
|
||||
>>> from scipy.sparse.linalg import spsolve
|
||||
>>> A = csc_matrix([[3, 2, 0], [1, -1, 0], [0, 5, 1]], dtype=float)
|
||||
>>> B = csc_matrix([[2, 0], [-1, 0], [2, 0]], dtype=float)
|
||||
>>> x = spsolve(A, B)
|
||||
>>> np.allclose(A.dot(x).todense(), B.todense())
|
||||
True
|
||||
"""
|
||||
if not (isspmatrix_csc(A) or isspmatrix_csr(A)):
|
||||
A = csc_matrix(A)
|
||||
warn('spsolve requires A be CSC or CSR matrix format',
|
||||
SparseEfficiencyWarning)
|
||||
|
||||
# b is a vector only if b have shape (n,) or (n, 1)
|
||||
b_is_sparse = isspmatrix(b)
|
||||
if not b_is_sparse:
|
||||
b = asarray(b)
|
||||
b_is_vector = ((b.ndim == 1) or (b.ndim == 2 and b.shape[1] == 1))
|
||||
|
||||
# sum duplicates for non-canonical format
|
||||
A.sum_duplicates()
|
||||
A = A.asfptype() # upcast to a floating point format
|
||||
result_dtype = np.promote_types(A.dtype, b.dtype)
|
||||
if A.dtype != result_dtype:
|
||||
A = A.astype(result_dtype)
|
||||
if b.dtype != result_dtype:
|
||||
b = b.astype(result_dtype)
|
||||
|
||||
# validate input shapes
|
||||
M, N = A.shape
|
||||
if (M != N):
|
||||
raise ValueError("matrix must be square (has shape %s)" % ((M, N),))
|
||||
|
||||
if M != b.shape[0]:
|
||||
raise ValueError("matrix - rhs dimension mismatch (%s - %s)"
|
||||
% (A.shape, b.shape[0]))
|
||||
|
||||
use_umfpack = use_umfpack and useUmfpack
|
||||
|
||||
if b_is_vector and use_umfpack:
|
||||
if b_is_sparse:
|
||||
b_vec = b.toarray()
|
||||
else:
|
||||
b_vec = b
|
||||
b_vec = asarray(b_vec, dtype=A.dtype).ravel()
|
||||
|
||||
if noScikit:
|
||||
raise RuntimeError('Scikits.umfpack not installed.')
|
||||
|
||||
if A.dtype.char not in 'dD':
|
||||
raise ValueError("convert matrix data to double, please, using"
|
||||
" .astype(), or set linsolve.useUmfpack = False")
|
||||
|
||||
umf = umfpack.UmfpackContext(_get_umf_family(A))
|
||||
x = umf.linsolve(umfpack.UMFPACK_A, A, b_vec,
|
||||
autoTranspose=True)
|
||||
else:
|
||||
if b_is_vector and b_is_sparse:
|
||||
b = b.toarray()
|
||||
b_is_sparse = False
|
||||
|
||||
if not b_is_sparse:
|
||||
if isspmatrix_csc(A):
|
||||
flag = 1 # CSC format
|
||||
else:
|
||||
flag = 0 # CSR format
|
||||
|
||||
options = dict(ColPerm=permc_spec)
|
||||
x, info = _superlu.gssv(N, A.nnz, A.data, A.indices, A.indptr,
|
||||
b, flag, options=options)
|
||||
if info != 0:
|
||||
warn("Matrix is exactly singular", MatrixRankWarning)
|
||||
x.fill(np.nan)
|
||||
if b_is_vector:
|
||||
x = x.ravel()
|
||||
else:
|
||||
# b is sparse
|
||||
Afactsolve = factorized(A)
|
||||
|
||||
if not isspmatrix_csc(b):
|
||||
warn('spsolve is more efficient when sparse b '
|
||||
'is in the CSC matrix format', SparseEfficiencyWarning)
|
||||
b = csc_matrix(b)
|
||||
|
||||
# Create a sparse output matrix by repeatedly applying
|
||||
# the sparse factorization to solve columns of b.
|
||||
data_segs = []
|
||||
row_segs = []
|
||||
col_segs = []
|
||||
for j in range(b.shape[1]):
|
||||
bj = b[:, j].A.ravel()
|
||||
xj = Afactsolve(bj)
|
||||
w = np.flatnonzero(xj)
|
||||
segment_length = w.shape[0]
|
||||
row_segs.append(w)
|
||||
col_segs.append(np.full(segment_length, j, dtype=int))
|
||||
data_segs.append(np.asarray(xj[w], dtype=A.dtype))
|
||||
sparse_data = np.concatenate(data_segs)
|
||||
sparse_row = np.concatenate(row_segs)
|
||||
sparse_col = np.concatenate(col_segs)
|
||||
x = A.__class__((sparse_data, (sparse_row, sparse_col)),
|
||||
shape=b.shape, dtype=A.dtype)
|
||||
|
||||
return x
|
||||
|
||||
|
||||
def splu(A, permc_spec=None, diag_pivot_thresh=None,
|
||||
relax=None, panel_size=None, options=dict()):
|
||||
"""
|
||||
Compute the LU decomposition of a sparse, square matrix.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
A : sparse matrix
|
||||
Sparse matrix to factorize. Should be in CSR or CSC format.
|
||||
permc_spec : str, optional
|
||||
How to permute the columns of the matrix for sparsity preservation.
|
||||
(default: 'COLAMD')
|
||||
|
||||
- ``NATURAL``: natural ordering.
|
||||
- ``MMD_ATA``: minimum degree ordering on the structure of A^T A.
|
||||
- ``MMD_AT_PLUS_A``: minimum degree ordering on the structure of A^T+A.
|
||||
- ``COLAMD``: approximate minimum degree column ordering
|
||||
|
||||
diag_pivot_thresh : float, optional
|
||||
Threshold used for a diagonal entry to be an acceptable pivot.
|
||||
See SuperLU user's guide for details [1]_
|
||||
relax : int, optional
|
||||
Expert option for customizing the degree of relaxing supernodes.
|
||||
See SuperLU user's guide for details [1]_
|
||||
panel_size : int, optional
|
||||
Expert option for customizing the panel size.
|
||||
See SuperLU user's guide for details [1]_
|
||||
options : dict, optional
|
||||
Dictionary containing additional expert options to SuperLU.
|
||||
See SuperLU user guide [1]_ (section 2.4 on the 'Options' argument)
|
||||
for more details. For example, you can specify
|
||||
``options=dict(Equil=False, IterRefine='SINGLE'))``
|
||||
to turn equilibration off and perform a single iterative refinement.
|
||||
|
||||
Returns
|
||||
-------
|
||||
invA : scipy.sparse.linalg.SuperLU
|
||||
Object, which has a ``solve`` method.
|
||||
|
||||
See also
|
||||
--------
|
||||
spilu : incomplete LU decomposition
|
||||
|
||||
Notes
|
||||
-----
|
||||
This function uses the SuperLU library.
|
||||
|
||||
References
|
||||
----------
|
||||
.. [1] SuperLU http://crd.lbl.gov/~xiaoye/SuperLU/
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> from scipy.sparse import csc_matrix
|
||||
>>> from scipy.sparse.linalg import splu
|
||||
>>> A = csc_matrix([[1., 0., 0.], [5., 0., 2.], [0., -1., 0.]], dtype=float)
|
||||
>>> B = splu(A)
|
||||
>>> x = np.array([1., 2., 3.], dtype=float)
|
||||
>>> B.solve(x)
|
||||
array([ 1. , -3. , -1.5])
|
||||
>>> A.dot(B.solve(x))
|
||||
array([ 1., 2., 3.])
|
||||
>>> B.solve(A.dot(x))
|
||||
array([ 1., 2., 3.])
|
||||
"""
|
||||
|
||||
if not isspmatrix_csc(A):
|
||||
A = csc_matrix(A)
|
||||
warn('splu requires CSC matrix format', SparseEfficiencyWarning)
|
||||
|
||||
# sum duplicates for non-canonical format
|
||||
A.sum_duplicates()
|
||||
A = A.asfptype() # upcast to a floating point format
|
||||
|
||||
M, N = A.shape
|
||||
if (M != N):
|
||||
raise ValueError("can only factor square matrices") # is this true?
|
||||
|
||||
_options = dict(DiagPivotThresh=diag_pivot_thresh, ColPerm=permc_spec,
|
||||
PanelSize=panel_size, Relax=relax)
|
||||
if options is not None:
|
||||
_options.update(options)
|
||||
return _superlu.gstrf(N, A.nnz, A.data, A.indices, A.indptr,
|
||||
ilu=False, options=_options)
|
||||
|
||||
|
||||
def spilu(A, drop_tol=None, fill_factor=None, drop_rule=None, permc_spec=None,
|
||||
diag_pivot_thresh=None, relax=None, panel_size=None, options=None):
|
||||
"""
|
||||
Compute an incomplete LU decomposition for a sparse, square matrix.
|
||||
|
||||
The resulting object is an approximation to the inverse of `A`.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
A : (N, N) array_like
|
||||
Sparse matrix to factorize
|
||||
drop_tol : float, optional
|
||||
Drop tolerance (0 <= tol <= 1) for an incomplete LU decomposition.
|
||||
(default: 1e-4)
|
||||
fill_factor : float, optional
|
||||
Specifies the fill ratio upper bound (>= 1.0) for ILU. (default: 10)
|
||||
drop_rule : str, optional
|
||||
Comma-separated string of drop rules to use.
|
||||
Available rules: ``basic``, ``prows``, ``column``, ``area``,
|
||||
``secondary``, ``dynamic``, ``interp``. (Default: ``basic,area``)
|
||||
|
||||
See SuperLU documentation for details.
|
||||
|
||||
Remaining other options
|
||||
Same as for `splu`
|
||||
|
||||
Returns
|
||||
-------
|
||||
invA_approx : scipy.sparse.linalg.SuperLU
|
||||
Object, which has a ``solve`` method.
|
||||
|
||||
See also
|
||||
--------
|
||||
splu : complete LU decomposition
|
||||
|
||||
Notes
|
||||
-----
|
||||
To improve the better approximation to the inverse, you may need to
|
||||
increase `fill_factor` AND decrease `drop_tol`.
|
||||
|
||||
This function uses the SuperLU library.
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> from scipy.sparse import csc_matrix
|
||||
>>> from scipy.sparse.linalg import spilu
|
||||
>>> A = csc_matrix([[1., 0., 0.], [5., 0., 2.], [0., -1., 0.]], dtype=float)
|
||||
>>> B = spilu(A)
|
||||
>>> x = np.array([1., 2., 3.], dtype=float)
|
||||
>>> B.solve(x)
|
||||
array([ 1. , -3. , -1.5])
|
||||
>>> A.dot(B.solve(x))
|
||||
array([ 1., 2., 3.])
|
||||
>>> B.solve(A.dot(x))
|
||||
array([ 1., 2., 3.])
|
||||
"""
|
||||
if not isspmatrix_csc(A):
|
||||
A = csc_matrix(A)
|
||||
warn('splu requires CSC matrix format', SparseEfficiencyWarning)
|
||||
|
||||
# sum duplicates for non-canonical format
|
||||
A.sum_duplicates()
|
||||
A = A.asfptype() # upcast to a floating point format
|
||||
|
||||
M, N = A.shape
|
||||
if (M != N):
|
||||
raise ValueError("can only factor square matrices") # is this true?
|
||||
|
||||
_options = dict(ILU_DropRule=drop_rule, ILU_DropTol=drop_tol,
|
||||
ILU_FillFactor=fill_factor,
|
||||
DiagPivotThresh=diag_pivot_thresh, ColPerm=permc_spec,
|
||||
PanelSize=panel_size, Relax=relax)
|
||||
if options is not None:
|
||||
_options.update(options)
|
||||
return _superlu.gstrf(N, A.nnz, A.data, A.indices, A.indptr,
|
||||
ilu=True, options=_options)
|
||||
|
||||
|
||||
def factorized(A):
|
||||
"""
|
||||
Return a function for solving a sparse linear system, with A pre-factorized.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
A : (N, N) array_like
|
||||
Input.
|
||||
|
||||
Returns
|
||||
-------
|
||||
solve : callable
|
||||
To solve the linear system of equations given in `A`, the `solve`
|
||||
callable should be passed an ndarray of shape (N,).
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> from scipy.sparse.linalg import factorized
|
||||
>>> A = np.array([[ 3. , 2. , -1. ],
|
||||
... [ 2. , -2. , 4. ],
|
||||
... [-1. , 0.5, -1. ]])
|
||||
>>> solve = factorized(A) # Makes LU decomposition.
|
||||
>>> rhs1 = np.array([1, -2, 0])
|
||||
>>> solve(rhs1) # Uses the LU factors.
|
||||
array([ 1., -2., -2.])
|
||||
|
||||
"""
|
||||
if useUmfpack:
|
||||
if noScikit:
|
||||
raise RuntimeError('Scikits.umfpack not installed.')
|
||||
|
||||
if not isspmatrix_csc(A):
|
||||
A = csc_matrix(A)
|
||||
warn('splu requires CSC matrix format', SparseEfficiencyWarning)
|
||||
|
||||
A = A.asfptype() # upcast to a floating point format
|
||||
|
||||
if A.dtype.char not in 'dD':
|
||||
raise ValueError("convert matrix data to double, please, using"
|
||||
" .astype(), or set linsolve.useUmfpack = False")
|
||||
|
||||
umf = umfpack.UmfpackContext(_get_umf_family(A))
|
||||
|
||||
# Make LU decomposition.
|
||||
umf.numeric(A)
|
||||
|
||||
def solve(b):
|
||||
return umf.solve(umfpack.UMFPACK_A, A, b, autoTranspose=True)
|
||||
|
||||
return solve
|
||||
else:
|
||||
return splu(A).solve
|
||||
|
||||
|
||||
def spsolve_triangular(A, b, lower=True, overwrite_A=False, overwrite_b=False):
|
||||
"""
|
||||
Solve the equation `A x = b` for `x`, assuming A is a triangular matrix.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
A : (M, M) sparse matrix
|
||||
A sparse square triangular matrix. Should be in CSR format.
|
||||
b : (M,) or (M, N) array_like
|
||||
Right-hand side matrix in `A x = b`
|
||||
lower : bool, optional
|
||||
Whether `A` is a lower or upper triangular matrix.
|
||||
Default is lower triangular matrix.
|
||||
overwrite_A : bool, optional
|
||||
Allow changing `A`. The indices of `A` are going to be sorted and zero
|
||||
entries are going to be removed.
|
||||
Enabling gives a performance gain. Default is False.
|
||||
overwrite_b : bool, optional
|
||||
Allow overwriting data in `b`.
|
||||
Enabling gives a performance gain. Default is False.
|
||||
If `overwrite_b` is True, it should be ensured that
|
||||
`b` has an appropriate dtype to be able to store the result.
|
||||
|
||||
Returns
|
||||
-------
|
||||
x : (M,) or (M, N) ndarray
|
||||
Solution to the system `A x = b`. Shape of return matches shape of `b`.
|
||||
|
||||
Raises
|
||||
------
|
||||
LinAlgError
|
||||
If `A` is singular or not triangular.
|
||||
ValueError
|
||||
If shape of `A` or shape of `b` do not match the requirements.
|
||||
|
||||
Notes
|
||||
-----
|
||||
.. versionadded:: 0.19.0
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> from scipy.sparse import csr_matrix
|
||||
>>> from scipy.sparse.linalg import spsolve_triangular
|
||||
>>> A = csr_matrix([[3, 0, 0], [1, -1, 0], [2, 0, 1]], dtype=float)
|
||||
>>> B = np.array([[2, 0], [-1, 0], [2, 0]], dtype=float)
|
||||
>>> x = spsolve_triangular(A, B)
|
||||
>>> np.allclose(A.dot(x), B)
|
||||
True
|
||||
"""
|
||||
|
||||
# Check the input for correct type and format.
|
||||
if not isspmatrix_csr(A):
|
||||
warn('CSR matrix format is required. Converting to CSR matrix.',
|
||||
SparseEfficiencyWarning)
|
||||
A = csr_matrix(A)
|
||||
elif not overwrite_A:
|
||||
A = A.copy()
|
||||
|
||||
if A.shape[0] != A.shape[1]:
|
||||
raise ValueError(
|
||||
'A must be a square matrix but its shape is {}.'.format(A.shape))
|
||||
|
||||
# sum duplicates for non-canonical format
|
||||
A.sum_duplicates()
|
||||
|
||||
b = np.asanyarray(b)
|
||||
|
||||
if b.ndim not in [1, 2]:
|
||||
raise ValueError(
|
||||
'b must have 1 or 2 dims but its shape is {}.'.format(b.shape))
|
||||
if A.shape[0] != b.shape[0]:
|
||||
raise ValueError(
|
||||
'The size of the dimensions of A must be equal to '
|
||||
'the size of the first dimension of b but the shape of A is '
|
||||
'{} and the shape of b is {}.'.format(A.shape, b.shape))
|
||||
|
||||
# Init x as (a copy of) b.
|
||||
x_dtype = np.result_type(A.data, b, np.float)
|
||||
if overwrite_b:
|
||||
if np.can_cast(b.dtype, x_dtype, casting='same_kind'):
|
||||
x = b
|
||||
else:
|
||||
raise ValueError(
|
||||
'Cannot overwrite b (dtype {}) with result '
|
||||
'of type {}.'.format(b.dtype, x_dtype))
|
||||
else:
|
||||
x = b.astype(x_dtype, copy=True)
|
||||
|
||||
# Choose forward or backward order.
|
||||
if lower:
|
||||
row_indices = range(len(b))
|
||||
else:
|
||||
row_indices = range(len(b) - 1, -1, -1)
|
||||
|
||||
# Fill x iteratively.
|
||||
for i in row_indices:
|
||||
|
||||
# Get indices for i-th row.
|
||||
indptr_start = A.indptr[i]
|
||||
indptr_stop = A.indptr[i + 1]
|
||||
if lower:
|
||||
A_diagonal_index_row_i = indptr_stop - 1
|
||||
A_off_diagonal_indices_row_i = slice(indptr_start, indptr_stop - 1)
|
||||
else:
|
||||
A_diagonal_index_row_i = indptr_start
|
||||
A_off_diagonal_indices_row_i = slice(indptr_start + 1, indptr_stop)
|
||||
|
||||
# Check regularity and triangularity of A.
|
||||
if indptr_stop <= indptr_start or A.indices[A_diagonal_index_row_i] < i:
|
||||
raise LinAlgError(
|
||||
'A is singular: diagonal {} is zero.'.format(i))
|
||||
if A.indices[A_diagonal_index_row_i] > i:
|
||||
raise LinAlgError(
|
||||
'A is not triangular: A[{}, {}] is nonzero.'
|
||||
''.format(i, A.indices[A_diagonal_index_row_i]))
|
||||
|
||||
# Incorporate off-diagonal entries.
|
||||
A_column_indices_in_row_i = A.indices[A_off_diagonal_indices_row_i]
|
||||
A_values_in_row_i = A.data[A_off_diagonal_indices_row_i]
|
||||
x[i] -= np.dot(x[A_column_indices_in_row_i].T, A_values_in_row_i)
|
||||
|
||||
# Compute i-th entry of x.
|
||||
x[i] /= A.data[A_diagonal_index_row_i]
|
||||
|
||||
return x
|
||||
@@ -0,0 +1,56 @@
|
||||
from __future__ import division, print_function, absolute_import
|
||||
|
||||
from os.path import join, dirname
|
||||
import sys
|
||||
import os
|
||||
import glob
|
||||
|
||||
|
||||
def configuration(parent_package='',top_path=None):
|
||||
from numpy.distutils.misc_util import Configuration
|
||||
from scipy._build_utils.system_info import get_info
|
||||
from scipy._build_utils import numpy_nodepr_api
|
||||
|
||||
config = Configuration('dsolve',parent_package,top_path)
|
||||
config.add_data_dir('tests')
|
||||
|
||||
lapack_opt = get_info('lapack_opt',notfound_action=2)
|
||||
if sys.platform == 'win32':
|
||||
superlu_defs = [('NO_TIMER',1)]
|
||||
else:
|
||||
superlu_defs = []
|
||||
superlu_defs.append(('USE_VENDOR_BLAS',1))
|
||||
|
||||
superlu_src = join(dirname(__file__), 'SuperLU', 'SRC')
|
||||
|
||||
sources = sorted(glob.glob(join(superlu_src, '*.c')))
|
||||
headers = list(glob.glob(join(superlu_src, '*.h')))
|
||||
|
||||
config.add_library('superlu_src',
|
||||
sources=sources,
|
||||
macros=superlu_defs,
|
||||
include_dirs=[superlu_src],
|
||||
)
|
||||
|
||||
# Extension
|
||||
ext_sources = ['_superlumodule.c',
|
||||
'_superlu_utils.c',
|
||||
'_superluobject.c']
|
||||
|
||||
config.add_extension('_superlu',
|
||||
sources=ext_sources,
|
||||
libraries=['superlu_src'],
|
||||
depends=(sources + headers),
|
||||
extra_info=lapack_opt,
|
||||
**numpy_nodepr_api
|
||||
)
|
||||
|
||||
# Add license files
|
||||
config.add_data_files('SuperLU/License.txt')
|
||||
|
||||
return config
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
from numpy.distutils.core import setup
|
||||
setup(**configuration(top_path='').todict())
|
||||
BIN
Binary file not shown.
BIN
Binary file not shown.
+718
@@ -0,0 +1,718 @@
|
||||
from __future__ import division, print_function, absolute_import
|
||||
|
||||
import sys
|
||||
import threading
|
||||
|
||||
import numpy as np
|
||||
from numpy import array, finfo, arange, eye, all, unique, ones, dot, matrix
|
||||
import numpy.random as random
|
||||
from numpy.testing import (
|
||||
assert_array_almost_equal, assert_almost_equal,
|
||||
assert_equal, assert_array_equal, assert_, assert_allclose,
|
||||
assert_warns)
|
||||
import pytest
|
||||
from pytest import raises as assert_raises
|
||||
|
||||
import scipy.linalg
|
||||
from scipy.linalg import norm, inv
|
||||
from scipy.sparse import (spdiags, SparseEfficiencyWarning, csc_matrix,
|
||||
csr_matrix, identity, isspmatrix, dok_matrix, lil_matrix, bsr_matrix)
|
||||
from scipy.sparse.linalg import SuperLU
|
||||
from scipy.sparse.linalg.dsolve import (spsolve, use_solver, splu, spilu,
|
||||
MatrixRankWarning, _superlu, spsolve_triangular, factorized)
|
||||
|
||||
from scipy._lib._numpy_compat import suppress_warnings
|
||||
|
||||
|
||||
sup_sparse_efficiency = suppress_warnings()
|
||||
sup_sparse_efficiency.filter(SparseEfficiencyWarning)
|
||||
|
||||
# scikits.umfpack is not a SciPy dependency but it is optionally used in
|
||||
# dsolve, so check whether it's available
|
||||
try:
|
||||
import scikits.umfpack as umfpack
|
||||
has_umfpack = True
|
||||
except ImportError:
|
||||
has_umfpack = False
|
||||
|
||||
def toarray(a):
|
||||
if isspmatrix(a):
|
||||
return a.toarray()
|
||||
else:
|
||||
return a
|
||||
|
||||
|
||||
class TestFactorized(object):
|
||||
def setup_method(self):
|
||||
n = 5
|
||||
d = arange(n) + 1
|
||||
self.n = n
|
||||
self.A = spdiags((d, 2*d, d[::-1]), (-3, 0, 5), n, n).tocsc()
|
||||
random.seed(1234)
|
||||
|
||||
def _check_singular(self):
|
||||
A = csc_matrix((5,5), dtype='d')
|
||||
b = ones(5)
|
||||
assert_array_almost_equal(0. * b, factorized(A)(b))
|
||||
|
||||
def _check_non_singular(self):
|
||||
# Make a diagonal dominant, to make sure it is not singular
|
||||
n = 5
|
||||
a = csc_matrix(random.rand(n, n))
|
||||
b = ones(n)
|
||||
|
||||
expected = splu(a).solve(b)
|
||||
assert_array_almost_equal(factorized(a)(b), expected)
|
||||
|
||||
def test_singular_without_umfpack(self):
|
||||
use_solver(useUmfpack=False)
|
||||
with assert_raises(RuntimeError, match="Factor is exactly singular"):
|
||||
self._check_singular()
|
||||
|
||||
@pytest.mark.skipif(not has_umfpack, reason="umfpack not available")
|
||||
def test_singular_with_umfpack(self):
|
||||
use_solver(useUmfpack=True)
|
||||
with suppress_warnings() as sup:
|
||||
sup.filter(RuntimeWarning, "divide by zero encountered in double_scalars")
|
||||
assert_warns(umfpack.UmfpackWarning, self._check_singular)
|
||||
|
||||
def test_non_singular_without_umfpack(self):
|
||||
use_solver(useUmfpack=False)
|
||||
self._check_non_singular()
|
||||
|
||||
@pytest.mark.skipif(not has_umfpack, reason="umfpack not available")
|
||||
def test_non_singular_with_umfpack(self):
|
||||
use_solver(useUmfpack=True)
|
||||
self._check_non_singular()
|
||||
|
||||
def test_cannot_factorize_nonsquare_matrix_without_umfpack(self):
|
||||
use_solver(useUmfpack=False)
|
||||
msg = "can only factor square matrices"
|
||||
with assert_raises(ValueError, match=msg):
|
||||
factorized(self.A[:, :4])
|
||||
|
||||
@pytest.mark.skipif(not has_umfpack, reason="umfpack not available")
|
||||
def test_factorizes_nonsquare_matrix_with_umfpack(self):
|
||||
use_solver(useUmfpack=True)
|
||||
# does not raise
|
||||
factorized(self.A[:,:4])
|
||||
|
||||
def test_call_with_incorrectly_sized_matrix_without_umfpack(self):
|
||||
use_solver(useUmfpack=False)
|
||||
solve = factorized(self.A)
|
||||
b = random.rand(4)
|
||||
B = random.rand(4, 3)
|
||||
BB = random.rand(self.n, 3, 9)
|
||||
|
||||
with assert_raises(ValueError, match="is of incompatible size"):
|
||||
solve(b)
|
||||
with assert_raises(ValueError, match="is of incompatible size"):
|
||||
solve(B)
|
||||
with assert_raises(ValueError,
|
||||
match="object too deep for desired array"):
|
||||
solve(BB)
|
||||
|
||||
@pytest.mark.skipif(not has_umfpack, reason="umfpack not available")
|
||||
def test_call_with_incorrectly_sized_matrix_with_umfpack(self):
|
||||
use_solver(useUmfpack=True)
|
||||
solve = factorized(self.A)
|
||||
b = random.rand(4)
|
||||
B = random.rand(4, 3)
|
||||
BB = random.rand(self.n, 3, 9)
|
||||
|
||||
# does not raise
|
||||
solve(b)
|
||||
msg = "object too deep for desired array"
|
||||
with assert_raises(ValueError, match=msg):
|
||||
solve(B)
|
||||
with assert_raises(ValueError, match=msg):
|
||||
solve(BB)
|
||||
|
||||
def test_call_with_cast_to_complex_without_umfpack(self):
|
||||
use_solver(useUmfpack=False)
|
||||
solve = factorized(self.A)
|
||||
b = random.rand(4)
|
||||
for t in [np.complex64, np.complex128]:
|
||||
with assert_raises(TypeError, match="Cannot cast array data"):
|
||||
solve(b.astype(t))
|
||||
|
||||
@pytest.mark.skipif(not has_umfpack, reason="umfpack not available")
|
||||
def test_call_with_cast_to_complex_with_umfpack(self):
|
||||
use_solver(useUmfpack=True)
|
||||
solve = factorized(self.A)
|
||||
b = random.rand(4)
|
||||
for t in [np.complex64, np.complex128]:
|
||||
assert_warns(np.ComplexWarning, solve, b.astype(t))
|
||||
|
||||
@pytest.mark.skipif(not has_umfpack, reason="umfpack not available")
|
||||
def test_assume_sorted_indices_flag(self):
|
||||
# a sparse matrix with unsorted indices
|
||||
unsorted_inds = np.array([2, 0, 1, 0])
|
||||
data = np.array([10, 16, 5, 0.4])
|
||||
indptr = np.array([0, 1, 2, 4])
|
||||
A = csc_matrix((data, unsorted_inds, indptr), (3, 3))
|
||||
b = ones(3)
|
||||
|
||||
# should raise when incorrectly assuming indices are sorted
|
||||
use_solver(useUmfpack=True, assumeSortedIndices=True)
|
||||
with assert_raises(RuntimeError,
|
||||
match="UMFPACK_ERROR_invalid_matrix"):
|
||||
factorized(A)
|
||||
|
||||
# should sort indices and succeed when not assuming indices are sorted
|
||||
use_solver(useUmfpack=True, assumeSortedIndices=False)
|
||||
expected = splu(A.copy()).solve(b)
|
||||
|
||||
assert_equal(A.has_sorted_indices, 0)
|
||||
assert_array_almost_equal(factorized(A)(b), expected)
|
||||
assert_equal(A.has_sorted_indices, 1)
|
||||
|
||||
|
||||
class TestLinsolve(object):
|
||||
def setup_method(self):
|
||||
use_solver(useUmfpack=False)
|
||||
|
||||
def test_singular(self):
|
||||
A = csc_matrix((5,5), dtype='d')
|
||||
b = array([1, 2, 3, 4, 5],dtype='d')
|
||||
with suppress_warnings() as sup:
|
||||
sup.filter(MatrixRankWarning, "Matrix is exactly singular")
|
||||
x = spsolve(A, b)
|
||||
assert_(not np.isfinite(x).any())
|
||||
|
||||
def test_singular_gh_3312(self):
|
||||
# "Bad" test case that leads SuperLU to call LAPACK with invalid
|
||||
# arguments. Check that it fails moderately gracefully.
|
||||
ij = np.array([(17, 0), (17, 6), (17, 12), (10, 13)], dtype=np.int32)
|
||||
v = np.array([0.284213, 0.94933781, 0.15767017, 0.38797296])
|
||||
A = csc_matrix((v, ij.T), shape=(20, 20))
|
||||
b = np.arange(20)
|
||||
|
||||
try:
|
||||
# should either raise a runtimeerror or return value
|
||||
# appropriate for singular input
|
||||
x = spsolve(A, b)
|
||||
assert_(not np.isfinite(x).any())
|
||||
except RuntimeError:
|
||||
pass
|
||||
|
||||
def test_twodiags(self):
|
||||
A = spdiags([[1, 2, 3, 4, 5], [6, 5, 8, 9, 10]], [0, 1], 5, 5)
|
||||
b = array([1, 2, 3, 4, 5])
|
||||
|
||||
# condition number of A
|
||||
cond_A = norm(A.todense(),2) * norm(inv(A.todense()),2)
|
||||
|
||||
for t in ['f','d','F','D']:
|
||||
eps = finfo(t).eps # floating point epsilon
|
||||
b = b.astype(t)
|
||||
|
||||
for format in ['csc','csr']:
|
||||
Asp = A.astype(t).asformat(format)
|
||||
|
||||
x = spsolve(Asp,b)
|
||||
|
||||
assert_(norm(b - Asp*x) < 10 * cond_A * eps)
|
||||
|
||||
def test_bvector_smoketest(self):
|
||||
Adense = matrix([[0., 1., 1.],
|
||||
[1., 0., 1.],
|
||||
[0., 0., 1.]])
|
||||
As = csc_matrix(Adense)
|
||||
random.seed(1234)
|
||||
x = random.randn(3)
|
||||
b = As*x
|
||||
x2 = spsolve(As, b)
|
||||
|
||||
assert_array_almost_equal(x, x2)
|
||||
|
||||
def test_bmatrix_smoketest(self):
|
||||
Adense = matrix([[0., 1., 1.],
|
||||
[1., 0., 1.],
|
||||
[0., 0., 1.]])
|
||||
As = csc_matrix(Adense)
|
||||
random.seed(1234)
|
||||
x = random.randn(3, 4)
|
||||
Bdense = As.dot(x)
|
||||
Bs = csc_matrix(Bdense)
|
||||
x2 = spsolve(As, Bs)
|
||||
assert_array_almost_equal(x, x2.todense())
|
||||
|
||||
@sup_sparse_efficiency
|
||||
def test_non_square(self):
|
||||
# A is not square.
|
||||
A = ones((3, 4))
|
||||
b = ones((4, 1))
|
||||
assert_raises(ValueError, spsolve, A, b)
|
||||
# A2 and b2 have incompatible shapes.
|
||||
A2 = csc_matrix(eye(3))
|
||||
b2 = array([1.0, 2.0])
|
||||
assert_raises(ValueError, spsolve, A2, b2)
|
||||
|
||||
@sup_sparse_efficiency
|
||||
def test_example_comparison(self):
|
||||
row = array([0,0,1,2,2,2])
|
||||
col = array([0,2,2,0,1,2])
|
||||
data = array([1,2,3,-4,5,6])
|
||||
sM = csr_matrix((data,(row,col)), shape=(3,3), dtype=float)
|
||||
M = sM.todense()
|
||||
|
||||
row = array([0,0,1,1,0,0])
|
||||
col = array([0,2,1,1,0,0])
|
||||
data = array([1,1,1,1,1,1])
|
||||
sN = csr_matrix((data, (row,col)), shape=(3,3), dtype=float)
|
||||
N = sN.todense()
|
||||
|
||||
sX = spsolve(sM, sN)
|
||||
X = scipy.linalg.solve(M, N)
|
||||
|
||||
assert_array_almost_equal(X, sX.todense())
|
||||
|
||||
@sup_sparse_efficiency
|
||||
@pytest.mark.skipif(not has_umfpack, reason="umfpack not available")
|
||||
def test_shape_compatibility(self):
|
||||
use_solver(useUmfpack=True)
|
||||
A = csc_matrix([[1., 0], [0, 2]])
|
||||
bs = [
|
||||
[1, 6],
|
||||
array([1, 6]),
|
||||
[[1], [6]],
|
||||
array([[1], [6]]),
|
||||
csc_matrix([[1], [6]]),
|
||||
csr_matrix([[1], [6]]),
|
||||
dok_matrix([[1], [6]]),
|
||||
bsr_matrix([[1], [6]]),
|
||||
array([[1., 2., 3.], [6., 8., 10.]]),
|
||||
csc_matrix([[1., 2., 3.], [6., 8., 10.]]),
|
||||
csr_matrix([[1., 2., 3.], [6., 8., 10.]]),
|
||||
dok_matrix([[1., 2., 3.], [6., 8., 10.]]),
|
||||
bsr_matrix([[1., 2., 3.], [6., 8., 10.]]),
|
||||
]
|
||||
|
||||
for b in bs:
|
||||
x = np.linalg.solve(A.toarray(), toarray(b))
|
||||
for spmattype in [csc_matrix, csr_matrix, dok_matrix, lil_matrix]:
|
||||
x1 = spsolve(spmattype(A), b, use_umfpack=True)
|
||||
x2 = spsolve(spmattype(A), b, use_umfpack=False)
|
||||
|
||||
# check solution
|
||||
if x.ndim == 2 and x.shape[1] == 1:
|
||||
# interprets also these as "vectors"
|
||||
x = x.ravel()
|
||||
|
||||
assert_array_almost_equal(toarray(x1), x, err_msg=repr((b, spmattype, 1)))
|
||||
assert_array_almost_equal(toarray(x2), x, err_msg=repr((b, spmattype, 2)))
|
||||
|
||||
# dense vs. sparse output ("vectors" are always dense)
|
||||
if isspmatrix(b) and x.ndim > 1:
|
||||
assert_(isspmatrix(x1), repr((b, spmattype, 1)))
|
||||
assert_(isspmatrix(x2), repr((b, spmattype, 2)))
|
||||
else:
|
||||
assert_(isinstance(x1, np.ndarray), repr((b, spmattype, 1)))
|
||||
assert_(isinstance(x2, np.ndarray), repr((b, spmattype, 2)))
|
||||
|
||||
# check output shape
|
||||
if x.ndim == 1:
|
||||
# "vector"
|
||||
assert_equal(x1.shape, (A.shape[1],))
|
||||
assert_equal(x2.shape, (A.shape[1],))
|
||||
else:
|
||||
# "matrix"
|
||||
assert_equal(x1.shape, x.shape)
|
||||
assert_equal(x2.shape, x.shape)
|
||||
|
||||
A = csc_matrix((3, 3))
|
||||
b = csc_matrix((1, 3))
|
||||
assert_raises(ValueError, spsolve, A, b)
|
||||
|
||||
@sup_sparse_efficiency
|
||||
def test_ndarray_support(self):
|
||||
A = array([[1., 2.], [2., 0.]])
|
||||
x = array([[1., 1.], [0.5, -0.5]])
|
||||
b = array([[2., 0.], [2., 2.]])
|
||||
|
||||
assert_array_almost_equal(x, spsolve(A, b))
|
||||
|
||||
def test_gssv_badinput(self):
|
||||
N = 10
|
||||
d = arange(N) + 1.0
|
||||
A = spdiags((d, 2*d, d[::-1]), (-3, 0, 5), N, N)
|
||||
|
||||
for spmatrix in (csc_matrix, csr_matrix):
|
||||
A = spmatrix(A)
|
||||
b = np.arange(N)
|
||||
|
||||
def not_c_contig(x):
|
||||
return x.repeat(2)[::2]
|
||||
|
||||
def not_1dim(x):
|
||||
return x[:,None]
|
||||
|
||||
def bad_type(x):
|
||||
return x.astype(bool)
|
||||
|
||||
def too_short(x):
|
||||
return x[:-1]
|
||||
|
||||
badops = [not_c_contig, not_1dim, bad_type, too_short]
|
||||
|
||||
for badop in badops:
|
||||
msg = "%r %r" % (spmatrix, badop)
|
||||
# Not C-contiguous
|
||||
assert_raises((ValueError, TypeError), _superlu.gssv,
|
||||
N, A.nnz, badop(A.data), A.indices, A.indptr,
|
||||
b, int(spmatrix == csc_matrix), err_msg=msg)
|
||||
assert_raises((ValueError, TypeError), _superlu.gssv,
|
||||
N, A.nnz, A.data, badop(A.indices), A.indptr,
|
||||
b, int(spmatrix == csc_matrix), err_msg=msg)
|
||||
assert_raises((ValueError, TypeError), _superlu.gssv,
|
||||
N, A.nnz, A.data, A.indices, badop(A.indptr),
|
||||
b, int(spmatrix == csc_matrix), err_msg=msg)
|
||||
|
||||
def test_sparsity_preservation(self):
|
||||
ident = csc_matrix([
|
||||
[1, 0, 0],
|
||||
[0, 1, 0],
|
||||
[0, 0, 1]])
|
||||
b = csc_matrix([
|
||||
[0, 1],
|
||||
[1, 0],
|
||||
[0, 0]])
|
||||
x = spsolve(ident, b)
|
||||
assert_equal(ident.nnz, 3)
|
||||
assert_equal(b.nnz, 2)
|
||||
assert_equal(x.nnz, 2)
|
||||
assert_allclose(x.A, b.A, atol=1e-12, rtol=1e-12)
|
||||
|
||||
def test_dtype_cast(self):
|
||||
A_real = scipy.sparse.csr_matrix([[1, 2, 0],
|
||||
[0, 0, 3],
|
||||
[4, 0, 5]])
|
||||
A_complex = scipy.sparse.csr_matrix([[1, 2, 0],
|
||||
[0, 0, 3],
|
||||
[4, 0, 5 + 1j]])
|
||||
b_real = np.array([1,1,1])
|
||||
b_complex = np.array([1,1,1]) + 1j*np.array([1,1,1])
|
||||
x = spsolve(A_real, b_real)
|
||||
assert_(np.issubdtype(x.dtype, np.floating))
|
||||
x = spsolve(A_real, b_complex)
|
||||
assert_(np.issubdtype(x.dtype, np.complexfloating))
|
||||
x = spsolve(A_complex, b_real)
|
||||
assert_(np.issubdtype(x.dtype, np.complexfloating))
|
||||
x = spsolve(A_complex, b_complex)
|
||||
assert_(np.issubdtype(x.dtype, np.complexfloating))
|
||||
|
||||
|
||||
class TestSplu(object):
|
||||
def setup_method(self):
|
||||
use_solver(useUmfpack=False)
|
||||
n = 40
|
||||
d = arange(n) + 1
|
||||
self.n = n
|
||||
self.A = spdiags((d, 2*d, d[::-1]), (-3, 0, 5), n, n)
|
||||
random.seed(1234)
|
||||
|
||||
def _smoketest(self, spxlu, check, dtype):
|
||||
if np.issubdtype(dtype, np.complexfloating):
|
||||
A = self.A + 1j*self.A.T
|
||||
else:
|
||||
A = self.A
|
||||
|
||||
A = A.astype(dtype)
|
||||
lu = spxlu(A)
|
||||
|
||||
rng = random.RandomState(1234)
|
||||
|
||||
# Input shapes
|
||||
for k in [None, 1, 2, self.n, self.n+2]:
|
||||
msg = "k=%r" % (k,)
|
||||
|
||||
if k is None:
|
||||
b = rng.rand(self.n)
|
||||
else:
|
||||
b = rng.rand(self.n, k)
|
||||
|
||||
if np.issubdtype(dtype, np.complexfloating):
|
||||
b = b + 1j*rng.rand(*b.shape)
|
||||
b = b.astype(dtype)
|
||||
|
||||
x = lu.solve(b)
|
||||
check(A, b, x, msg)
|
||||
|
||||
x = lu.solve(b, 'T')
|
||||
check(A.T, b, x, msg)
|
||||
|
||||
x = lu.solve(b, 'H')
|
||||
check(A.T.conj(), b, x, msg)
|
||||
|
||||
@sup_sparse_efficiency
|
||||
def test_splu_smoketest(self):
|
||||
self._internal_test_splu_smoketest()
|
||||
|
||||
def _internal_test_splu_smoketest(self):
|
||||
# Check that splu works at all
|
||||
def check(A, b, x, msg=""):
|
||||
eps = np.finfo(A.dtype).eps
|
||||
r = A * x
|
||||
assert_(abs(r - b).max() < 1e3*eps, msg)
|
||||
|
||||
self._smoketest(splu, check, np.float32)
|
||||
self._smoketest(splu, check, np.float64)
|
||||
self._smoketest(splu, check, np.complex64)
|
||||
self._smoketest(splu, check, np.complex128)
|
||||
|
||||
@sup_sparse_efficiency
|
||||
def test_spilu_smoketest(self):
|
||||
self._internal_test_spilu_smoketest()
|
||||
|
||||
def _internal_test_spilu_smoketest(self):
|
||||
errors = []
|
||||
|
||||
def check(A, b, x, msg=""):
|
||||
r = A * x
|
||||
err = abs(r - b).max()
|
||||
assert_(err < 1e-2, msg)
|
||||
if b.dtype in (np.float64, np.complex128):
|
||||
errors.append(err)
|
||||
|
||||
self._smoketest(spilu, check, np.float32)
|
||||
self._smoketest(spilu, check, np.float64)
|
||||
self._smoketest(spilu, check, np.complex64)
|
||||
self._smoketest(spilu, check, np.complex128)
|
||||
|
||||
assert_(max(errors) > 1e-5)
|
||||
|
||||
@sup_sparse_efficiency
|
||||
def test_spilu_drop_rule(self):
|
||||
# Test passing in the drop_rule argument to spilu.
|
||||
A = identity(2)
|
||||
|
||||
rules = [
|
||||
b'basic,area'.decode('ascii'), # unicode
|
||||
b'basic,area', # ascii
|
||||
[b'basic', b'area'.decode('ascii')]
|
||||
]
|
||||
for rule in rules:
|
||||
# Argument should be accepted
|
||||
assert_(isinstance(spilu(A, drop_rule=rule), SuperLU))
|
||||
|
||||
def test_splu_nnz0(self):
|
||||
A = csc_matrix((5,5), dtype='d')
|
||||
assert_raises(RuntimeError, splu, A)
|
||||
|
||||
def test_spilu_nnz0(self):
|
||||
A = csc_matrix((5,5), dtype='d')
|
||||
assert_raises(RuntimeError, spilu, A)
|
||||
|
||||
def test_splu_basic(self):
|
||||
# Test basic splu functionality.
|
||||
n = 30
|
||||
rng = random.RandomState(12)
|
||||
a = rng.rand(n, n)
|
||||
a[a < 0.95] = 0
|
||||
# First test with a singular matrix
|
||||
a[:, 0] = 0
|
||||
a_ = csc_matrix(a)
|
||||
# Matrix is exactly singular
|
||||
assert_raises(RuntimeError, splu, a_)
|
||||
|
||||
# Make a diagonal dominant, to make sure it is not singular
|
||||
a += 4*eye(n)
|
||||
a_ = csc_matrix(a)
|
||||
lu = splu(a_)
|
||||
b = ones(n)
|
||||
x = lu.solve(b)
|
||||
assert_almost_equal(dot(a, x), b)
|
||||
|
||||
def test_splu_perm(self):
|
||||
# Test the permutation vectors exposed by splu.
|
||||
n = 30
|
||||
a = random.random((n, n))
|
||||
a[a < 0.95] = 0
|
||||
# Make a diagonal dominant, to make sure it is not singular
|
||||
a += 4*eye(n)
|
||||
a_ = csc_matrix(a)
|
||||
lu = splu(a_)
|
||||
# Check that the permutation indices do belong to [0, n-1].
|
||||
for perm in (lu.perm_r, lu.perm_c):
|
||||
assert_(all(perm > -1))
|
||||
assert_(all(perm < n))
|
||||
assert_equal(len(unique(perm)), len(perm))
|
||||
|
||||
# Now make a symmetric, and test that the two permutation vectors are
|
||||
# the same
|
||||
# Note: a += a.T relies on undefined behavior.
|
||||
a = a + a.T
|
||||
a_ = csc_matrix(a)
|
||||
lu = splu(a_)
|
||||
assert_array_equal(lu.perm_r, lu.perm_c)
|
||||
|
||||
@pytest.mark.skipif(not hasattr(sys, 'getrefcount'), reason="no sys.getrefcount")
|
||||
def test_lu_refcount(self):
|
||||
# Test that we are keeping track of the reference count with splu.
|
||||
n = 30
|
||||
a = random.random((n, n))
|
||||
a[a < 0.95] = 0
|
||||
# Make a diagonal dominant, to make sure it is not singular
|
||||
a += 4*eye(n)
|
||||
a_ = csc_matrix(a)
|
||||
lu = splu(a_)
|
||||
|
||||
# And now test that we don't have a refcount bug
|
||||
rc = sys.getrefcount(lu)
|
||||
for attr in ('perm_r', 'perm_c'):
|
||||
perm = getattr(lu, attr)
|
||||
assert_equal(sys.getrefcount(lu), rc + 1)
|
||||
del perm
|
||||
assert_equal(sys.getrefcount(lu), rc)
|
||||
|
||||
def test_bad_inputs(self):
|
||||
A = self.A.tocsc()
|
||||
|
||||
assert_raises(ValueError, splu, A[:,:4])
|
||||
assert_raises(ValueError, spilu, A[:,:4])
|
||||
|
||||
for lu in [splu(A), spilu(A)]:
|
||||
b = random.rand(42)
|
||||
B = random.rand(42, 3)
|
||||
BB = random.rand(self.n, 3, 9)
|
||||
assert_raises(ValueError, lu.solve, b)
|
||||
assert_raises(ValueError, lu.solve, B)
|
||||
assert_raises(ValueError, lu.solve, BB)
|
||||
assert_raises(TypeError, lu.solve,
|
||||
b.astype(np.complex64))
|
||||
assert_raises(TypeError, lu.solve,
|
||||
b.astype(np.complex128))
|
||||
|
||||
@sup_sparse_efficiency
|
||||
def test_superlu_dlamch_i386_nan(self):
|
||||
# SuperLU 4.3 calls some functions returning floats without
|
||||
# declaring them. On i386@linux call convention, this fails to
|
||||
# clear floating point registers after call. As a result, NaN
|
||||
# can appear in the next floating point operation made.
|
||||
#
|
||||
# Here's a test case that triggered the issue.
|
||||
n = 8
|
||||
d = np.arange(n) + 1
|
||||
A = spdiags((d, 2*d, d[::-1]), (-3, 0, 5), n, n)
|
||||
A = A.astype(np.float32)
|
||||
spilu(A)
|
||||
A = A + 1j*A
|
||||
B = A.A
|
||||
assert_(not np.isnan(B).any())
|
||||
|
||||
@sup_sparse_efficiency
|
||||
def test_lu_attr(self):
|
||||
|
||||
def check(dtype, complex_2=False):
|
||||
A = self.A.astype(dtype)
|
||||
|
||||
if complex_2:
|
||||
A = A + 1j*A.T
|
||||
|
||||
n = A.shape[0]
|
||||
lu = splu(A)
|
||||
|
||||
# Check that the decomposition is as advertized
|
||||
|
||||
Pc = np.zeros((n, n))
|
||||
Pc[np.arange(n), lu.perm_c] = 1
|
||||
|
||||
Pr = np.zeros((n, n))
|
||||
Pr[lu.perm_r, np.arange(n)] = 1
|
||||
|
||||
Ad = A.toarray()
|
||||
lhs = Pr.dot(Ad).dot(Pc)
|
||||
rhs = (lu.L * lu.U).toarray()
|
||||
|
||||
eps = np.finfo(dtype).eps
|
||||
|
||||
assert_allclose(lhs, rhs, atol=100*eps)
|
||||
|
||||
check(np.float32)
|
||||
check(np.float64)
|
||||
check(np.complex64)
|
||||
check(np.complex128)
|
||||
check(np.complex64, True)
|
||||
check(np.complex128, True)
|
||||
|
||||
@pytest.mark.slow
|
||||
@sup_sparse_efficiency
|
||||
def test_threads_parallel(self):
|
||||
oks = []
|
||||
|
||||
def worker():
|
||||
try:
|
||||
self.test_splu_basic()
|
||||
self._internal_test_splu_smoketest()
|
||||
self._internal_test_spilu_smoketest()
|
||||
oks.append(True)
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
threads = [threading.Thread(target=worker)
|
||||
for k in range(20)]
|
||||
for t in threads:
|
||||
t.start()
|
||||
for t in threads:
|
||||
t.join()
|
||||
|
||||
assert_equal(len(oks), 20)
|
||||
|
||||
|
||||
class TestSpsolveTriangular(object):
|
||||
def setup_method(self):
|
||||
use_solver(useUmfpack=False)
|
||||
|
||||
def test_singular(self):
|
||||
n = 5
|
||||
A = csr_matrix((n, n))
|
||||
b = np.arange(n)
|
||||
for lower in (True, False):
|
||||
assert_raises(scipy.linalg.LinAlgError, spsolve_triangular, A, b, lower=lower)
|
||||
|
||||
@sup_sparse_efficiency
|
||||
def test_bad_shape(self):
|
||||
# A is not square.
|
||||
A = np.zeros((3, 4))
|
||||
b = ones((4, 1))
|
||||
assert_raises(ValueError, spsolve_triangular, A, b)
|
||||
# A2 and b2 have incompatible shapes.
|
||||
A2 = csr_matrix(eye(3))
|
||||
b2 = array([1.0, 2.0])
|
||||
assert_raises(ValueError, spsolve_triangular, A2, b2)
|
||||
|
||||
@sup_sparse_efficiency
|
||||
def test_input_types(self):
|
||||
A = array([[1., 0.], [1., 2.]])
|
||||
b = array([[2., 0.], [2., 2.]])
|
||||
for matrix_type in (array, csc_matrix, csr_matrix):
|
||||
x = spsolve_triangular(matrix_type(A), b, lower=True)
|
||||
assert_array_almost_equal(A.dot(x), b)
|
||||
|
||||
@pytest.mark.slow
|
||||
@sup_sparse_efficiency
|
||||
def test_random(self):
|
||||
def random_triangle_matrix(n, lower=True):
|
||||
A = scipy.sparse.random(n, n, density=0.1, format='coo')
|
||||
if lower:
|
||||
A = scipy.sparse.tril(A)
|
||||
else:
|
||||
A = scipy.sparse.triu(A)
|
||||
A = A.tocsr(copy=False)
|
||||
for i in range(n):
|
||||
A[i, i] = np.random.rand() + 1
|
||||
return A
|
||||
|
||||
np.random.seed(1234)
|
||||
for lower in (True, False):
|
||||
for n in (10, 10**2, 10**3):
|
||||
A = random_triangle_matrix(n, lower=lower)
|
||||
for m in (1, 10):
|
||||
for b in (np.random.rand(n, m),
|
||||
np.random.randint(-9, 9, (n, m)),
|
||||
np.random.randint(-9, 9, (n, m)) +
|
||||
np.random.randint(-9, 9, (n, m)) * 1j):
|
||||
x = spsolve_triangular(A, b, lower=lower)
|
||||
assert_array_almost_equal(A.dot(x), b)
|
||||
|
||||
@@ -0,0 +1,18 @@
|
||||
"""
|
||||
Sparse Eigenvalue Solvers
|
||||
-------------------------
|
||||
|
||||
The submodules of sparse.linalg.eigen:
|
||||
1. lobpcg: Locally Optimal Block Preconditioned Conjugate Gradient Method
|
||||
|
||||
"""
|
||||
from __future__ import division, print_function, absolute_import
|
||||
|
||||
from .arpack import *
|
||||
from .lobpcg import *
|
||||
|
||||
__all__ = [s for s in dir() if not s.startswith('_')]
|
||||
|
||||
from scipy._lib._testutils import PytestTester
|
||||
test = PytestTester(__name__)
|
||||
del PytestTester
|
||||
BIN
Binary file not shown.
BIN
Binary file not shown.
+45
@@ -0,0 +1,45 @@
|
||||
|
||||
BSD Software License
|
||||
|
||||
Pertains to ARPACK and P_ARPACK
|
||||
|
||||
Copyright (c) 1996-2008 Rice University.
|
||||
Developed by D.C. Sorensen, R.B. Lehoucq, C. Yang, and K. Maschhoff.
|
||||
All rights reserved.
|
||||
|
||||
Arpack has been renamed to arpack-ng.
|
||||
|
||||
Copyright (c) 2001-2011 - Scilab Enterprises
|
||||
Updated by Allan Cornet, Sylvestre Ledru.
|
||||
|
||||
Copyright (c) 2010 - Jordi Gutiérrez Hermoso (Octave patch)
|
||||
|
||||
Copyright (c) 2007 - Sébastien Fabbro (gentoo patch)
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are
|
||||
met:
|
||||
|
||||
- Redistributions of source code must retain the above copyright
|
||||
notice, this list of conditions and the following disclaimer.
|
||||
|
||||
- Redistributions in binary form must reproduce the above copyright
|
||||
notice, this list of conditions and the following disclaimer listed
|
||||
in this license in the documentation and/or other materials
|
||||
provided with the distribution.
|
||||
|
||||
- Neither the name of the copyright holders nor the names of its
|
||||
contributors may be used to endorse or promote products derived from
|
||||
this software without specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
@@ -0,0 +1,22 @@
|
||||
"""
|
||||
Eigenvalue solver using iterative methods.
|
||||
|
||||
Find k eigenvectors and eigenvalues of a matrix A using the
|
||||
Arnoldi/Lanczos iterative methods from ARPACK [1]_,[2]_.
|
||||
|
||||
These methods are most useful for large sparse matrices.
|
||||
|
||||
- eigs(A,k)
|
||||
- eigsh(A,k)
|
||||
|
||||
References
|
||||
----------
|
||||
.. [1] ARPACK Software, http://www.caam.rice.edu/software/ARPACK/
|
||||
.. [2] R. B. Lehoucq, D. C. Sorensen, and C. Yang, ARPACK USERS GUIDE:
|
||||
Solution of Large Scale Eigenvalue Problems by Implicitly Restarted
|
||||
Arnoldi Methods. SIAM, Philadelphia, PA, 1998.
|
||||
|
||||
"""
|
||||
from __future__ import division, print_function, absolute_import
|
||||
|
||||
from .arpack import *
|
||||
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,41 @@
|
||||
from __future__ import division, print_function, absolute_import
|
||||
|
||||
from os.path import join
|
||||
|
||||
|
||||
def configuration(parent_package='',top_path=None):
|
||||
from scipy._build_utils.system_info import get_info, NotFoundError
|
||||
from numpy.distutils.misc_util import Configuration
|
||||
from scipy._build_utils import get_g77_abi_wrappers
|
||||
|
||||
lapack_opt = get_info('lapack_opt')
|
||||
|
||||
config = Configuration('arpack', parent_package, top_path)
|
||||
|
||||
arpack_sources = [join('ARPACK','SRC', '*.f')]
|
||||
arpack_sources.extend([join('ARPACK','UTIL', '*.f')])
|
||||
|
||||
arpack_sources += get_g77_abi_wrappers(lapack_opt)
|
||||
|
||||
config.add_library('arpack_scipy', sources=arpack_sources,
|
||||
include_dirs=[join('ARPACK', 'SRC')])
|
||||
|
||||
ext_sources = ['arpack.pyf.src']
|
||||
config.add_extension('_arpack',
|
||||
sources=ext_sources,
|
||||
libraries=['arpack_scipy'],
|
||||
extra_info=lapack_opt,
|
||||
depends=arpack_sources,
|
||||
)
|
||||
|
||||
config.add_data_dir('tests')
|
||||
|
||||
# Add license files
|
||||
config.add_data_files('ARPACK/COPYING')
|
||||
|
||||
return config
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
from numpy.distutils.core import setup
|
||||
setup(**configuration(top_path='').todict())
|
||||
BIN
Binary file not shown.
BIN
Binary file not shown.
+965
@@ -0,0 +1,965 @@
|
||||
from __future__ import division, print_function, absolute_import
|
||||
|
||||
__usage__ = """
|
||||
To run tests locally:
|
||||
python tests/test_arpack.py [-l<int>] [-v<int>]
|
||||
|
||||
"""
|
||||
|
||||
import threading
|
||||
|
||||
import numpy as np
|
||||
|
||||
from numpy.testing import (assert_allclose, assert_array_almost_equal_nulp,
|
||||
assert_equal, assert_array_equal)
|
||||
from pytest import raises as assert_raises
|
||||
import pytest
|
||||
|
||||
from numpy import dot, conj, random
|
||||
from scipy.linalg import eig, eigh, hilbert, svd
|
||||
from scipy.sparse import csc_matrix, csr_matrix, isspmatrix, diags
|
||||
from scipy.sparse.linalg import LinearOperator, aslinearoperator
|
||||
from scipy.sparse.linalg.eigen.arpack import eigs, eigsh, svds, \
|
||||
ArpackNoConvergence, arpack
|
||||
|
||||
from scipy._lib._gcutils import assert_deallocated, IS_PYPY
|
||||
from scipy._lib._numpy_compat import suppress_warnings
|
||||
|
||||
|
||||
# precision for tests
|
||||
_ndigits = {'f': 3, 'd': 11, 'F': 3, 'D': 11}
|
||||
|
||||
|
||||
def _get_test_tolerance(type_char, mattype=None):
|
||||
"""
|
||||
Return tolerance values suitable for a given test:
|
||||
|
||||
Parameters
|
||||
----------
|
||||
type_char : {'f', 'd', 'F', 'D'}
|
||||
Data type in ARPACK eigenvalue problem
|
||||
mattype : {csr_matrix, aslinearoperator, asarray}, optional
|
||||
Linear operator type
|
||||
|
||||
Returns
|
||||
-------
|
||||
tol
|
||||
Tolerance to pass to the ARPACK routine
|
||||
rtol
|
||||
Relative tolerance for outputs
|
||||
atol
|
||||
Absolute tolerance for outputs
|
||||
|
||||
"""
|
||||
|
||||
rtol = {'f': 3000 * np.finfo(np.float32).eps,
|
||||
'F': 3000 * np.finfo(np.float32).eps,
|
||||
'd': 2000 * np.finfo(np.float64).eps,
|
||||
'D': 2000 * np.finfo(np.float64).eps}[type_char]
|
||||
atol = rtol
|
||||
tol = 0
|
||||
|
||||
if mattype is aslinearoperator and type_char in ('f', 'F'):
|
||||
# iterative methods in single precision: worse errors
|
||||
# also: bump ARPACK tolerance so that the iterative method converges
|
||||
tol = 30 * np.finfo(np.float32).eps
|
||||
rtol *= 5
|
||||
|
||||
if mattype is csr_matrix and type_char in ('f', 'F'):
|
||||
# sparse in single precision: worse errors
|
||||
rtol *= 5
|
||||
|
||||
return tol, rtol, atol
|
||||
|
||||
|
||||
def generate_matrix(N, complex=False, hermitian=False,
|
||||
pos_definite=False, sparse=False):
|
||||
M = np.random.random((N,N))
|
||||
if complex:
|
||||
M = M + 1j * np.random.random((N,N))
|
||||
|
||||
if hermitian:
|
||||
if pos_definite:
|
||||
if sparse:
|
||||
i = np.arange(N)
|
||||
j = np.random.randint(N, size=N-2)
|
||||
i, j = np.meshgrid(i, j)
|
||||
M[i,j] = 0
|
||||
M = np.dot(M.conj(), M.T)
|
||||
else:
|
||||
M = np.dot(M.conj(), M.T)
|
||||
if sparse:
|
||||
i = np.random.randint(N, size=N * N // 4)
|
||||
j = np.random.randint(N, size=N * N // 4)
|
||||
ind = np.nonzero(i == j)
|
||||
j[ind] = (j[ind] + 1) % N
|
||||
M[i,j] = 0
|
||||
M[j,i] = 0
|
||||
else:
|
||||
if sparse:
|
||||
i = np.random.randint(N, size=N * N // 2)
|
||||
j = np.random.randint(N, size=N * N // 2)
|
||||
M[i,j] = 0
|
||||
return M
|
||||
|
||||
|
||||
def generate_matrix_symmetric(N, pos_definite=False, sparse=False):
|
||||
M = np.random.random((N, N))
|
||||
|
||||
M = 0.5 * (M + M.T) # Make M symmetric
|
||||
|
||||
if pos_definite:
|
||||
Id = N * np.eye(N)
|
||||
if sparse:
|
||||
M = csr_matrix(M)
|
||||
M += Id
|
||||
else:
|
||||
if sparse:
|
||||
M = csr_matrix(M)
|
||||
|
||||
return M
|
||||
|
||||
|
||||
def _aslinearoperator_with_dtype(m):
|
||||
m = aslinearoperator(m)
|
||||
if not hasattr(m, 'dtype'):
|
||||
x = np.zeros(m.shape[1])
|
||||
m.dtype = (m * x).dtype
|
||||
return m
|
||||
|
||||
|
||||
def assert_allclose_cc(actual, desired, **kw):
|
||||
"""Almost equal or complex conjugates almost equal"""
|
||||
try:
|
||||
assert_allclose(actual, desired, **kw)
|
||||
except AssertionError:
|
||||
assert_allclose(actual, conj(desired), **kw)
|
||||
|
||||
|
||||
def argsort_which(eval, typ, k, which,
|
||||
sigma=None, OPpart=None, mode=None):
|
||||
"""Return sorted indices of eigenvalues using the "which" keyword
|
||||
from eigs and eigsh"""
|
||||
if sigma is None:
|
||||
reval = np.round(eval, decimals=_ndigits[typ])
|
||||
else:
|
||||
if mode is None or mode == 'normal':
|
||||
if OPpart is None:
|
||||
reval = 1. / (eval - sigma)
|
||||
elif OPpart == 'r':
|
||||
reval = 0.5 * (1. / (eval - sigma)
|
||||
+ 1. / (eval - np.conj(sigma)))
|
||||
elif OPpart == 'i':
|
||||
reval = -0.5j * (1. / (eval - sigma)
|
||||
- 1. / (eval - np.conj(sigma)))
|
||||
elif mode == 'cayley':
|
||||
reval = (eval + sigma) / (eval - sigma)
|
||||
elif mode == 'buckling':
|
||||
reval = eval / (eval - sigma)
|
||||
else:
|
||||
raise ValueError("mode='%s' not recognized" % mode)
|
||||
|
||||
reval = np.round(reval, decimals=_ndigits[typ])
|
||||
|
||||
if which in ['LM', 'SM']:
|
||||
ind = np.argsort(abs(reval))
|
||||
elif which in ['LR', 'SR', 'LA', 'SA', 'BE']:
|
||||
ind = np.argsort(np.real(reval))
|
||||
elif which in ['LI', 'SI']:
|
||||
# for LI,SI ARPACK returns largest,smallest abs(imaginary) why?
|
||||
if typ.islower():
|
||||
ind = np.argsort(abs(np.imag(reval)))
|
||||
else:
|
||||
ind = np.argsort(np.imag(reval))
|
||||
else:
|
||||
raise ValueError("which='%s' is unrecognized" % which)
|
||||
|
||||
if which in ['LM', 'LA', 'LR', 'LI']:
|
||||
return ind[-k:]
|
||||
elif which in ['SM', 'SA', 'SR', 'SI']:
|
||||
return ind[:k]
|
||||
elif which == 'BE':
|
||||
return np.concatenate((ind[:k//2], ind[k//2-k:]))
|
||||
|
||||
|
||||
def eval_evec(symmetric, d, typ, k, which, v0=None, sigma=None,
|
||||
mattype=np.asarray, OPpart=None, mode='normal'):
|
||||
general = ('bmat' in d)
|
||||
|
||||
if symmetric:
|
||||
eigs_func = eigsh
|
||||
else:
|
||||
eigs_func = eigs
|
||||
|
||||
if general:
|
||||
err = ("error for %s:general, typ=%s, which=%s, sigma=%s, "
|
||||
"mattype=%s, OPpart=%s, mode=%s" % (eigs_func.__name__,
|
||||
typ, which, sigma,
|
||||
mattype.__name__,
|
||||
OPpart, mode))
|
||||
else:
|
||||
err = ("error for %s:standard, typ=%s, which=%s, sigma=%s, "
|
||||
"mattype=%s, OPpart=%s, mode=%s" % (eigs_func.__name__,
|
||||
typ, which, sigma,
|
||||
mattype.__name__,
|
||||
OPpart, mode))
|
||||
|
||||
a = d['mat'].astype(typ)
|
||||
ac = mattype(a)
|
||||
|
||||
if general:
|
||||
b = d['bmat'].astype(typ.lower())
|
||||
bc = mattype(b)
|
||||
|
||||
# get exact eigenvalues
|
||||
exact_eval = d['eval'].astype(typ.upper())
|
||||
ind = argsort_which(exact_eval, typ, k, which,
|
||||
sigma, OPpart, mode)
|
||||
exact_eval = exact_eval[ind]
|
||||
|
||||
# compute arpack eigenvalues
|
||||
kwargs = dict(which=which, v0=v0, sigma=sigma)
|
||||
if eigs_func is eigsh:
|
||||
kwargs['mode'] = mode
|
||||
else:
|
||||
kwargs['OPpart'] = OPpart
|
||||
|
||||
# compute suitable tolerances
|
||||
kwargs['tol'], rtol, atol = _get_test_tolerance(typ, mattype)
|
||||
|
||||
# on rare occasions, ARPACK routines return results that are proper
|
||||
# eigenvalues and -vectors, but not necessarily the ones requested in
|
||||
# the parameter which. This is inherent to the Krylov methods, and
|
||||
# should not be treated as a failure. If such a rare situation
|
||||
# occurs, the calculation is tried again (but at most a few times).
|
||||
ntries = 0
|
||||
while ntries < 5:
|
||||
# solve
|
||||
if general:
|
||||
try:
|
||||
eval, evec = eigs_func(ac, k, bc, **kwargs)
|
||||
except ArpackNoConvergence:
|
||||
kwargs['maxiter'] = 20*a.shape[0]
|
||||
eval, evec = eigs_func(ac, k, bc, **kwargs)
|
||||
else:
|
||||
try:
|
||||
eval, evec = eigs_func(ac, k, **kwargs)
|
||||
except ArpackNoConvergence:
|
||||
kwargs['maxiter'] = 20*a.shape[0]
|
||||
eval, evec = eigs_func(ac, k, **kwargs)
|
||||
|
||||
ind = argsort_which(eval, typ, k, which,
|
||||
sigma, OPpart, mode)
|
||||
eval = eval[ind]
|
||||
evec = evec[:,ind]
|
||||
|
||||
# check eigenvectors
|
||||
LHS = np.dot(a, evec)
|
||||
if general:
|
||||
RHS = eval * np.dot(b, evec)
|
||||
else:
|
||||
RHS = eval * evec
|
||||
|
||||
assert_allclose(LHS, RHS, rtol=rtol, atol=atol, err_msg=err)
|
||||
|
||||
try:
|
||||
# check eigenvalues
|
||||
assert_allclose_cc(eval, exact_eval, rtol=rtol, atol=atol,
|
||||
err_msg=err)
|
||||
break
|
||||
except AssertionError:
|
||||
ntries += 1
|
||||
|
||||
# check eigenvalues
|
||||
assert_allclose_cc(eval, exact_eval, rtol=rtol, atol=atol, err_msg=err)
|
||||
|
||||
|
||||
class DictWithRepr(dict):
|
||||
def __init__(self, name):
|
||||
self.name = name
|
||||
|
||||
def __repr__(self):
|
||||
return "<%s>" % self.name
|
||||
|
||||
|
||||
class SymmetricParams:
|
||||
def __init__(self):
|
||||
self.eigs = eigsh
|
||||
self.which = ['LM', 'SM', 'LA', 'SA', 'BE']
|
||||
self.mattypes = [csr_matrix, aslinearoperator, np.asarray]
|
||||
self.sigmas_modes = {None: ['normal'],
|
||||
0.5: ['normal', 'buckling', 'cayley']}
|
||||
|
||||
# generate matrices
|
||||
# these should all be float32 so that the eigenvalues
|
||||
# are the same in float32 and float64
|
||||
N = 6
|
||||
np.random.seed(2300)
|
||||
Ar = generate_matrix(N, hermitian=True,
|
||||
pos_definite=True).astype('f').astype('d')
|
||||
M = generate_matrix(N, hermitian=True,
|
||||
pos_definite=True).astype('f').astype('d')
|
||||
Ac = generate_matrix(N, hermitian=True, pos_definite=True,
|
||||
complex=True).astype('F').astype('D')
|
||||
v0 = np.random.random(N)
|
||||
|
||||
# standard symmetric problem
|
||||
SS = DictWithRepr("std-symmetric")
|
||||
SS['mat'] = Ar
|
||||
SS['v0'] = v0
|
||||
SS['eval'] = eigh(SS['mat'], eigvals_only=True)
|
||||
|
||||
# general symmetric problem
|
||||
GS = DictWithRepr("gen-symmetric")
|
||||
GS['mat'] = Ar
|
||||
GS['bmat'] = M
|
||||
GS['v0'] = v0
|
||||
GS['eval'] = eigh(GS['mat'], GS['bmat'], eigvals_only=True)
|
||||
|
||||
# standard hermitian problem
|
||||
SH = DictWithRepr("std-hermitian")
|
||||
SH['mat'] = Ac
|
||||
SH['v0'] = v0
|
||||
SH['eval'] = eigh(SH['mat'], eigvals_only=True)
|
||||
|
||||
# general hermitian problem
|
||||
GH = DictWithRepr("gen-hermitian")
|
||||
GH['mat'] = Ac
|
||||
GH['bmat'] = M
|
||||
GH['v0'] = v0
|
||||
GH['eval'] = eigh(GH['mat'], GH['bmat'], eigvals_only=True)
|
||||
|
||||
self.real_test_cases = [SS, GS]
|
||||
self.complex_test_cases = [SH, GH]
|
||||
|
||||
|
||||
class NonSymmetricParams:
|
||||
def __init__(self):
|
||||
self.eigs = eigs
|
||||
self.which = ['LM', 'LR', 'LI'] # , 'SM', 'LR', 'SR', 'LI', 'SI']
|
||||
self.mattypes = [csr_matrix, aslinearoperator, np.asarray]
|
||||
self.sigmas_OPparts = {None: [None],
|
||||
0.1: ['r'],
|
||||
0.1 + 0.1j: ['r', 'i']}
|
||||
|
||||
# generate matrices
|
||||
# these should all be float32 so that the eigenvalues
|
||||
# are the same in float32 and float64
|
||||
N = 6
|
||||
np.random.seed(2300)
|
||||
Ar = generate_matrix(N).astype('f').astype('d')
|
||||
M = generate_matrix(N, hermitian=True,
|
||||
pos_definite=True).astype('f').astype('d')
|
||||
Ac = generate_matrix(N, complex=True).astype('F').astype('D')
|
||||
v0 = np.random.random(N)
|
||||
|
||||
# standard real nonsymmetric problem
|
||||
SNR = DictWithRepr("std-real-nonsym")
|
||||
SNR['mat'] = Ar
|
||||
SNR['v0'] = v0
|
||||
SNR['eval'] = eig(SNR['mat'], left=False, right=False)
|
||||
|
||||
# general real nonsymmetric problem
|
||||
GNR = DictWithRepr("gen-real-nonsym")
|
||||
GNR['mat'] = Ar
|
||||
GNR['bmat'] = M
|
||||
GNR['v0'] = v0
|
||||
GNR['eval'] = eig(GNR['mat'], GNR['bmat'], left=False, right=False)
|
||||
|
||||
# standard complex nonsymmetric problem
|
||||
SNC = DictWithRepr("std-cmplx-nonsym")
|
||||
SNC['mat'] = Ac
|
||||
SNC['v0'] = v0
|
||||
SNC['eval'] = eig(SNC['mat'], left=False, right=False)
|
||||
|
||||
# general complex nonsymmetric problem
|
||||
GNC = DictWithRepr("gen-cmplx-nonsym")
|
||||
GNC['mat'] = Ac
|
||||
GNC['bmat'] = M
|
||||
GNC['v0'] = v0
|
||||
GNC['eval'] = eig(GNC['mat'], GNC['bmat'], left=False, right=False)
|
||||
|
||||
self.real_test_cases = [SNR, GNR]
|
||||
self.complex_test_cases = [SNC, GNC]
|
||||
|
||||
|
||||
def test_symmetric_modes():
|
||||
params = SymmetricParams()
|
||||
k = 2
|
||||
symmetric = True
|
||||
for D in params.real_test_cases:
|
||||
for typ in 'fd':
|
||||
for which in params.which:
|
||||
for mattype in params.mattypes:
|
||||
for (sigma, modes) in params.sigmas_modes.items():
|
||||
for mode in modes:
|
||||
eval_evec(symmetric, D, typ, k, which,
|
||||
None, sigma, mattype, None, mode)
|
||||
|
||||
|
||||
def test_hermitian_modes():
|
||||
params = SymmetricParams()
|
||||
k = 2
|
||||
symmetric = True
|
||||
for D in params.complex_test_cases:
|
||||
for typ in 'FD':
|
||||
for which in params.which:
|
||||
if which == 'BE':
|
||||
continue # BE invalid for complex
|
||||
for mattype in params.mattypes:
|
||||
for sigma in params.sigmas_modes:
|
||||
eval_evec(symmetric, D, typ, k, which,
|
||||
None, sigma, mattype)
|
||||
|
||||
|
||||
def test_symmetric_starting_vector():
|
||||
params = SymmetricParams()
|
||||
symmetric = True
|
||||
for k in [1, 2, 3, 4, 5]:
|
||||
for D in params.real_test_cases:
|
||||
for typ in 'fd':
|
||||
v0 = random.rand(len(D['v0'])).astype(typ)
|
||||
eval_evec(symmetric, D, typ, k, 'LM', v0)
|
||||
|
||||
|
||||
def test_symmetric_no_convergence():
|
||||
np.random.seed(1234)
|
||||
m = generate_matrix(30, hermitian=True, pos_definite=True)
|
||||
tol, rtol, atol = _get_test_tolerance('d')
|
||||
try:
|
||||
w, v = eigsh(m, 4, which='LM', v0=m[:, 0], maxiter=5, tol=tol, ncv=9)
|
||||
raise AssertionError("Spurious no-error exit")
|
||||
except ArpackNoConvergence as err:
|
||||
k = len(err.eigenvalues)
|
||||
if k <= 0:
|
||||
raise AssertionError("Spurious no-eigenvalues-found case")
|
||||
w, v = err.eigenvalues, err.eigenvectors
|
||||
assert_allclose(dot(m, v), w * v, rtol=rtol, atol=atol)
|
||||
|
||||
|
||||
def test_real_nonsymmetric_modes():
|
||||
params = NonSymmetricParams()
|
||||
k = 2
|
||||
symmetric = False
|
||||
for D in params.real_test_cases:
|
||||
for typ in 'fd':
|
||||
for which in params.which:
|
||||
for mattype in params.mattypes:
|
||||
for sigma, OPparts in params.sigmas_OPparts.items():
|
||||
for OPpart in OPparts:
|
||||
eval_evec(symmetric, D, typ, k, which,
|
||||
None, sigma, mattype, OPpart)
|
||||
|
||||
|
||||
def test_complex_nonsymmetric_modes():
|
||||
params = NonSymmetricParams()
|
||||
k = 2
|
||||
symmetric = False
|
||||
for D in params.complex_test_cases:
|
||||
for typ in 'DF':
|
||||
for which in params.which:
|
||||
for mattype in params.mattypes:
|
||||
for sigma in params.sigmas_OPparts:
|
||||
eval_evec(symmetric, D, typ, k, which,
|
||||
None, sigma, mattype)
|
||||
|
||||
|
||||
def test_standard_nonsymmetric_starting_vector():
|
||||
params = NonSymmetricParams()
|
||||
sigma = None
|
||||
symmetric = False
|
||||
for k in [1, 2, 3, 4]:
|
||||
for d in params.complex_test_cases:
|
||||
for typ in 'FD':
|
||||
A = d['mat']
|
||||
n = A.shape[0]
|
||||
v0 = random.rand(n).astype(typ)
|
||||
eval_evec(symmetric, d, typ, k, "LM", v0, sigma)
|
||||
|
||||
|
||||
def test_general_nonsymmetric_starting_vector():
|
||||
params = NonSymmetricParams()
|
||||
sigma = None
|
||||
symmetric = False
|
||||
for k in [1, 2, 3, 4]:
|
||||
for d in params.complex_test_cases:
|
||||
for typ in 'FD':
|
||||
A = d['mat']
|
||||
n = A.shape[0]
|
||||
v0 = random.rand(n).astype(typ)
|
||||
eval_evec(symmetric, d, typ, k, "LM", v0, sigma)
|
||||
|
||||
|
||||
def test_standard_nonsymmetric_no_convergence():
|
||||
np.random.seed(1234)
|
||||
m = generate_matrix(30, complex=True)
|
||||
tol, rtol, atol = _get_test_tolerance('d')
|
||||
try:
|
||||
w, v = eigs(m, 4, which='LM', v0=m[:, 0], maxiter=5, tol=tol)
|
||||
raise AssertionError("Spurious no-error exit")
|
||||
except ArpackNoConvergence as err:
|
||||
k = len(err.eigenvalues)
|
||||
if k <= 0:
|
||||
raise AssertionError("Spurious no-eigenvalues-found case")
|
||||
w, v = err.eigenvalues, err.eigenvectors
|
||||
for ww, vv in zip(w, v.T):
|
||||
assert_allclose(dot(m, vv), ww * vv, rtol=rtol, atol=atol)
|
||||
|
||||
|
||||
def test_eigen_bad_shapes():
|
||||
# A is not square.
|
||||
A = csc_matrix(np.zeros((2, 3)))
|
||||
assert_raises(ValueError, eigs, A)
|
||||
|
||||
|
||||
def test_eigen_bad_kwargs():
|
||||
# Test eigen on wrong keyword argument
|
||||
A = csc_matrix(np.zeros((8, 8)))
|
||||
assert_raises(ValueError, eigs, A, which='XX')
|
||||
|
||||
|
||||
def test_ticket_1459_arpack_crash():
|
||||
for dtype in [np.float32, np.float64]:
|
||||
# XXX: this test does not seem to catch the issue for float32,
|
||||
# but we made the same fix there, just to be sure
|
||||
|
||||
N = 6
|
||||
k = 2
|
||||
|
||||
np.random.seed(2301)
|
||||
A = np.random.random((N, N)).astype(dtype)
|
||||
v0 = np.array([-0.71063568258907849895, -0.83185111795729227424,
|
||||
-0.34365925382227402451, 0.46122533684552280420,
|
||||
-0.58001341115969040629, -0.78844877570084292984e-01],
|
||||
dtype=dtype)
|
||||
|
||||
# Should not crash:
|
||||
evals, evecs = eigs(A, k, v0=v0)
|
||||
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
# sparse SVD tests
|
||||
|
||||
def sorted_svd(m, k, which='LM'):
|
||||
# Compute svd of a dense matrix m, and return singular vectors/values
|
||||
# sorted.
|
||||
if isspmatrix(m):
|
||||
m = m.todense()
|
||||
u, s, vh = svd(m)
|
||||
if which == 'LM':
|
||||
ii = np.argsort(s)[-k:]
|
||||
elif which == 'SM':
|
||||
ii = np.argsort(s)[:k]
|
||||
else:
|
||||
raise ValueError("unknown which=%r" % (which,))
|
||||
|
||||
return u[:, ii], s[ii], vh[ii]
|
||||
|
||||
|
||||
def svd_estimate(u, s, vh):
|
||||
return np.dot(u, np.dot(np.diag(s), vh))
|
||||
|
||||
|
||||
def svd_test_input_check():
|
||||
x = np.array([[1, 2, 3],
|
||||
[3, 4, 3],
|
||||
[1, 0, 2],
|
||||
[0, 0, 1]], float)
|
||||
|
||||
assert_raises(ValueError, svds, x, k=-1)
|
||||
assert_raises(ValueError, svds, x, k=0)
|
||||
assert_raises(ValueError, svds, x, k=10)
|
||||
assert_raises(ValueError, svds, x, k=x.shape[0])
|
||||
assert_raises(ValueError, svds, x, k=x.shape[1])
|
||||
assert_raises(ValueError, svds, x.T, k=x.shape[0])
|
||||
assert_raises(ValueError, svds, x.T, k=x.shape[1])
|
||||
|
||||
|
||||
def test_svd_simple_real():
|
||||
x = np.array([[1, 2, 3],
|
||||
[3, 4, 3],
|
||||
[1, 0, 2],
|
||||
[0, 0, 1]], float)
|
||||
y = np.array([[1, 2, 3, 8],
|
||||
[3, 4, 3, 5],
|
||||
[1, 0, 2, 3],
|
||||
[0, 0, 1, 0]], float)
|
||||
z = csc_matrix(x)
|
||||
|
||||
for m in [x.T, x, y, z, z.T]:
|
||||
for k in range(1, min(m.shape)):
|
||||
u, s, vh = sorted_svd(m, k)
|
||||
su, ss, svh = svds(m, k)
|
||||
|
||||
m_hat = svd_estimate(u, s, vh)
|
||||
sm_hat = svd_estimate(su, ss, svh)
|
||||
|
||||
assert_array_almost_equal_nulp(m_hat, sm_hat, nulp=1000)
|
||||
|
||||
|
||||
def test_svd_simple_complex():
|
||||
x = np.array([[1, 2, 3],
|
||||
[3, 4, 3],
|
||||
[1 + 1j, 0, 2],
|
||||
[0, 0, 1]], complex)
|
||||
y = np.array([[1, 2, 3, 8 + 5j],
|
||||
[3 - 2j, 4, 3, 5],
|
||||
[1, 0, 2, 3],
|
||||
[0, 0, 1, 0]], complex)
|
||||
z = csc_matrix(x)
|
||||
|
||||
for m in [x, x.T.conjugate(), x.T, y, y.conjugate(), z, z.T]:
|
||||
for k in range(1, min(m.shape) - 1):
|
||||
u, s, vh = sorted_svd(m, k)
|
||||
su, ss, svh = svds(m, k)
|
||||
|
||||
m_hat = svd_estimate(u, s, vh)
|
||||
sm_hat = svd_estimate(su, ss, svh)
|
||||
|
||||
assert_array_almost_equal_nulp(m_hat, sm_hat, nulp=1000)
|
||||
|
||||
|
||||
def test_svd_maxiter():
|
||||
# check that maxiter works as expected
|
||||
x = hilbert(6)
|
||||
# ARPACK shouldn't converge on such an ill-conditioned matrix with just
|
||||
# one iteration
|
||||
assert_raises(ArpackNoConvergence, svds, x, 1, maxiter=1, ncv=3)
|
||||
# but 100 iterations should be more than enough
|
||||
u, s, vt = svds(x, 1, maxiter=100, ncv=3)
|
||||
assert_allclose(s, [1.7], atol=0.5)
|
||||
|
||||
|
||||
def test_svd_return():
|
||||
# check that the return_singular_vectors parameter works as expected
|
||||
x = hilbert(6)
|
||||
_, s, _ = sorted_svd(x, 2)
|
||||
ss = svds(x, 2, return_singular_vectors=False)
|
||||
assert_allclose(s, ss)
|
||||
|
||||
|
||||
def test_svd_which():
|
||||
# check that the which parameter works as expected
|
||||
x = hilbert(6)
|
||||
for which in ['LM', 'SM']:
|
||||
_, s, _ = sorted_svd(x, 2, which=which)
|
||||
ss = svds(x, 2, which=which, return_singular_vectors=False)
|
||||
ss.sort()
|
||||
assert_allclose(s, ss, atol=np.sqrt(1e-15))
|
||||
|
||||
|
||||
def test_svd_v0():
|
||||
# check that the v0 parameter works as expected
|
||||
x = np.array([[1, 2, 3, 4], [5, 6, 7, 8]], float)
|
||||
|
||||
u, s, vh = svds(x, 1)
|
||||
u2, s2, vh2 = svds(x, 1, v0=u[:,0])
|
||||
|
||||
assert_allclose(s, s2, atol=np.sqrt(1e-15))
|
||||
|
||||
|
||||
def _check_svds(A, k, U, s, VH):
|
||||
n, m = A.shape
|
||||
|
||||
# Check shapes.
|
||||
assert_equal(U.shape, (n, k))
|
||||
assert_equal(s.shape, (k,))
|
||||
assert_equal(VH.shape, (k, m))
|
||||
|
||||
# Check that the original matrix can be reconstituted.
|
||||
A_rebuilt = (U*s).dot(VH)
|
||||
assert_equal(A_rebuilt.shape, A.shape)
|
||||
assert_allclose(A_rebuilt, A)
|
||||
|
||||
# Check that U is a semi-orthogonal matrix.
|
||||
UH_U = np.dot(U.T.conj(), U)
|
||||
assert_equal(UH_U.shape, (k, k))
|
||||
assert_allclose(UH_U, np.identity(k), atol=1e-12)
|
||||
|
||||
# Check that V is a semi-orthogonal matrix.
|
||||
VH_V = np.dot(VH, VH.T.conj())
|
||||
assert_equal(VH_V.shape, (k, k))
|
||||
assert_allclose(VH_V, np.identity(k), atol=1e-12)
|
||||
|
||||
|
||||
def test_svd_LM_ones_matrix():
|
||||
# Check that svds can deal with matrix_rank less than k in LM mode.
|
||||
k = 3
|
||||
for n, m in (6, 5), (5, 5), (5, 6):
|
||||
for t in float, complex:
|
||||
A = np.ones((n, m), dtype=t)
|
||||
U, s, VH = svds(A, k)
|
||||
|
||||
# Check some generic properties of svd.
|
||||
_check_svds(A, k, U, s, VH)
|
||||
|
||||
# Check that the largest singular value is near sqrt(n*m)
|
||||
# and the other singular values have been forced to zero.
|
||||
assert_allclose(np.max(s), np.sqrt(n*m))
|
||||
assert_array_equal(sorted(s)[:-1], 0)
|
||||
|
||||
|
||||
def test_svd_LM_zeros_matrix():
|
||||
# Check that svds can deal with matrices containing only zeros.
|
||||
k = 1
|
||||
for n, m in (3, 4), (4, 4), (4, 3):
|
||||
for t in float, complex:
|
||||
A = np.zeros((n, m), dtype=t)
|
||||
U, s, VH = svds(A, k)
|
||||
|
||||
# Check some generic properties of svd.
|
||||
_check_svds(A, k, U, s, VH)
|
||||
|
||||
# Check that the singular values are zero.
|
||||
assert_array_equal(s, 0)
|
||||
|
||||
|
||||
def test_svd_LM_zeros_matrix_gh_3452():
|
||||
# Regression test for a github issue.
|
||||
# https://github.com/scipy/scipy/issues/3452
|
||||
# Note that for complex dype the size of this matrix is too small for k=1.
|
||||
n, m, k = 4, 2, 1
|
||||
A = np.zeros((n, m))
|
||||
U, s, VH = svds(A, k)
|
||||
|
||||
# Check some generic properties of svd.
|
||||
_check_svds(A, k, U, s, VH)
|
||||
|
||||
# Check that the singular values are zero.
|
||||
assert_array_equal(s, 0)
|
||||
|
||||
|
||||
class CheckingLinearOperator(LinearOperator):
|
||||
def __init__(self, A):
|
||||
self.A = A
|
||||
self.dtype = A.dtype
|
||||
self.shape = A.shape
|
||||
|
||||
def _matvec(self, x):
|
||||
assert_equal(max(x.shape), np.size(x))
|
||||
return self.A.dot(x)
|
||||
|
||||
def _rmatvec(self, x):
|
||||
assert_equal(max(x.shape), np.size(x))
|
||||
return self.A.T.conjugate().dot(x)
|
||||
|
||||
|
||||
def test_svd_linop():
|
||||
nmks = [(6, 7, 3),
|
||||
(9, 5, 4),
|
||||
(10, 8, 5)]
|
||||
|
||||
def reorder(args):
|
||||
U, s, VH = args
|
||||
j = np.argsort(s)
|
||||
return U[:,j], s[j], VH[j,:]
|
||||
|
||||
for n, m, k in nmks:
|
||||
# Test svds on a LinearOperator.
|
||||
A = np.random.RandomState(52).randn(n, m)
|
||||
L = CheckingLinearOperator(A)
|
||||
|
||||
v0 = np.ones(min(A.shape))
|
||||
|
||||
U1, s1, VH1 = reorder(svds(A, k, v0=v0))
|
||||
U2, s2, VH2 = reorder(svds(L, k, v0=v0))
|
||||
|
||||
assert_allclose(np.abs(U1), np.abs(U2))
|
||||
assert_allclose(s1, s2)
|
||||
assert_allclose(np.abs(VH1), np.abs(VH2))
|
||||
assert_allclose(np.dot(U1, np.dot(np.diag(s1), VH1)),
|
||||
np.dot(U2, np.dot(np.diag(s2), VH2)))
|
||||
|
||||
# Try again with which="SM".
|
||||
A = np.random.RandomState(1909).randn(n, m)
|
||||
L = CheckingLinearOperator(A)
|
||||
|
||||
U1, s1, VH1 = reorder(svds(A, k, which="SM"))
|
||||
U2, s2, VH2 = reorder(svds(L, k, which="SM"))
|
||||
|
||||
assert_allclose(np.abs(U1), np.abs(U2))
|
||||
assert_allclose(s1, s2)
|
||||
assert_allclose(np.abs(VH1), np.abs(VH2))
|
||||
assert_allclose(np.dot(U1, np.dot(np.diag(s1), VH1)),
|
||||
np.dot(U2, np.dot(np.diag(s2), VH2)))
|
||||
|
||||
if k < min(n, m) - 1:
|
||||
# Complex input and explicit which="LM".
|
||||
for (dt, eps) in [(complex, 1e-7), (np.complex64, 1e-3)]:
|
||||
rng = np.random.RandomState(1648)
|
||||
A = (rng.randn(n, m) + 1j * rng.randn(n, m)).astype(dt)
|
||||
L = CheckingLinearOperator(A)
|
||||
|
||||
U1, s1, VH1 = reorder(svds(A, k, which="LM"))
|
||||
U2, s2, VH2 = reorder(svds(L, k, which="LM"))
|
||||
|
||||
assert_allclose(np.abs(U1), np.abs(U2), rtol=eps)
|
||||
assert_allclose(s1, s2, rtol=eps)
|
||||
assert_allclose(np.abs(VH1), np.abs(VH2), rtol=eps)
|
||||
assert_allclose(np.dot(U1, np.dot(np.diag(s1), VH1)),
|
||||
np.dot(U2, np.dot(np.diag(s2), VH2)), rtol=eps)
|
||||
|
||||
|
||||
@pytest.mark.skipif(IS_PYPY, reason="Test not meaningful on PyPy")
|
||||
def test_linearoperator_deallocation():
|
||||
# Check that the linear operators used by the Arpack wrappers are
|
||||
# deallocatable by reference counting -- they are big objects, so
|
||||
# Python's cyclic GC may not collect them fast enough before
|
||||
# running out of memory if eigs/eigsh are called in a tight loop.
|
||||
|
||||
M_d = np.eye(10)
|
||||
M_s = csc_matrix(M_d)
|
||||
M_o = aslinearoperator(M_d)
|
||||
|
||||
with assert_deallocated(lambda: arpack.SpLuInv(M_s)):
|
||||
pass
|
||||
with assert_deallocated(lambda: arpack.LuInv(M_d)):
|
||||
pass
|
||||
with assert_deallocated(lambda: arpack.IterInv(M_s)):
|
||||
pass
|
||||
with assert_deallocated(lambda: arpack.IterOpInv(M_o, None, 0.3)):
|
||||
pass
|
||||
with assert_deallocated(lambda: arpack.IterOpInv(M_o, M_o, 0.3)):
|
||||
pass
|
||||
|
||||
|
||||
def test_svds_partial_return():
|
||||
x = np.array([[1, 2, 3],
|
||||
[3, 4, 3],
|
||||
[1, 0, 2],
|
||||
[0, 0, 1]], float)
|
||||
# test vertical matrix
|
||||
z = csr_matrix(x)
|
||||
vh_full = svds(z, 2)[-1]
|
||||
vh_partial = svds(z, 2, return_singular_vectors='vh')[-1]
|
||||
dvh = np.linalg.norm(np.abs(vh_full) - np.abs(vh_partial))
|
||||
if dvh > 1e-10:
|
||||
raise AssertionError('right eigenvector matrices differ when using return_singular_vectors parameter')
|
||||
if svds(z, 2, return_singular_vectors='vh')[0] is not None:
|
||||
raise AssertionError('left eigenvector matrix was computed when it should not have been')
|
||||
# test horizontal matrix
|
||||
z = csr_matrix(x.T)
|
||||
u_full = svds(z, 2)[0]
|
||||
u_partial = svds(z, 2, return_singular_vectors='vh')[0]
|
||||
du = np.linalg.norm(np.abs(u_full) - np.abs(u_partial))
|
||||
if du > 1e-10:
|
||||
raise AssertionError('left eigenvector matrices differ when using return_singular_vectors parameter')
|
||||
if svds(z, 2, return_singular_vectors='u')[-1] is not None:
|
||||
raise AssertionError('right eigenvector matrix was computed when it should not have been')
|
||||
|
||||
def test_svds_wrong_eigen_type():
|
||||
# Regression test for a github issue.
|
||||
# https://github.com/scipy/scipy/issues/4590
|
||||
# Function was not checking for eigenvalue type and unintended
|
||||
# values could be returned.
|
||||
x = np.array([[1, 2, 3],
|
||||
[3, 4, 3],
|
||||
[1, 0, 2],
|
||||
[0, 0, 1]], float)
|
||||
assert_raises(ValueError, svds, x, 1, which='LA')
|
||||
|
||||
|
||||
def test_parallel_threads():
|
||||
results = []
|
||||
v0 = np.random.rand(50)
|
||||
|
||||
def worker():
|
||||
x = diags([1, -2, 1], [-1, 0, 1], shape=(50, 50))
|
||||
w, v = eigs(x, k=3, v0=v0)
|
||||
results.append(w)
|
||||
|
||||
w, v = eigsh(x, k=3, v0=v0)
|
||||
results.append(w)
|
||||
|
||||
threads = [threading.Thread(target=worker) for k in range(10)]
|
||||
for t in threads:
|
||||
t.start()
|
||||
for t in threads:
|
||||
t.join()
|
||||
|
||||
worker()
|
||||
|
||||
for r in results:
|
||||
assert_allclose(r, results[-1])
|
||||
|
||||
|
||||
def test_reentering():
|
||||
# Just some linear operator that calls eigs recursively
|
||||
def A_matvec(x):
|
||||
x = diags([1, -2, 1], [-1, 0, 1], shape=(50, 50))
|
||||
w, v = eigs(x, k=1)
|
||||
return v / w[0]
|
||||
A = LinearOperator(matvec=A_matvec, dtype=float, shape=(50, 50))
|
||||
|
||||
# The Fortran code is not reentrant, so this fails (gracefully, not crashing)
|
||||
assert_raises(RuntimeError, eigs, A, k=1)
|
||||
assert_raises(RuntimeError, eigsh, A, k=1)
|
||||
|
||||
|
||||
def test_regression_arpackng_1315():
|
||||
# Check that issue arpack-ng/#1315 is not present.
|
||||
# Adapted from arpack-ng/TESTS/bug_1315_single.c
|
||||
# If this fails, then the installed ARPACK library is faulty.
|
||||
|
||||
for dtype in [np.float32, np.float64]:
|
||||
np.random.seed(1234)
|
||||
|
||||
w0 = np.arange(1, 1000+1).astype(dtype)
|
||||
A = diags([w0], [0], shape=(1000, 1000))
|
||||
|
||||
v0 = np.random.rand(1000).astype(dtype)
|
||||
w, v = eigs(A, k=9, ncv=2*9+1, which="LM", v0=v0)
|
||||
|
||||
assert_allclose(np.sort(w), np.sort(w0[-9:]),
|
||||
rtol=1e-4)
|
||||
|
||||
|
||||
def test_eigs_for_k_greater():
|
||||
# Test eigs() for k beyond limits.
|
||||
A_sparse = diags([1, -2, 1], [-1, 0, 1], shape=(4, 4)) # sparse
|
||||
A = generate_matrix(4, sparse=False)
|
||||
M_dense = np.random.random((4, 4))
|
||||
M_sparse = generate_matrix(4, sparse=True)
|
||||
M_linop = aslinearoperator(M_dense)
|
||||
eig_tuple1 = eig(A, b=M_dense)
|
||||
eig_tuple2 = eig(A, b=M_sparse)
|
||||
|
||||
with suppress_warnings() as sup:
|
||||
sup.filter(RuntimeWarning)
|
||||
|
||||
assert_equal(eigs(A, M=M_dense, k=3), eig_tuple1)
|
||||
assert_equal(eigs(A, M=M_dense, k=4), eig_tuple1)
|
||||
assert_equal(eigs(A, M=M_dense, k=5), eig_tuple1)
|
||||
assert_equal(eigs(A, M=M_sparse, k=5), eig_tuple2)
|
||||
|
||||
# M as LinearOperator
|
||||
assert_raises(TypeError, eigs, A, M=M_linop, k=3)
|
||||
|
||||
# Test 'A' for different types
|
||||
assert_raises(TypeError, eigs, aslinearoperator(A), k=3)
|
||||
assert_raises(TypeError, eigs, A_sparse, k=3)
|
||||
|
||||
|
||||
def test_eigsh_for_k_greater():
|
||||
# Test eigsh() for k beyond limits.
|
||||
A_sparse = diags([1, -2, 1], [-1, 0, 1], shape=(4, 4)) # sparse
|
||||
A = generate_matrix(4, sparse=False)
|
||||
M_dense = generate_matrix_symmetric(4, pos_definite=True)
|
||||
M_sparse = generate_matrix_symmetric(4, pos_definite=True, sparse=True)
|
||||
M_linop = aslinearoperator(M_dense)
|
||||
eig_tuple1 = eigh(A, b=M_dense)
|
||||
eig_tuple2 = eigh(A, b=M_sparse)
|
||||
|
||||
with suppress_warnings() as sup:
|
||||
sup.filter(RuntimeWarning)
|
||||
|
||||
assert_equal(eigsh(A, M=M_dense, k=4), eig_tuple1)
|
||||
assert_equal(eigsh(A, M=M_dense, k=5), eig_tuple1)
|
||||
assert_equal(eigsh(A, M=M_sparse, k=5), eig_tuple2)
|
||||
|
||||
# M as LinearOperator
|
||||
assert_raises(TypeError, eigsh, A, M=M_linop, k=4)
|
||||
|
||||
# Test 'A' for different types
|
||||
assert_raises(TypeError, eigsh, aslinearoperator(A), k=4)
|
||||
assert_raises(TypeError, eigsh, A_sparse, M=M_dense, k=4)
|
||||
@@ -0,0 +1,18 @@
|
||||
"""
|
||||
Locally Optimal Block Preconditioned Conjugate Gradient Method (LOBPCG)
|
||||
|
||||
LOBPCG is a preconditioned eigensolver for large symmetric positive definite
|
||||
(SPD) generalized eigenproblems.
|
||||
|
||||
Call the function lobpcg - see help for lobpcg.lobpcg.
|
||||
|
||||
"""
|
||||
from __future__ import division, print_function, absolute_import
|
||||
|
||||
from .lobpcg import *
|
||||
|
||||
__all__ = [s for s in dir() if not s.startswith('_')]
|
||||
|
||||
from scipy._lib._testutils import PytestTester
|
||||
test = PytestTester(__name__)
|
||||
del PytestTester
|
||||
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
@@ -0,0 +1,582 @@
|
||||
"""
|
||||
Pure SciPy implementation of Locally Optimal Block Preconditioned Conjugate
|
||||
Gradient Method (LOBPCG), see
|
||||
https://bitbucket.org/joseroman/blopex
|
||||
|
||||
License: BSD
|
||||
|
||||
Authors: Robert Cimrman, Andrew Knyazev
|
||||
|
||||
Examples in tests directory contributed by Nils Wagner.
|
||||
"""
|
||||
|
||||
from __future__ import division, print_function, absolute_import
|
||||
import numpy as np
|
||||
from numpy.testing import assert_allclose
|
||||
from scipy._lib.six import xrange
|
||||
from scipy.linalg import inv, eigh, cho_factor, cho_solve, cholesky
|
||||
from scipy.sparse.linalg import aslinearoperator, LinearOperator
|
||||
|
||||
__all__ = ['lobpcg']
|
||||
|
||||
|
||||
def save(ar, fileName):
|
||||
# Used only when verbosity level > 10.
|
||||
from numpy import savetxt
|
||||
savetxt(fileName, ar)
|
||||
|
||||
|
||||
def _report_nonhermitian(M, a, b, name):
|
||||
"""
|
||||
Report if `M` is not a hermitian matrix given the tolerances `a`, `b`.
|
||||
"""
|
||||
from scipy.linalg import norm
|
||||
|
||||
md = M - M.T.conj()
|
||||
|
||||
nmd = norm(md, 1)
|
||||
tol = np.spacing(max(10**a, (10**b)*norm(M, 1)))
|
||||
if nmd > tol:
|
||||
print('matrix %s is not sufficiently Hermitian for a=%d, b=%d:'
|
||||
% (name, a, b))
|
||||
print('condition: %.e < %e' % (nmd, tol))
|
||||
|
||||
##
|
||||
# 21.05.2007, c
|
||||
|
||||
|
||||
def as2d(ar):
|
||||
"""
|
||||
If the input array is 2D return it, if it is 1D, append a dimension,
|
||||
making it a column vector.
|
||||
"""
|
||||
if ar.ndim == 2:
|
||||
return ar
|
||||
else: # Assume 1!
|
||||
aux = np.array(ar, copy=False)
|
||||
aux.shape = (ar.shape[0], 1)
|
||||
return aux
|
||||
|
||||
|
||||
def _makeOperator(operatorInput, expectedShape):
|
||||
"""Takes a dense numpy array or a sparse matrix or
|
||||
a function and makes an operator performing matrix * blockvector
|
||||
products.
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> A = _makeOperator( arrayA, (n, n) )
|
||||
>>> vectorB = A( vectorX )
|
||||
|
||||
"""
|
||||
if operatorInput is None:
|
||||
def ident(x):
|
||||
return x
|
||||
operator = LinearOperator(expectedShape, ident, matmat=ident)
|
||||
else:
|
||||
operator = aslinearoperator(operatorInput)
|
||||
|
||||
if operator.shape != expectedShape:
|
||||
raise ValueError('operator has invalid shape')
|
||||
|
||||
return operator
|
||||
|
||||
|
||||
def _applyConstraints(blockVectorV, factYBY, blockVectorBY, blockVectorY):
|
||||
"""Changes blockVectorV in place."""
|
||||
gramYBV = np.dot(blockVectorBY.T.conj(), blockVectorV)
|
||||
tmp = cho_solve(factYBY, gramYBV)
|
||||
blockVectorV -= np.dot(blockVectorY, tmp)
|
||||
|
||||
|
||||
def _b_orthonormalize(B, blockVectorV, blockVectorBV=None, retInvR=False):
|
||||
if blockVectorBV is None:
|
||||
if B is not None:
|
||||
blockVectorBV = B(blockVectorV)
|
||||
else:
|
||||
blockVectorBV = blockVectorV # Shared data!!!
|
||||
gramVBV = np.dot(blockVectorV.T.conj(), blockVectorBV)
|
||||
gramVBV = cholesky(gramVBV)
|
||||
gramVBV = inv(gramVBV, overwrite_a=True)
|
||||
# gramVBV is now R^{-1}.
|
||||
blockVectorV = np.dot(blockVectorV, gramVBV)
|
||||
if B is not None:
|
||||
blockVectorBV = np.dot(blockVectorBV, gramVBV)
|
||||
|
||||
if retInvR:
|
||||
return blockVectorV, blockVectorBV, gramVBV
|
||||
else:
|
||||
return blockVectorV, blockVectorBV
|
||||
|
||||
def _get_indx(_lambda, num, largest):
|
||||
"""Get `num` indices into `_lambda` depending on `largest` option."""
|
||||
ii = np.argsort(_lambda)
|
||||
if largest:
|
||||
ii = ii[:-num-1:-1]
|
||||
else:
|
||||
ii = ii[:num]
|
||||
|
||||
return ii
|
||||
|
||||
def lobpcg(A, X,
|
||||
B=None, M=None, Y=None,
|
||||
tol=None, maxiter=20,
|
||||
largest=True, verbosityLevel=0,
|
||||
retLambdaHistory=False, retResidualNormsHistory=False):
|
||||
"""Locally Optimal Block Preconditioned Conjugate Gradient Method (LOBPCG)
|
||||
|
||||
LOBPCG is a preconditioned eigensolver for large symmetric positive
|
||||
definite (SPD) generalized eigenproblems.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
A : {sparse matrix, dense matrix, LinearOperator}
|
||||
The symmetric linear operator of the problem, usually a
|
||||
sparse matrix. Often called the "stiffness matrix".
|
||||
X : array_like
|
||||
Initial approximation to the k eigenvectors. If A has
|
||||
shape=(n,n) then X should have shape shape=(n,k).
|
||||
B : {dense matrix, sparse matrix, LinearOperator}, optional
|
||||
the right hand side operator in a generalized eigenproblem.
|
||||
by default, B = Identity
|
||||
often called the "mass matrix"
|
||||
M : {dense matrix, sparse matrix, LinearOperator}, optional
|
||||
preconditioner to A; by default M = Identity
|
||||
M should approximate the inverse of A
|
||||
Y : array_like, optional
|
||||
n-by-sizeY matrix of constraints, sizeY < n
|
||||
The iterations will be performed in the B-orthogonal complement
|
||||
of the column-space of Y. Y must be full rank.
|
||||
|
||||
Returns
|
||||
-------
|
||||
w : array
|
||||
Array of k eigenvalues
|
||||
v : array
|
||||
An array of k eigenvectors. V has the same shape as X.
|
||||
|
||||
Other Parameters
|
||||
----------------
|
||||
tol : scalar, optional
|
||||
Solver tolerance (stopping criterion)
|
||||
by default: tol=n*sqrt(eps)
|
||||
maxiter : integer, optional
|
||||
maximum number of iterations
|
||||
by default: maxiter=min(n,20)
|
||||
largest : bool, optional
|
||||
when True, solve for the largest eigenvalues, otherwise the smallest
|
||||
verbosityLevel : integer, optional
|
||||
controls solver output. default: verbosityLevel = 0.
|
||||
retLambdaHistory : boolean, optional
|
||||
whether to return eigenvalue history
|
||||
retResidualNormsHistory : boolean, optional
|
||||
whether to return history of residual norms
|
||||
|
||||
Examples
|
||||
--------
|
||||
|
||||
Solve A x = lambda B x with constraints and preconditioning.
|
||||
|
||||
>>> from scipy.sparse import spdiags, issparse
|
||||
>>> from scipy.sparse.linalg import lobpcg, LinearOperator
|
||||
>>> n = 100
|
||||
>>> vals = [np.arange(n, dtype=np.float64) + 1]
|
||||
>>> A = spdiags(vals, 0, n, n)
|
||||
>>> A.toarray()
|
||||
array([[ 1., 0., 0., ..., 0., 0., 0.],
|
||||
[ 0., 2., 0., ..., 0., 0., 0.],
|
||||
[ 0., 0., 3., ..., 0., 0., 0.],
|
||||
...,
|
||||
[ 0., 0., 0., ..., 98., 0., 0.],
|
||||
[ 0., 0., 0., ..., 0., 99., 0.],
|
||||
[ 0., 0., 0., ..., 0., 0., 100.]])
|
||||
|
||||
Constraints.
|
||||
|
||||
>>> Y = np.eye(n, 3)
|
||||
|
||||
Initial guess for eigenvectors, should have linearly independent
|
||||
columns. Column dimension = number of requested eigenvalues.
|
||||
|
||||
>>> X = np.random.rand(n, 3)
|
||||
|
||||
Preconditioner -- inverse of A (as an abstract linear operator).
|
||||
|
||||
>>> invA = spdiags([1./vals[0]], 0, n, n)
|
||||
>>> def precond( x ):
|
||||
... return invA * x
|
||||
>>> M = LinearOperator(matvec=precond, shape=(n, n), dtype=float)
|
||||
|
||||
Here, ``invA`` could of course have been used directly as a preconditioner.
|
||||
Let us then solve the problem:
|
||||
|
||||
>>> eigs, vecs = lobpcg(A, X, Y=Y, M=M, tol=1e-4, maxiter=40, largest=False)
|
||||
>>> eigs
|
||||
array([ 4., 5., 6.])
|
||||
|
||||
Note that the vectors passed in Y are the eigenvectors of the 3 smallest
|
||||
eigenvalues. The results returned are orthogonal to those.
|
||||
|
||||
Notes
|
||||
-----
|
||||
If both retLambdaHistory and retResidualNormsHistory are True,
|
||||
the return tuple has the following format
|
||||
(lambda, V, lambda history, residual norms history).
|
||||
|
||||
In the following ``n`` denotes the matrix size and ``m`` the number
|
||||
of required eigenvalues (smallest or largest).
|
||||
|
||||
The LOBPCG code internally solves eigenproblems of the size 3``m`` on every
|
||||
iteration by calling the "standard" dense eigensolver, so if ``m`` is not
|
||||
small enough compared to ``n``, it does not make sense to call the LOBPCG
|
||||
code, but rather one should use the "standard" eigensolver,
|
||||
e.g. numpy or scipy function in this case.
|
||||
If one calls the LOBPCG algorithm for 5``m``>``n``,
|
||||
it will most likely break internally, so the code tries to call the standard
|
||||
function instead.
|
||||
|
||||
It is not that n should be large for the LOBPCG to work, but rather the
|
||||
ratio ``n``/``m`` should be large. It you call the LOBPCG code with ``m``=1
|
||||
and ``n``=10, it should work, though ``n`` is small. The method is intended
|
||||
for extremely large ``n``/``m``, see e.g., reference [28] in
|
||||
https://arxiv.org/abs/0705.2626
|
||||
|
||||
The convergence speed depends basically on two factors:
|
||||
|
||||
1. How well relatively separated the seeking eigenvalues are
|
||||
from the rest of the eigenvalues.
|
||||
One can try to vary ``m`` to make this better.
|
||||
|
||||
2. How well conditioned the problem is. This can be changed by using proper
|
||||
preconditioning. For example, a rod vibration test problem (under tests
|
||||
directory) is ill-conditioned for large ``n``, so convergence will be
|
||||
slow, unless efficient preconditioning is used.
|
||||
For this specific problem, a good simple preconditioner function would
|
||||
be a linear solve for A, which is easy to code since A is tridiagonal.
|
||||
|
||||
*Acknowledgements*
|
||||
|
||||
lobpcg.py code was written by Robert Cimrman.
|
||||
Many thanks belong to Andrew Knyazev, the author of the algorithm,
|
||||
for lots of advice and support.
|
||||
|
||||
References
|
||||
----------
|
||||
.. [1] A. V. Knyazev (2001),
|
||||
Toward the Optimal Preconditioned Eigensolver: Locally Optimal
|
||||
Block Preconditioned Conjugate Gradient Method.
|
||||
SIAM Journal on Scientific Computing 23, no. 2,
|
||||
pp. 517-541. :doi:`10.1137/S1064827500366124`
|
||||
|
||||
.. [2] A. V. Knyazev, I. Lashuk, M. E. Argentati, and E. Ovchinnikov (2007),
|
||||
Block Locally Optimal Preconditioned Eigenvalue Xolvers (BLOPEX)
|
||||
in hypre and PETSc. https://arxiv.org/abs/0705.2626
|
||||
|
||||
.. [3] A. V. Knyazev's C and MATLAB implementations:
|
||||
https://bitbucket.org/joseroman/blopex
|
||||
|
||||
"""
|
||||
blockVectorX = X
|
||||
blockVectorY = Y
|
||||
residualTolerance = tol
|
||||
maxIterations = maxiter
|
||||
|
||||
if blockVectorY is not None:
|
||||
sizeY = blockVectorY.shape[1]
|
||||
else:
|
||||
sizeY = 0
|
||||
|
||||
# Block size.
|
||||
if len(blockVectorX.shape) != 2:
|
||||
raise ValueError('expected rank-2 array for argument X')
|
||||
|
||||
n, sizeX = blockVectorX.shape
|
||||
if sizeX > n:
|
||||
raise ValueError('X column dimension exceeds the row dimension')
|
||||
|
||||
A = _makeOperator(A, (n,n))
|
||||
B = _makeOperator(B, (n,n))
|
||||
M = _makeOperator(M, (n,n))
|
||||
|
||||
if (n - sizeY) < (5 * sizeX):
|
||||
# warn('The problem size is small compared to the block size.' \
|
||||
# ' Using dense eigensolver instead of LOBPCG.')
|
||||
|
||||
if blockVectorY is not None:
|
||||
raise NotImplementedError('The dense eigensolver '
|
||||
'does not support constraints.')
|
||||
|
||||
# Define the closed range of indices of eigenvalues to return.
|
||||
if largest:
|
||||
eigvals = (n - sizeX, n-1)
|
||||
else:
|
||||
eigvals = (0, sizeX-1)
|
||||
|
||||
A_dense = A(np.eye(n))
|
||||
B_dense = None if B is None else B(np.eye(n))
|
||||
|
||||
vals, vecs = eigh(A_dense, B_dense, eigvals=eigvals, check_finite=False)
|
||||
if largest:
|
||||
# Reverse order to be compatible with eigs() in 'LM' mode.
|
||||
vals = vals[::-1]
|
||||
vecs = vecs[:, ::-1]
|
||||
|
||||
return vals, vecs
|
||||
|
||||
if residualTolerance is None:
|
||||
residualTolerance = np.sqrt(1e-15) * n
|
||||
|
||||
maxIterations = min(n, maxIterations)
|
||||
|
||||
if verbosityLevel:
|
||||
aux = "Solving "
|
||||
if B is None:
|
||||
aux += "standard"
|
||||
else:
|
||||
aux += "generalized"
|
||||
aux += " eigenvalue problem with"
|
||||
if M is None:
|
||||
aux += "out"
|
||||
aux += " preconditioning\n\n"
|
||||
aux += "matrix size %d\n" % n
|
||||
aux += "block size %d\n\n" % sizeX
|
||||
if blockVectorY is None:
|
||||
aux += "No constraints\n\n"
|
||||
else:
|
||||
if sizeY > 1:
|
||||
aux += "%d constraints\n\n" % sizeY
|
||||
else:
|
||||
aux += "%d constraint\n\n" % sizeY
|
||||
print(aux)
|
||||
|
||||
##
|
||||
# Apply constraints to X.
|
||||
if blockVectorY is not None:
|
||||
|
||||
if B is not None:
|
||||
blockVectorBY = B(blockVectorY)
|
||||
else:
|
||||
blockVectorBY = blockVectorY
|
||||
|
||||
# gramYBY is a dense array.
|
||||
gramYBY = np.dot(blockVectorY.T.conj(), blockVectorBY)
|
||||
try:
|
||||
# gramYBY is a Cholesky factor from now on...
|
||||
gramYBY = cho_factor(gramYBY)
|
||||
except Exception:
|
||||
raise ValueError('cannot handle linearly dependent constraints')
|
||||
|
||||
_applyConstraints(blockVectorX, gramYBY, blockVectorBY, blockVectorY)
|
||||
|
||||
##
|
||||
# B-orthonormalize X.
|
||||
blockVectorX, blockVectorBX = _b_orthonormalize(B, blockVectorX)
|
||||
|
||||
##
|
||||
# Compute the initial Ritz vectors: solve the eigenproblem.
|
||||
blockVectorAX = A(blockVectorX)
|
||||
gramXAX = np.dot(blockVectorX.T.conj(), blockVectorAX)
|
||||
|
||||
_lambda, eigBlockVector = eigh(gramXAX, check_finite=False)
|
||||
ii = _get_indx(_lambda, sizeX, largest)
|
||||
_lambda = _lambda[ii]
|
||||
|
||||
eigBlockVector = np.asarray(eigBlockVector[:,ii])
|
||||
blockVectorX = np.dot(blockVectorX, eigBlockVector)
|
||||
blockVectorAX = np.dot(blockVectorAX, eigBlockVector)
|
||||
if B is not None:
|
||||
blockVectorBX = np.dot(blockVectorBX, eigBlockVector)
|
||||
|
||||
##
|
||||
# Active index set.
|
||||
activeMask = np.ones((sizeX,), dtype=bool)
|
||||
|
||||
lambdaHistory = [_lambda]
|
||||
residualNormsHistory = []
|
||||
|
||||
previousBlockSize = sizeX
|
||||
ident = np.eye(sizeX, dtype=A.dtype)
|
||||
ident0 = np.eye(sizeX, dtype=A.dtype)
|
||||
|
||||
##
|
||||
# Main iteration loop.
|
||||
|
||||
blockVectorP = None # set during iteration
|
||||
blockVectorAP = None
|
||||
blockVectorBP = None
|
||||
|
||||
for iterationNumber in xrange(maxIterations):
|
||||
if verbosityLevel > 0:
|
||||
print('iteration %d' % iterationNumber)
|
||||
|
||||
aux = blockVectorBX * _lambda[np.newaxis,:]
|
||||
blockVectorR = blockVectorAX - aux
|
||||
|
||||
aux = np.sum(blockVectorR.conjugate() * blockVectorR, 0)
|
||||
residualNorms = np.sqrt(aux)
|
||||
|
||||
residualNormsHistory.append(residualNorms)
|
||||
|
||||
ii = np.where(residualNorms > residualTolerance, True, False)
|
||||
activeMask = activeMask & ii
|
||||
if verbosityLevel > 2:
|
||||
print(activeMask)
|
||||
|
||||
currentBlockSize = activeMask.sum()
|
||||
if currentBlockSize != previousBlockSize:
|
||||
previousBlockSize = currentBlockSize
|
||||
ident = np.eye(currentBlockSize, dtype=A.dtype)
|
||||
|
||||
if currentBlockSize == 0:
|
||||
break
|
||||
|
||||
if verbosityLevel > 0:
|
||||
print('current block size:', currentBlockSize)
|
||||
print('eigenvalue:', _lambda)
|
||||
print('residual norms:', residualNorms)
|
||||
if verbosityLevel > 10:
|
||||
print(eigBlockVector)
|
||||
|
||||
activeBlockVectorR = as2d(blockVectorR[:,activeMask])
|
||||
|
||||
if iterationNumber > 0:
|
||||
activeBlockVectorP = as2d(blockVectorP[:,activeMask])
|
||||
activeBlockVectorAP = as2d(blockVectorAP[:,activeMask])
|
||||
activeBlockVectorBP = as2d(blockVectorBP[:,activeMask])
|
||||
|
||||
if M is not None:
|
||||
# Apply preconditioner T to the active residuals.
|
||||
activeBlockVectorR = M(activeBlockVectorR)
|
||||
|
||||
##
|
||||
# Apply constraints to the preconditioned residuals.
|
||||
if blockVectorY is not None:
|
||||
_applyConstraints(activeBlockVectorR,
|
||||
gramYBY, blockVectorBY, blockVectorY)
|
||||
|
||||
##
|
||||
# B-orthonormalize the preconditioned residuals.
|
||||
|
||||
aux = _b_orthonormalize(B, activeBlockVectorR)
|
||||
activeBlockVectorR, activeBlockVectorBR = aux
|
||||
|
||||
activeBlockVectorAR = A(activeBlockVectorR)
|
||||
|
||||
if iterationNumber > 0:
|
||||
aux = _b_orthonormalize(B, activeBlockVectorP,
|
||||
activeBlockVectorBP, retInvR=True)
|
||||
activeBlockVectorP, activeBlockVectorBP, invR = aux
|
||||
activeBlockVectorAP = np.dot(activeBlockVectorAP, invR)
|
||||
|
||||
##
|
||||
# Perform the Rayleigh Ritz Procedure:
|
||||
# Compute symmetric Gram matrices:
|
||||
|
||||
xaw = np.dot(blockVectorX.T.conj(), activeBlockVectorAR)
|
||||
waw = np.dot(activeBlockVectorR.T.conj(), activeBlockVectorAR)
|
||||
xbw = np.dot(blockVectorX.T.conj(), activeBlockVectorBR)
|
||||
|
||||
if iterationNumber > 0:
|
||||
xap = np.dot(blockVectorX.T.conj(), activeBlockVectorAP)
|
||||
wap = np.dot(activeBlockVectorR.T.conj(), activeBlockVectorAP)
|
||||
pap = np.dot(activeBlockVectorP.T.conj(), activeBlockVectorAP)
|
||||
xbp = np.dot(blockVectorX.T.conj(), activeBlockVectorBP)
|
||||
wbp = np.dot(activeBlockVectorR.T.conj(), activeBlockVectorBP)
|
||||
|
||||
gramA = np.bmat([[np.diag(_lambda), xaw, xap],
|
||||
[xaw.T.conj(), waw, wap],
|
||||
[xap.T.conj(), wap.T.conj(), pap]])
|
||||
|
||||
gramB = np.bmat([[ident0, xbw, xbp],
|
||||
[xbw.T.conj(), ident, wbp],
|
||||
[xbp.T.conj(), wbp.T.conj(), ident]])
|
||||
else:
|
||||
gramA = np.bmat([[np.diag(_lambda), xaw],
|
||||
[xaw.T.conj(), waw]])
|
||||
gramB = np.bmat([[ident0, xbw],
|
||||
[xbw.T.conj(), ident]])
|
||||
|
||||
if verbosityLevel > 0:
|
||||
_report_nonhermitian(gramA, 3, -1, 'gramA')
|
||||
_report_nonhermitian(gramB, 3, -1, 'gramB')
|
||||
|
||||
if verbosityLevel > 10:
|
||||
save(gramA, 'gramA')
|
||||
save(gramB, 'gramB')
|
||||
|
||||
# Solve the generalized eigenvalue problem.
|
||||
_lambda, eigBlockVector = eigh(gramA, gramB, check_finite=False)
|
||||
ii = _get_indx(_lambda, sizeX, largest)
|
||||
if verbosityLevel > 10:
|
||||
print(ii)
|
||||
|
||||
_lambda = _lambda[ii]
|
||||
eigBlockVector = eigBlockVector[:,ii]
|
||||
|
||||
lambdaHistory.append(_lambda)
|
||||
|
||||
if verbosityLevel > 10:
|
||||
print('lambda:', _lambda)
|
||||
## # Normalize eigenvectors!
|
||||
## aux = np.sum( eigBlockVector.conjugate() * eigBlockVector, 0 )
|
||||
## eigVecNorms = np.sqrt( aux )
|
||||
## eigBlockVector = eigBlockVector / eigVecNorms[np.newaxis,:]
|
||||
# eigBlockVector, aux = _b_orthonormalize( B, eigBlockVector )
|
||||
|
||||
if verbosityLevel > 10:
|
||||
print(eigBlockVector)
|
||||
|
||||
##
|
||||
# Compute Ritz vectors.
|
||||
if iterationNumber > 0:
|
||||
eigBlockVectorX = eigBlockVector[:sizeX]
|
||||
eigBlockVectorR = eigBlockVector[sizeX:sizeX+currentBlockSize]
|
||||
eigBlockVectorP = eigBlockVector[sizeX+currentBlockSize:]
|
||||
|
||||
pp = np.dot(activeBlockVectorR, eigBlockVectorR)
|
||||
pp += np.dot(activeBlockVectorP, eigBlockVectorP)
|
||||
|
||||
app = np.dot(activeBlockVectorAR, eigBlockVectorR)
|
||||
app += np.dot(activeBlockVectorAP, eigBlockVectorP)
|
||||
|
||||
bpp = np.dot(activeBlockVectorBR, eigBlockVectorR)
|
||||
bpp += np.dot(activeBlockVectorBP, eigBlockVectorP)
|
||||
else:
|
||||
eigBlockVectorX = eigBlockVector[:sizeX]
|
||||
eigBlockVectorR = eigBlockVector[sizeX:]
|
||||
|
||||
pp = np.dot(activeBlockVectorR, eigBlockVectorR)
|
||||
app = np.dot(activeBlockVectorAR, eigBlockVectorR)
|
||||
bpp = np.dot(activeBlockVectorBR, eigBlockVectorR)
|
||||
|
||||
if verbosityLevel > 10:
|
||||
print(pp)
|
||||
print(app)
|
||||
print(bpp)
|
||||
|
||||
blockVectorX = np.dot(blockVectorX, eigBlockVectorX) + pp
|
||||
blockVectorAX = np.dot(blockVectorAX, eigBlockVectorX) + app
|
||||
blockVectorBX = np.dot(blockVectorBX, eigBlockVectorX) + bpp
|
||||
|
||||
blockVectorP, blockVectorAP, blockVectorBP = pp, app, bpp
|
||||
|
||||
aux = blockVectorBX * _lambda[np.newaxis,:]
|
||||
blockVectorR = blockVectorAX - aux
|
||||
|
||||
aux = np.sum(blockVectorR.conjugate() * blockVectorR, 0)
|
||||
residualNorms = np.sqrt(aux)
|
||||
|
||||
if verbosityLevel > 0:
|
||||
print('final eigenvalue:', _lambda)
|
||||
print('final residual norms:', residualNorms)
|
||||
|
||||
if retLambdaHistory:
|
||||
if retResidualNormsHistory:
|
||||
return _lambda, blockVectorX, lambdaHistory, residualNormsHistory
|
||||
else:
|
||||
return _lambda, blockVectorX, lambdaHistory
|
||||
else:
|
||||
if retResidualNormsHistory:
|
||||
return _lambda, blockVectorX, residualNormsHistory
|
||||
else:
|
||||
return _lambda, blockVectorX
|
||||
@@ -0,0 +1,15 @@
|
||||
from __future__ import division, print_function, absolute_import
|
||||
|
||||
|
||||
def configuration(parent_package='',top_path=None):
|
||||
from numpy.distutils.misc_util import Configuration
|
||||
|
||||
config = Configuration('lobpcg',parent_package,top_path)
|
||||
config.add_data_dir('tests')
|
||||
|
||||
return config
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
from numpy.distutils.core import setup
|
||||
setup(**configuration(top_path='').todict())
|
||||
BIN
Binary file not shown.
BIN
Binary file not shown.
+261
@@ -0,0 +1,261 @@
|
||||
""" Test functions for the sparse.linalg.eigen.lobpcg module
|
||||
"""
|
||||
from __future__ import division, print_function, absolute_import
|
||||
|
||||
import itertools
|
||||
|
||||
import numpy as np
|
||||
from numpy.testing import (assert_almost_equal, assert_equal,
|
||||
assert_allclose, assert_array_less)
|
||||
|
||||
from scipy import ones, rand, r_, diag, linalg, eye
|
||||
from scipy.linalg import eig, eigh, toeplitz
|
||||
import scipy.sparse
|
||||
from scipy.sparse.linalg.eigen.lobpcg import lobpcg
|
||||
from scipy.sparse.linalg import eigs
|
||||
from scipy.sparse import spdiags
|
||||
|
||||
import pytest
|
||||
|
||||
def ElasticRod(n):
|
||||
# Fixed-free elastic rod
|
||||
L = 1.0
|
||||
le = L/n
|
||||
rho = 7.85e3
|
||||
S = 1.e-4
|
||||
E = 2.1e11
|
||||
mass = rho*S*le/6.
|
||||
k = E*S/le
|
||||
A = k*(diag(r_[2.*ones(n-1),1])-diag(ones(n-1),1)-diag(ones(n-1),-1))
|
||||
B = mass*(diag(r_[4.*ones(n-1),2])+diag(ones(n-1),1)+diag(ones(n-1),-1))
|
||||
return A,B
|
||||
|
||||
|
||||
def MikotaPair(n):
|
||||
# Mikota pair acts as a nice test since the eigenvalues
|
||||
# are the squares of the integers n, n=1,2,...
|
||||
x = np.arange(1,n+1)
|
||||
B = diag(1./x)
|
||||
y = np.arange(n-1,0,-1)
|
||||
z = np.arange(2*n-1,0,-2)
|
||||
A = diag(z)-diag(y,-1)-diag(y,1)
|
||||
return A,B
|
||||
|
||||
|
||||
def compare_solutions(A,B,m):
|
||||
n = A.shape[0]
|
||||
|
||||
np.random.seed(0)
|
||||
|
||||
V = rand(n,m)
|
||||
X = linalg.orth(V)
|
||||
|
||||
eigs,vecs = lobpcg(A, X, B=B, tol=1e-5, maxiter=30, largest=False)
|
||||
eigs.sort()
|
||||
|
||||
w,v = eig(A,b=B)
|
||||
w.sort()
|
||||
|
||||
assert_almost_equal(w[:int(m/2)],eigs[:int(m/2)],decimal=2)
|
||||
|
||||
|
||||
def test_Small():
|
||||
A,B = ElasticRod(10)
|
||||
compare_solutions(A,B,10)
|
||||
A,B = MikotaPair(10)
|
||||
compare_solutions(A,B,10)
|
||||
|
||||
|
||||
def test_ElasticRod():
|
||||
A,B = ElasticRod(100)
|
||||
compare_solutions(A,B,20)
|
||||
|
||||
|
||||
def test_MikotaPair():
|
||||
A,B = MikotaPair(100)
|
||||
compare_solutions(A,B,20)
|
||||
|
||||
|
||||
def test_trivial():
|
||||
n = 5
|
||||
X = ones((n, 1))
|
||||
A = eye(n)
|
||||
compare_solutions(A, None, n)
|
||||
|
||||
|
||||
def test_regression():
|
||||
# https://mail.python.org/pipermail/scipy-user/2010-October/026944.html
|
||||
n = 10
|
||||
X = np.ones((n, 1))
|
||||
A = np.identity(n)
|
||||
w, V = lobpcg(A, X)
|
||||
assert_allclose(w, [1])
|
||||
|
||||
|
||||
def test_diagonal():
|
||||
# This test was moved from '__main__' in lobpcg.py.
|
||||
# Coincidentally or not, this is the same eigensystem
|
||||
# required to reproduce arpack bug
|
||||
# https://forge.scilab.org/p/arpack-ng/issues/1397/
|
||||
# even using the same n=100.
|
||||
|
||||
np.random.seed(1234)
|
||||
|
||||
# The system of interest is of size n x n.
|
||||
n = 100
|
||||
|
||||
# We care about only m eigenpairs.
|
||||
m = 4
|
||||
|
||||
# Define the generalized eigenvalue problem Av = cBv
|
||||
# where (c, v) is a generalized eigenpair,
|
||||
# and where we choose A to be the diagonal matrix whose entries are 1..n
|
||||
# and where B is chosen to be the identity matrix.
|
||||
vals = np.arange(1, n+1, dtype=float)
|
||||
A = scipy.sparse.diags([vals], [0], (n, n))
|
||||
B = scipy.sparse.eye(n)
|
||||
|
||||
# Let the preconditioner M be the inverse of A.
|
||||
M = scipy.sparse.diags([np.reciprocal(vals)], [0], (n, n))
|
||||
|
||||
# Pick random initial vectors.
|
||||
X = np.random.rand(n, m)
|
||||
|
||||
# Require that the returned eigenvectors be in the orthogonal complement
|
||||
# of the first few standard basis vectors.
|
||||
m_excluded = 3
|
||||
Y = np.eye(n, m_excluded)
|
||||
|
||||
eigs, vecs = lobpcg(A, X, B, M=M, Y=Y, tol=1e-4, maxiter=40, largest=False)
|
||||
|
||||
assert_allclose(eigs, np.arange(1+m_excluded, 1+m_excluded+m))
|
||||
_check_eigen(A, eigs, vecs, rtol=1e-3, atol=1e-3)
|
||||
|
||||
|
||||
def _check_eigen(M, w, V, rtol=1e-8, atol=1e-14):
|
||||
mult_wV = np.multiply(w, V)
|
||||
dot_MV = M.dot(V)
|
||||
assert_allclose(mult_wV, dot_MV, rtol=rtol, atol=atol)
|
||||
|
||||
|
||||
def _check_fiedler(n, p):
|
||||
# This is not necessarily the recommended way to find the Fiedler vector.
|
||||
np.random.seed(1234)
|
||||
col = np.zeros(n)
|
||||
col[1] = 1
|
||||
A = toeplitz(col)
|
||||
D = np.diag(A.sum(axis=1))
|
||||
L = D - A
|
||||
# Compute the full eigendecomposition using tricks, e.g.
|
||||
# http://www.cs.yale.edu/homes/spielman/561/2009/lect02-09.pdf
|
||||
tmp = np.pi * np.arange(n) / n
|
||||
analytic_w = 2 * (1 - np.cos(tmp))
|
||||
analytic_V = np.cos(np.outer(np.arange(n) + 1/2, tmp))
|
||||
_check_eigen(L, analytic_w, analytic_V)
|
||||
# Compute the full eigendecomposition using eigh.
|
||||
eigh_w, eigh_V = eigh(L)
|
||||
_check_eigen(L, eigh_w, eigh_V)
|
||||
# Check that the first eigenvalue is near zero and that the rest agree.
|
||||
assert_array_less(np.abs([eigh_w[0], analytic_w[0]]), 1e-14)
|
||||
assert_allclose(eigh_w[1:], analytic_w[1:])
|
||||
|
||||
# Check small lobpcg eigenvalues.
|
||||
X = analytic_V[:, :p]
|
||||
lobpcg_w, lobpcg_V = lobpcg(L, X, largest=False)
|
||||
assert_equal(lobpcg_w.shape, (p,))
|
||||
assert_equal(lobpcg_V.shape, (n, p))
|
||||
_check_eigen(L, lobpcg_w, lobpcg_V)
|
||||
assert_array_less(np.abs(np.min(lobpcg_w)), 1e-14)
|
||||
assert_allclose(np.sort(lobpcg_w)[1:], analytic_w[1:p])
|
||||
|
||||
# Check large lobpcg eigenvalues.
|
||||
X = analytic_V[:, -p:]
|
||||
lobpcg_w, lobpcg_V = lobpcg(L, X, largest=True)
|
||||
assert_equal(lobpcg_w.shape, (p,))
|
||||
assert_equal(lobpcg_V.shape, (n, p))
|
||||
_check_eigen(L, lobpcg_w, lobpcg_V)
|
||||
assert_allclose(np.sort(lobpcg_w), analytic_w[-p:])
|
||||
|
||||
# Look for the Fiedler vector using good but not exactly correct guesses.
|
||||
fiedler_guess = np.concatenate((np.ones(n//2), -np.ones(n-n//2)))
|
||||
X = np.vstack((np.ones(n), fiedler_guess)).T
|
||||
lobpcg_w, lobpcg_V = lobpcg(L, X, largest=False)
|
||||
# Mathematically, the smaller eigenvalue should be zero
|
||||
# and the larger should be the algebraic connectivity.
|
||||
lobpcg_w = np.sort(lobpcg_w)
|
||||
assert_allclose(lobpcg_w, analytic_w[:2], atol=1e-14)
|
||||
|
||||
|
||||
def test_fiedler_small_8():
|
||||
# This triggers the dense path because 8 < 2*5.
|
||||
_check_fiedler(8, 2)
|
||||
|
||||
|
||||
def test_fiedler_large_12():
|
||||
# This does not trigger the dense path, because 2*5 <= 12.
|
||||
_check_fiedler(12, 2)
|
||||
|
||||
|
||||
def test_hermitian():
|
||||
np.random.seed(1234)
|
||||
|
||||
sizes = [3, 10, 50]
|
||||
ks = [1, 3, 10, 50]
|
||||
gens = [True, False]
|
||||
|
||||
for size, k, gen in itertools.product(sizes, ks, gens):
|
||||
if k > size:
|
||||
continue
|
||||
|
||||
H = np.random.rand(size, size) + 1.j * np.random.rand(size, size)
|
||||
H = 10 * np.eye(size) + H + H.T.conj()
|
||||
|
||||
X = np.random.rand(size, k)
|
||||
|
||||
if not gen:
|
||||
B = np.eye(size)
|
||||
w, v = lobpcg(H, X, maxiter=5000)
|
||||
w0, v0 = eigh(H)
|
||||
else:
|
||||
B = np.random.rand(size, size) + 1.j * np.random.rand(size, size)
|
||||
B = 10 * np.eye(size) + B.dot(B.T.conj())
|
||||
w, v = lobpcg(H, X, B, maxiter=5000, largest=False)
|
||||
w0, v0 = eigh(H, B)
|
||||
|
||||
for wx, vx in zip(w, v.T):
|
||||
# Check eigenvector
|
||||
assert_allclose(np.linalg.norm(H.dot(vx) - B.dot(vx) * wx)
|
||||
/ np.linalg.norm(H.dot(vx)),
|
||||
0, atol=5e-4, rtol=0)
|
||||
|
||||
# Compare eigenvalues
|
||||
j = np.argmin(abs(w0 - wx))
|
||||
assert_allclose(wx, w0[j], rtol=1e-4)
|
||||
|
||||
# The n=5 case tests the alternative small matrix code path that uses eigh().
|
||||
@pytest.mark.parametrize('n, atol', [(20, 1e-3), (5, 1e-8)])
|
||||
def test_eigs_consistency(n, atol):
|
||||
vals = np.arange(1, n+1, dtype=np.float64)
|
||||
A = spdiags(vals, 0, n, n)
|
||||
np.random.seed(345678)
|
||||
X = np.random.rand(n, 2)
|
||||
lvals, lvecs = lobpcg(A, X, largest=True, maxiter=100)
|
||||
vals, vecs = eigs(A, k=2)
|
||||
|
||||
_check_eigen(A, lvals, lvecs, atol=atol, rtol=0)
|
||||
assert_allclose(np.sort(vals), np.sort(lvals), atol=1e-14)
|
||||
|
||||
def test_verbosity():
|
||||
"""Check that nonzero verbosity level code runs.
|
||||
"""
|
||||
A, B = ElasticRod(100)
|
||||
|
||||
n = A.shape[0]
|
||||
m = 20
|
||||
|
||||
np.random.seed(0)
|
||||
V = rand(n,m)
|
||||
X = linalg.orth(V)
|
||||
|
||||
eigs,vecs = lobpcg(A, X, B=B, tol=1e-5, maxiter=30, largest=False,
|
||||
verbosityLevel=11)
|
||||
@@ -0,0 +1,17 @@
|
||||
from __future__ import division, print_function, absolute_import
|
||||
|
||||
|
||||
def configuration(parent_package='',top_path=None):
|
||||
from numpy.distutils.misc_util import Configuration
|
||||
|
||||
config = Configuration('eigen',parent_package,top_path)
|
||||
|
||||
config.add_subpackage(('arpack'))
|
||||
config.add_subpackage(('lobpcg'))
|
||||
|
||||
return config
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
from numpy.distutils.core import setup
|
||||
setup(**configuration(top_path='').todict())
|
||||
@@ -0,0 +1,703 @@
|
||||
"""Abstract linear algebra library.
|
||||
|
||||
This module defines a class hierarchy that implements a kind of "lazy"
|
||||
matrix representation, called the ``LinearOperator``. It can be used to do
|
||||
linear algebra with extremely large sparse or structured matrices, without
|
||||
representing those explicitly in memory. Such matrices can be added,
|
||||
multiplied, transposed, etc.
|
||||
|
||||
As a motivating example, suppose you want have a matrix where almost all of
|
||||
the elements have the value one. The standard sparse matrix representation
|
||||
skips the storage of zeros, but not ones. By contrast, a LinearOperator is
|
||||
able to represent such matrices efficiently. First, we need a compact way to
|
||||
represent an all-ones matrix::
|
||||
|
||||
>>> import numpy as np
|
||||
>>> class Ones(LinearOperator):
|
||||
... def __init__(self, shape):
|
||||
... super(Ones, self).__init__(dtype=None, shape=shape)
|
||||
... def _matvec(self, x):
|
||||
... return np.repeat(x.sum(), self.shape[0])
|
||||
|
||||
Instances of this class emulate ``np.ones(shape)``, but using a constant
|
||||
amount of storage, independent of ``shape``. The ``_matvec`` method specifies
|
||||
how this linear operator multiplies with (operates on) a vector. We can now
|
||||
add this operator to a sparse matrix that stores only offsets from one::
|
||||
|
||||
>>> from scipy.sparse import csr_matrix
|
||||
>>> offsets = csr_matrix([[1, 0, 2], [0, -1, 0], [0, 0, 3]])
|
||||
>>> A = aslinearoperator(offsets) + Ones(offsets.shape)
|
||||
>>> A.dot([1, 2, 3])
|
||||
array([13, 4, 15])
|
||||
|
||||
The result is the same as that given by its dense, explicitly-stored
|
||||
counterpart::
|
||||
|
||||
>>> (np.ones(A.shape, A.dtype) + offsets.toarray()).dot([1, 2, 3])
|
||||
array([13, 4, 15])
|
||||
|
||||
Several algorithms in the ``scipy.sparse`` library are able to operate on
|
||||
``LinearOperator`` instances.
|
||||
"""
|
||||
|
||||
from __future__ import division, print_function, absolute_import
|
||||
|
||||
import warnings
|
||||
|
||||
import numpy as np
|
||||
|
||||
from scipy.sparse import isspmatrix
|
||||
from scipy.sparse.sputils import isshape, isintlike
|
||||
|
||||
__all__ = ['LinearOperator', 'aslinearoperator']
|
||||
|
||||
|
||||
class LinearOperator(object):
|
||||
"""Common interface for performing matrix vector products
|
||||
|
||||
Many iterative methods (e.g. cg, gmres) do not need to know the
|
||||
individual entries of a matrix to solve a linear system A*x=b.
|
||||
Such solvers only require the computation of matrix vector
|
||||
products, A*v where v is a dense vector. This class serves as
|
||||
an abstract interface between iterative solvers and matrix-like
|
||||
objects.
|
||||
|
||||
To construct a concrete LinearOperator, either pass appropriate
|
||||
callables to the constructor of this class, or subclass it.
|
||||
|
||||
A subclass must implement either one of the methods ``_matvec``
|
||||
and ``_matmat``, and the attributes/properties ``shape`` (pair of
|
||||
integers) and ``dtype`` (may be None). It may call the ``__init__``
|
||||
on this class to have these attributes validated. Implementing
|
||||
``_matvec`` automatically implements ``_matmat`` (using a naive
|
||||
algorithm) and vice-versa.
|
||||
|
||||
Optionally, a subclass may implement ``_rmatvec`` or ``_adjoint``
|
||||
to implement the Hermitian adjoint (conjugate transpose). As with
|
||||
``_matvec`` and ``_matmat``, implementing either ``_rmatvec`` or
|
||||
``_adjoint`` implements the other automatically. Implementing
|
||||
``_adjoint`` is preferable; ``_rmatvec`` is mostly there for
|
||||
backwards compatibility.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
shape : tuple
|
||||
Matrix dimensions (M,N).
|
||||
matvec : callable f(v)
|
||||
Returns returns A * v.
|
||||
rmatvec : callable f(v)
|
||||
Returns A^H * v, where A^H is the conjugate transpose of A.
|
||||
matmat : callable f(V)
|
||||
Returns A * V, where V is a dense matrix with dimensions (N,K).
|
||||
dtype : dtype
|
||||
Data type of the matrix.
|
||||
|
||||
Attributes
|
||||
----------
|
||||
args : tuple
|
||||
For linear operators describing products etc. of other linear
|
||||
operators, the operands of the binary operation.
|
||||
|
||||
See Also
|
||||
--------
|
||||
aslinearoperator : Construct LinearOperators
|
||||
|
||||
Notes
|
||||
-----
|
||||
The user-defined matvec() function must properly handle the case
|
||||
where v has shape (N,) as well as the (N,1) case. The shape of
|
||||
the return type is handled internally by LinearOperator.
|
||||
|
||||
LinearOperator instances can also be multiplied, added with each
|
||||
other and exponentiated, all lazily: the result of these operations
|
||||
is always a new, composite LinearOperator, that defers linear
|
||||
operations to the original operators and combines the results.
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> import numpy as np
|
||||
>>> from scipy.sparse.linalg import LinearOperator
|
||||
>>> def mv(v):
|
||||
... return np.array([2*v[0], 3*v[1]])
|
||||
...
|
||||
>>> A = LinearOperator((2,2), matvec=mv)
|
||||
>>> A
|
||||
<2x2 _CustomLinearOperator with dtype=float64>
|
||||
>>> A.matvec(np.ones(2))
|
||||
array([ 2., 3.])
|
||||
>>> A * np.ones(2)
|
||||
array([ 2., 3.])
|
||||
|
||||
"""
|
||||
def __new__(cls, *args, **kwargs):
|
||||
if cls is LinearOperator:
|
||||
# Operate as _CustomLinearOperator factory.
|
||||
return super(LinearOperator, cls).__new__(_CustomLinearOperator)
|
||||
else:
|
||||
obj = super(LinearOperator, cls).__new__(cls)
|
||||
|
||||
if (type(obj)._matvec == LinearOperator._matvec
|
||||
and type(obj)._matmat == LinearOperator._matmat):
|
||||
warnings.warn("LinearOperator subclass should implement"
|
||||
" at least one of _matvec and _matmat.",
|
||||
category=RuntimeWarning, stacklevel=2)
|
||||
|
||||
return obj
|
||||
|
||||
def __init__(self, dtype, shape):
|
||||
"""Initialize this LinearOperator.
|
||||
|
||||
To be called by subclasses. ``dtype`` may be None; ``shape`` should
|
||||
be convertible to a length-2 tuple.
|
||||
"""
|
||||
if dtype is not None:
|
||||
dtype = np.dtype(dtype)
|
||||
|
||||
shape = tuple(shape)
|
||||
if not isshape(shape):
|
||||
raise ValueError("invalid shape %r (must be 2-d)" % (shape,))
|
||||
|
||||
self.dtype = dtype
|
||||
self.shape = shape
|
||||
|
||||
def _init_dtype(self):
|
||||
"""Called from subclasses at the end of the __init__ routine.
|
||||
"""
|
||||
if self.dtype is None:
|
||||
v = np.zeros(self.shape[-1])
|
||||
self.dtype = np.asarray(self.matvec(v)).dtype
|
||||
|
||||
def _matmat(self, X):
|
||||
"""Default matrix-matrix multiplication handler.
|
||||
|
||||
Falls back on the user-defined _matvec method, so defining that will
|
||||
define matrix multiplication (though in a very suboptimal way).
|
||||
"""
|
||||
|
||||
return np.hstack([self.matvec(col.reshape(-1,1)) for col in X.T])
|
||||
|
||||
def _matvec(self, x):
|
||||
"""Default matrix-vector multiplication handler.
|
||||
|
||||
If self is a linear operator of shape (M, N), then this method will
|
||||
be called on a shape (N,) or (N, 1) ndarray, and should return a
|
||||
shape (M,) or (M, 1) ndarray.
|
||||
|
||||
This default implementation falls back on _matmat, so defining that
|
||||
will define matrix-vector multiplication as well.
|
||||
"""
|
||||
return self.matmat(x.reshape(-1, 1))
|
||||
|
||||
def matvec(self, x):
|
||||
"""Matrix-vector multiplication.
|
||||
|
||||
Performs the operation y=A*x where A is an MxN linear
|
||||
operator and x is a column vector or 1-d array.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
x : {matrix, ndarray}
|
||||
An array with shape (N,) or (N,1).
|
||||
|
||||
Returns
|
||||
-------
|
||||
y : {matrix, ndarray}
|
||||
A matrix or ndarray with shape (M,) or (M,1) depending
|
||||
on the type and shape of the x argument.
|
||||
|
||||
Notes
|
||||
-----
|
||||
This matvec wraps the user-specified matvec routine or overridden
|
||||
_matvec method to ensure that y has the correct shape and type.
|
||||
|
||||
"""
|
||||
|
||||
x = np.asanyarray(x)
|
||||
|
||||
M,N = self.shape
|
||||
|
||||
if x.shape != (N,) and x.shape != (N,1):
|
||||
raise ValueError('dimension mismatch')
|
||||
|
||||
y = self._matvec(x)
|
||||
|
||||
if isinstance(x, np.matrix):
|
||||
y = np.asmatrix(y)
|
||||
else:
|
||||
y = np.asarray(y)
|
||||
|
||||
if x.ndim == 1:
|
||||
y = y.reshape(M)
|
||||
elif x.ndim == 2:
|
||||
y = y.reshape(M,1)
|
||||
else:
|
||||
raise ValueError('invalid shape returned by user-defined matvec()')
|
||||
|
||||
return y
|
||||
|
||||
def rmatvec(self, x):
|
||||
"""Adjoint matrix-vector multiplication.
|
||||
|
||||
Performs the operation y = A^H * x where A is an MxN linear
|
||||
operator and x is a column vector or 1-d array.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
x : {matrix, ndarray}
|
||||
An array with shape (M,) or (M,1).
|
||||
|
||||
Returns
|
||||
-------
|
||||
y : {matrix, ndarray}
|
||||
A matrix or ndarray with shape (N,) or (N,1) depending
|
||||
on the type and shape of the x argument.
|
||||
|
||||
Notes
|
||||
-----
|
||||
This rmatvec wraps the user-specified rmatvec routine or overridden
|
||||
_rmatvec method to ensure that y has the correct shape and type.
|
||||
|
||||
"""
|
||||
|
||||
x = np.asanyarray(x)
|
||||
|
||||
M,N = self.shape
|
||||
|
||||
if x.shape != (M,) and x.shape != (M,1):
|
||||
raise ValueError('dimension mismatch')
|
||||
|
||||
y = self._rmatvec(x)
|
||||
|
||||
if isinstance(x, np.matrix):
|
||||
y = np.asmatrix(y)
|
||||
else:
|
||||
y = np.asarray(y)
|
||||
|
||||
if x.ndim == 1:
|
||||
y = y.reshape(N)
|
||||
elif x.ndim == 2:
|
||||
y = y.reshape(N,1)
|
||||
else:
|
||||
raise ValueError('invalid shape returned by user-defined rmatvec()')
|
||||
|
||||
return y
|
||||
|
||||
def _rmatvec(self, x):
|
||||
"""Default implementation of _rmatvec; defers to adjoint."""
|
||||
if type(self)._adjoint == LinearOperator._adjoint:
|
||||
# _adjoint not overridden, prevent infinite recursion
|
||||
raise NotImplementedError
|
||||
else:
|
||||
return self.H.matvec(x)
|
||||
|
||||
def matmat(self, X):
|
||||
"""Matrix-matrix multiplication.
|
||||
|
||||
Performs the operation y=A*X where A is an MxN linear
|
||||
operator and X dense N*K matrix or ndarray.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
X : {matrix, ndarray}
|
||||
An array with shape (N,K).
|
||||
|
||||
Returns
|
||||
-------
|
||||
Y : {matrix, ndarray}
|
||||
A matrix or ndarray with shape (M,K) depending on
|
||||
the type of the X argument.
|
||||
|
||||
Notes
|
||||
-----
|
||||
This matmat wraps any user-specified matmat routine or overridden
|
||||
_matmat method to ensure that y has the correct type.
|
||||
|
||||
"""
|
||||
|
||||
X = np.asanyarray(X)
|
||||
|
||||
if X.ndim != 2:
|
||||
raise ValueError('expected 2-d ndarray or matrix, not %d-d'
|
||||
% X.ndim)
|
||||
|
||||
M,N = self.shape
|
||||
|
||||
if X.shape[0] != N:
|
||||
raise ValueError('dimension mismatch: %r, %r'
|
||||
% (self.shape, X.shape))
|
||||
|
||||
Y = self._matmat(X)
|
||||
|
||||
if isinstance(Y, np.matrix):
|
||||
Y = np.asmatrix(Y)
|
||||
|
||||
return Y
|
||||
|
||||
def __call__(self, x):
|
||||
return self*x
|
||||
|
||||
def __mul__(self, x):
|
||||
return self.dot(x)
|
||||
|
||||
def dot(self, x):
|
||||
"""Matrix-matrix or matrix-vector multiplication.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
x : array_like
|
||||
1-d or 2-d array, representing a vector or matrix.
|
||||
|
||||
Returns
|
||||
-------
|
||||
Ax : array
|
||||
1-d or 2-d array (depending on the shape of x) that represents
|
||||
the result of applying this linear operator on x.
|
||||
|
||||
"""
|
||||
if isinstance(x, LinearOperator):
|
||||
return _ProductLinearOperator(self, x)
|
||||
elif np.isscalar(x):
|
||||
return _ScaledLinearOperator(self, x)
|
||||
else:
|
||||
x = np.asarray(x)
|
||||
|
||||
if x.ndim == 1 or x.ndim == 2 and x.shape[1] == 1:
|
||||
return self.matvec(x)
|
||||
elif x.ndim == 2:
|
||||
return self.matmat(x)
|
||||
else:
|
||||
raise ValueError('expected 1-d or 2-d array or matrix, got %r'
|
||||
% x)
|
||||
|
||||
def __matmul__(self, other):
|
||||
if np.isscalar(other):
|
||||
raise ValueError("Scalar operands are not allowed, "
|
||||
"use '*' instead")
|
||||
return self.__mul__(other)
|
||||
|
||||
def __rmatmul__(self, other):
|
||||
if np.isscalar(other):
|
||||
raise ValueError("Scalar operands are not allowed, "
|
||||
"use '*' instead")
|
||||
return self.__rmul__(other)
|
||||
|
||||
def __rmul__(self, x):
|
||||
if np.isscalar(x):
|
||||
return _ScaledLinearOperator(self, x)
|
||||
else:
|
||||
return NotImplemented
|
||||
|
||||
def __pow__(self, p):
|
||||
if np.isscalar(p):
|
||||
return _PowerLinearOperator(self, p)
|
||||
else:
|
||||
return NotImplemented
|
||||
|
||||
def __add__(self, x):
|
||||
if isinstance(x, LinearOperator):
|
||||
return _SumLinearOperator(self, x)
|
||||
else:
|
||||
return NotImplemented
|
||||
|
||||
def __neg__(self):
|
||||
return _ScaledLinearOperator(self, -1)
|
||||
|
||||
def __sub__(self, x):
|
||||
return self.__add__(-x)
|
||||
|
||||
def __repr__(self):
|
||||
M,N = self.shape
|
||||
if self.dtype is None:
|
||||
dt = 'unspecified dtype'
|
||||
else:
|
||||
dt = 'dtype=' + str(self.dtype)
|
||||
|
||||
return '<%dx%d %s with %s>' % (M, N, self.__class__.__name__, dt)
|
||||
|
||||
def adjoint(self):
|
||||
"""Hermitian adjoint.
|
||||
|
||||
Returns the Hermitian adjoint of self, aka the Hermitian
|
||||
conjugate or Hermitian transpose. For a complex matrix, the
|
||||
Hermitian adjoint is equal to the conjugate transpose.
|
||||
|
||||
Can be abbreviated self.H instead of self.adjoint().
|
||||
|
||||
Returns
|
||||
-------
|
||||
A_H : LinearOperator
|
||||
Hermitian adjoint of self.
|
||||
"""
|
||||
return self._adjoint()
|
||||
|
||||
H = property(adjoint)
|
||||
|
||||
def transpose(self):
|
||||
"""Transpose this linear operator.
|
||||
|
||||
Returns a LinearOperator that represents the transpose of this one.
|
||||
Can be abbreviated self.T instead of self.transpose().
|
||||
"""
|
||||
return self._transpose()
|
||||
|
||||
T = property(transpose)
|
||||
|
||||
def _adjoint(self):
|
||||
"""Default implementation of _adjoint; defers to rmatvec."""
|
||||
shape = (self.shape[1], self.shape[0])
|
||||
return _CustomLinearOperator(shape, matvec=self.rmatvec,
|
||||
rmatvec=self.matvec,
|
||||
dtype=self.dtype)
|
||||
|
||||
|
||||
class _CustomLinearOperator(LinearOperator):
|
||||
"""Linear operator defined in terms of user-specified operations."""
|
||||
|
||||
def __init__(self, shape, matvec, rmatvec=None, matmat=None, dtype=None):
|
||||
super(_CustomLinearOperator, self).__init__(dtype, shape)
|
||||
|
||||
self.args = ()
|
||||
|
||||
self.__matvec_impl = matvec
|
||||
self.__rmatvec_impl = rmatvec
|
||||
self.__matmat_impl = matmat
|
||||
|
||||
self._init_dtype()
|
||||
|
||||
def _matmat(self, X):
|
||||
if self.__matmat_impl is not None:
|
||||
return self.__matmat_impl(X)
|
||||
else:
|
||||
return super(_CustomLinearOperator, self)._matmat(X)
|
||||
|
||||
def _matvec(self, x):
|
||||
return self.__matvec_impl(x)
|
||||
|
||||
def _rmatvec(self, x):
|
||||
func = self.__rmatvec_impl
|
||||
if func is None:
|
||||
raise NotImplementedError("rmatvec is not defined")
|
||||
return self.__rmatvec_impl(x)
|
||||
|
||||
def _adjoint(self):
|
||||
return _CustomLinearOperator(shape=(self.shape[1], self.shape[0]),
|
||||
matvec=self.__rmatvec_impl,
|
||||
rmatvec=self.__matvec_impl,
|
||||
dtype=self.dtype)
|
||||
|
||||
|
||||
def _get_dtype(operators, dtypes=None):
|
||||
if dtypes is None:
|
||||
dtypes = []
|
||||
for obj in operators:
|
||||
if obj is not None and hasattr(obj, 'dtype'):
|
||||
dtypes.append(obj.dtype)
|
||||
return np.find_common_type(dtypes, [])
|
||||
|
||||
|
||||
class _SumLinearOperator(LinearOperator):
|
||||
def __init__(self, A, B):
|
||||
if not isinstance(A, LinearOperator) or \
|
||||
not isinstance(B, LinearOperator):
|
||||
raise ValueError('both operands have to be a LinearOperator')
|
||||
if A.shape != B.shape:
|
||||
raise ValueError('cannot add %r and %r: shape mismatch'
|
||||
% (A, B))
|
||||
self.args = (A, B)
|
||||
super(_SumLinearOperator, self).__init__(_get_dtype([A, B]), A.shape)
|
||||
|
||||
def _matvec(self, x):
|
||||
return self.args[0].matvec(x) + self.args[1].matvec(x)
|
||||
|
||||
def _rmatvec(self, x):
|
||||
return self.args[0].rmatvec(x) + self.args[1].rmatvec(x)
|
||||
|
||||
def _matmat(self, x):
|
||||
return self.args[0].matmat(x) + self.args[1].matmat(x)
|
||||
|
||||
def _adjoint(self):
|
||||
A, B = self.args
|
||||
return A.H + B.H
|
||||
|
||||
|
||||
class _ProductLinearOperator(LinearOperator):
|
||||
def __init__(self, A, B):
|
||||
if not isinstance(A, LinearOperator) or \
|
||||
not isinstance(B, LinearOperator):
|
||||
raise ValueError('both operands have to be a LinearOperator')
|
||||
if A.shape[1] != B.shape[0]:
|
||||
raise ValueError('cannot multiply %r and %r: shape mismatch'
|
||||
% (A, B))
|
||||
super(_ProductLinearOperator, self).__init__(_get_dtype([A, B]),
|
||||
(A.shape[0], B.shape[1]))
|
||||
self.args = (A, B)
|
||||
|
||||
def _matvec(self, x):
|
||||
return self.args[0].matvec(self.args[1].matvec(x))
|
||||
|
||||
def _rmatvec(self, x):
|
||||
return self.args[1].rmatvec(self.args[0].rmatvec(x))
|
||||
|
||||
def _matmat(self, x):
|
||||
return self.args[0].matmat(self.args[1].matmat(x))
|
||||
|
||||
def _adjoint(self):
|
||||
A, B = self.args
|
||||
return B.H * A.H
|
||||
|
||||
|
||||
class _ScaledLinearOperator(LinearOperator):
|
||||
def __init__(self, A, alpha):
|
||||
if not isinstance(A, LinearOperator):
|
||||
raise ValueError('LinearOperator expected as A')
|
||||
if not np.isscalar(alpha):
|
||||
raise ValueError('scalar expected as alpha')
|
||||
dtype = _get_dtype([A], [type(alpha)])
|
||||
super(_ScaledLinearOperator, self).__init__(dtype, A.shape)
|
||||
self.args = (A, alpha)
|
||||
|
||||
def _matvec(self, x):
|
||||
return self.args[1] * self.args[0].matvec(x)
|
||||
|
||||
def _rmatvec(self, x):
|
||||
return np.conj(self.args[1]) * self.args[0].rmatvec(x)
|
||||
|
||||
def _matmat(self, x):
|
||||
return self.args[1] * self.args[0].matmat(x)
|
||||
|
||||
def _adjoint(self):
|
||||
A, alpha = self.args
|
||||
return A.H * np.conj(alpha)
|
||||
|
||||
|
||||
class _PowerLinearOperator(LinearOperator):
|
||||
def __init__(self, A, p):
|
||||
if not isinstance(A, LinearOperator):
|
||||
raise ValueError('LinearOperator expected as A')
|
||||
if A.shape[0] != A.shape[1]:
|
||||
raise ValueError('square LinearOperator expected, got %r' % A)
|
||||
if not isintlike(p) or p < 0:
|
||||
raise ValueError('non-negative integer expected as p')
|
||||
|
||||
super(_PowerLinearOperator, self).__init__(_get_dtype([A]), A.shape)
|
||||
self.args = (A, p)
|
||||
|
||||
def _power(self, fun, x):
|
||||
res = np.array(x, copy=True)
|
||||
for i in range(self.args[1]):
|
||||
res = fun(res)
|
||||
return res
|
||||
|
||||
def _matvec(self, x):
|
||||
return self._power(self.args[0].matvec, x)
|
||||
|
||||
def _rmatvec(self, x):
|
||||
return self._power(self.args[0].rmatvec, x)
|
||||
|
||||
def _matmat(self, x):
|
||||
return self._power(self.args[0].matmat, x)
|
||||
|
||||
def _adjoint(self):
|
||||
A, p = self.args
|
||||
return A.H ** p
|
||||
|
||||
|
||||
class MatrixLinearOperator(LinearOperator):
|
||||
def __init__(self, A):
|
||||
super(MatrixLinearOperator, self).__init__(A.dtype, A.shape)
|
||||
self.A = A
|
||||
self.__adj = None
|
||||
self.args = (A,)
|
||||
|
||||
def _matmat(self, X):
|
||||
return self.A.dot(X)
|
||||
|
||||
def _adjoint(self):
|
||||
if self.__adj is None:
|
||||
self.__adj = _AdjointMatrixOperator(self)
|
||||
return self.__adj
|
||||
|
||||
|
||||
class _AdjointMatrixOperator(MatrixLinearOperator):
|
||||
def __init__(self, adjoint):
|
||||
self.A = adjoint.A.T.conj()
|
||||
self.__adjoint = adjoint
|
||||
self.args = (adjoint,)
|
||||
self.shape = adjoint.shape[1], adjoint.shape[0]
|
||||
|
||||
@property
|
||||
def dtype(self):
|
||||
return self.__adjoint.dtype
|
||||
|
||||
def _adjoint(self):
|
||||
return self.__adjoint
|
||||
|
||||
|
||||
class IdentityOperator(LinearOperator):
|
||||
def __init__(self, shape, dtype=None):
|
||||
super(IdentityOperator, self).__init__(dtype, shape)
|
||||
|
||||
def _matvec(self, x):
|
||||
return x
|
||||
|
||||
def _rmatvec(self, x):
|
||||
return x
|
||||
|
||||
def _matmat(self, x):
|
||||
return x
|
||||
|
||||
def _adjoint(self):
|
||||
return self
|
||||
|
||||
|
||||
def aslinearoperator(A):
|
||||
"""Return A as a LinearOperator.
|
||||
|
||||
'A' may be any of the following types:
|
||||
- ndarray
|
||||
- matrix
|
||||
- sparse matrix (e.g. csr_matrix, lil_matrix, etc.)
|
||||
- LinearOperator
|
||||
- An object with .shape and .matvec attributes
|
||||
|
||||
See the LinearOperator documentation for additional information.
|
||||
|
||||
Notes
|
||||
-----
|
||||
If 'A' has no .dtype attribute, the data type is determined by calling
|
||||
:func:`LinearOperator.matvec()` - set the .dtype attribute to prevent this
|
||||
call upon the linear operator creation.
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> from scipy.sparse.linalg import aslinearoperator
|
||||
>>> M = np.array([[1,2,3],[4,5,6]], dtype=np.int32)
|
||||
>>> aslinearoperator(M)
|
||||
<2x3 MatrixLinearOperator with dtype=int32>
|
||||
"""
|
||||
if isinstance(A, LinearOperator):
|
||||
return A
|
||||
|
||||
elif isinstance(A, np.ndarray) or isinstance(A, np.matrix):
|
||||
if A.ndim > 2:
|
||||
raise ValueError('array must have ndim <= 2')
|
||||
A = np.atleast_2d(np.asarray(A))
|
||||
return MatrixLinearOperator(A)
|
||||
|
||||
elif isspmatrix(A):
|
||||
return MatrixLinearOperator(A)
|
||||
|
||||
else:
|
||||
if hasattr(A, 'shape') and hasattr(A, 'matvec'):
|
||||
rmatvec = None
|
||||
dtype = None
|
||||
|
||||
if hasattr(A, 'rmatvec'):
|
||||
rmatvec = A.rmatvec
|
||||
if hasattr(A, 'dtype'):
|
||||
dtype = A.dtype
|
||||
return LinearOperator(A.shape, A.matvec,
|
||||
rmatvec=rmatvec, dtype=dtype)
|
||||
|
||||
else:
|
||||
raise TypeError('type not understood')
|
||||
@@ -0,0 +1,17 @@
|
||||
"Iterative Solvers for Sparse Linear Systems"
|
||||
|
||||
from __future__ import division, print_function, absolute_import
|
||||
|
||||
#from info import __doc__
|
||||
from .iterative import *
|
||||
from .minres import minres
|
||||
from .lgmres import lgmres
|
||||
from .lsqr import lsqr
|
||||
from .lsmr import lsmr
|
||||
from ._gcrotmk import gcrotmk
|
||||
|
||||
__all__ = [s for s in dir() if not s.startswith('_')]
|
||||
|
||||
from scipy._lib._testutils import PytestTester
|
||||
test = PytestTester(__name__)
|
||||
del PytestTester
|
||||
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
@@ -0,0 +1,487 @@
|
||||
# Copyright (C) 2015, Pauli Virtanen <pav@iki.fi>
|
||||
# Distributed under the same license as Scipy.
|
||||
|
||||
from __future__ import division, print_function, absolute_import
|
||||
|
||||
import warnings
|
||||
import numpy as np
|
||||
from numpy.linalg import LinAlgError
|
||||
from scipy._lib.six import xrange
|
||||
from scipy.linalg import (get_blas_funcs, qr, solve, svd, qr_insert, lstsq)
|
||||
from scipy.sparse.linalg.isolve.utils import make_system
|
||||
|
||||
|
||||
__all__ = ['gcrotmk']
|
||||
|
||||
|
||||
def _fgmres(matvec, v0, m, atol, lpsolve=None, rpsolve=None, cs=(), outer_v=(),
|
||||
prepend_outer_v=False):
|
||||
"""
|
||||
FGMRES Arnoldi process, with optional projection or augmentation
|
||||
|
||||
Parameters
|
||||
----------
|
||||
matvec : callable
|
||||
Operation A*x
|
||||
v0 : ndarray
|
||||
Initial vector, normalized to nrm2(v0) == 1
|
||||
m : int
|
||||
Number of GMRES rounds
|
||||
atol : float
|
||||
Absolute tolerance for early exit
|
||||
lpsolve : callable
|
||||
Left preconditioner L
|
||||
rpsolve : callable
|
||||
Right preconditioner R
|
||||
CU : list of (ndarray, ndarray)
|
||||
Columns of matrices C and U in GCROT
|
||||
outer_v : list of ndarrays
|
||||
Augmentation vectors in LGMRES
|
||||
prepend_outer_v : bool, optional
|
||||
Whether augmentation vectors come before or after
|
||||
Krylov iterates
|
||||
|
||||
Raises
|
||||
------
|
||||
LinAlgError
|
||||
If nans encountered
|
||||
|
||||
Returns
|
||||
-------
|
||||
Q, R : ndarray
|
||||
QR decomposition of the upper Hessenberg H=QR
|
||||
B : ndarray
|
||||
Projections corresponding to matrix C
|
||||
vs : list of ndarray
|
||||
Columns of matrix V
|
||||
zs : list of ndarray
|
||||
Columns of matrix Z
|
||||
y : ndarray
|
||||
Solution to ||H y - e_1||_2 = min!
|
||||
res : float
|
||||
The final (preconditioned) residual norm
|
||||
|
||||
"""
|
||||
|
||||
if lpsolve is None:
|
||||
lpsolve = lambda x: x
|
||||
if rpsolve is None:
|
||||
rpsolve = lambda x: x
|
||||
|
||||
axpy, dot, scal, nrm2 = get_blas_funcs(['axpy', 'dot', 'scal', 'nrm2'], (v0,))
|
||||
|
||||
vs = [v0]
|
||||
zs = []
|
||||
y = None
|
||||
res = np.nan
|
||||
|
||||
m = m + len(outer_v)
|
||||
|
||||
# Orthogonal projection coefficients
|
||||
B = np.zeros((len(cs), m), dtype=v0.dtype)
|
||||
|
||||
# H is stored in QR factorized form
|
||||
Q = np.ones((1, 1), dtype=v0.dtype)
|
||||
R = np.zeros((1, 0), dtype=v0.dtype)
|
||||
|
||||
eps = np.finfo(v0.dtype).eps
|
||||
|
||||
breakdown = False
|
||||
|
||||
# FGMRES Arnoldi process
|
||||
for j in xrange(m):
|
||||
# L A Z = C B + V H
|
||||
|
||||
if prepend_outer_v and j < len(outer_v):
|
||||
z, w = outer_v[j]
|
||||
elif prepend_outer_v and j == len(outer_v):
|
||||
z = rpsolve(v0)
|
||||
w = None
|
||||
elif not prepend_outer_v and j >= m - len(outer_v):
|
||||
z, w = outer_v[j - (m - len(outer_v))]
|
||||
else:
|
||||
z = rpsolve(vs[-1])
|
||||
w = None
|
||||
|
||||
if w is None:
|
||||
w = lpsolve(matvec(z))
|
||||
else:
|
||||
# w is clobbered below
|
||||
w = w.copy()
|
||||
|
||||
w_norm = nrm2(w)
|
||||
|
||||
# GCROT projection: L A -> (1 - C C^H) L A
|
||||
# i.e. orthogonalize against C
|
||||
for i, c in enumerate(cs):
|
||||
alpha = dot(c, w)
|
||||
B[i,j] = alpha
|
||||
w = axpy(c, w, c.shape[0], -alpha) # w -= alpha*c
|
||||
|
||||
# Orthogonalize against V
|
||||
hcur = np.zeros(j+2, dtype=Q.dtype)
|
||||
for i, v in enumerate(vs):
|
||||
alpha = dot(v, w)
|
||||
hcur[i] = alpha
|
||||
w = axpy(v, w, v.shape[0], -alpha) # w -= alpha*v
|
||||
hcur[i+1] = nrm2(w)
|
||||
|
||||
with np.errstate(over='ignore', divide='ignore'):
|
||||
# Careful with denormals
|
||||
alpha = 1/hcur[-1]
|
||||
|
||||
if np.isfinite(alpha):
|
||||
w = scal(alpha, w)
|
||||
|
||||
if not (hcur[-1] > eps * w_norm):
|
||||
# w essentially in the span of previous vectors,
|
||||
# or we have nans. Bail out after updating the QR
|
||||
# solution.
|
||||
breakdown = True
|
||||
|
||||
vs.append(w)
|
||||
zs.append(z)
|
||||
|
||||
# Arnoldi LSQ problem
|
||||
|
||||
# Add new column to H=Q*R, padding other columns with zeros
|
||||
Q2 = np.zeros((j+2, j+2), dtype=Q.dtype, order='F')
|
||||
Q2[:j+1,:j+1] = Q
|
||||
Q2[j+1,j+1] = 1
|
||||
|
||||
R2 = np.zeros((j+2, j), dtype=R.dtype, order='F')
|
||||
R2[:j+1,:] = R
|
||||
|
||||
Q, R = qr_insert(Q2, R2, hcur, j, which='col',
|
||||
overwrite_qru=True, check_finite=False)
|
||||
|
||||
# Transformed least squares problem
|
||||
# || Q R y - inner_res_0 * e_1 ||_2 = min!
|
||||
# Since R = [R'; 0], solution is y = inner_res_0 (R')^{-1} (Q^H)[:j,0]
|
||||
|
||||
# Residual is immediately known
|
||||
res = abs(Q[0,-1])
|
||||
|
||||
# Check for termination
|
||||
if res < atol or breakdown:
|
||||
break
|
||||
|
||||
if not np.isfinite(R[j,j]):
|
||||
# nans encountered, bail out
|
||||
raise LinAlgError()
|
||||
|
||||
# -- Get the LSQ problem solution
|
||||
|
||||
# The problem is triangular, but the condition number may be
|
||||
# bad (or in case of breakdown the last diagonal entry may be
|
||||
# zero), so use lstsq instead of trtrs.
|
||||
y, _, _, _, = lstsq(R[:j+1,:j+1], Q[0,:j+1].conj())
|
||||
|
||||
B = B[:,:j+1]
|
||||
|
||||
return Q, R, B, vs, zs, y, res
|
||||
|
||||
|
||||
def gcrotmk(A, b, x0=None, tol=1e-5, maxiter=1000, M=None, callback=None,
|
||||
m=20, k=None, CU=None, discard_C=False, truncate='oldest',
|
||||
atol=None):
|
||||
"""
|
||||
Solve a matrix equation using flexible GCROT(m,k) algorithm.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
A : {sparse matrix, dense matrix, LinearOperator}
|
||||
The real or complex N-by-N matrix of the linear system.
|
||||
b : {array, matrix}
|
||||
Right hand side of the linear system. Has shape (N,) or (N,1).
|
||||
x0 : {array, matrix}
|
||||
Starting guess for the solution.
|
||||
tol, atol : float, optional
|
||||
Tolerances for convergence, ``norm(residual) <= max(tol*norm(b), atol)``.
|
||||
The default for ``atol`` is `tol`.
|
||||
|
||||
.. warning::
|
||||
|
||||
The default value for `atol` will be changed in a future release.
|
||||
For future compatibility, specify `atol` explicitly.
|
||||
maxiter : int, optional
|
||||
Maximum number of iterations. Iteration will stop after maxiter
|
||||
steps even if the specified tolerance has not been achieved.
|
||||
M : {sparse matrix, dense matrix, LinearOperator}, optional
|
||||
Preconditioner for A. The preconditioner should approximate the
|
||||
inverse of A. gcrotmk is a 'flexible' algorithm and the preconditioner
|
||||
can vary from iteration to iteration. Effective preconditioning
|
||||
dramatically improves the rate of convergence, which implies that
|
||||
fewer iterations are needed to reach a given error tolerance.
|
||||
callback : function, optional
|
||||
User-supplied function to call after each iteration. It is called
|
||||
as callback(xk), where xk is the current solution vector.
|
||||
m : int, optional
|
||||
Number of inner FGMRES iterations per each outer iteration.
|
||||
Default: 20
|
||||
k : int, optional
|
||||
Number of vectors to carry between inner FGMRES iterations.
|
||||
According to [2]_, good values are around m.
|
||||
Default: m
|
||||
CU : list of tuples, optional
|
||||
List of tuples ``(c, u)`` which contain the columns of the matrices
|
||||
C and U in the GCROT(m,k) algorithm. For details, see [2]_.
|
||||
The list given and vectors contained in it are modified in-place.
|
||||
If not given, start from empty matrices. The ``c`` elements in the
|
||||
tuples can be ``None``, in which case the vectors are recomputed
|
||||
via ``c = A u`` on start and orthogonalized as described in [3]_.
|
||||
discard_C : bool, optional
|
||||
Discard the C-vectors at the end. Useful if recycling Krylov subspaces
|
||||
for different linear systems.
|
||||
truncate : {'oldest', 'smallest'}, optional
|
||||
Truncation scheme to use. Drop: oldest vectors, or vectors with
|
||||
smallest singular values using the scheme discussed in [1,2].
|
||||
See [2]_ for detailed comparison.
|
||||
Default: 'oldest'
|
||||
|
||||
Returns
|
||||
-------
|
||||
x : array or matrix
|
||||
The solution found.
|
||||
info : int
|
||||
Provides convergence information:
|
||||
|
||||
* 0 : successful exit
|
||||
* >0 : convergence to tolerance not achieved, number of iterations
|
||||
|
||||
References
|
||||
----------
|
||||
.. [1] E. de Sturler, ''Truncation strategies for optimal Krylov subspace
|
||||
methods'', SIAM J. Numer. Anal. 36, 864 (1999).
|
||||
.. [2] J.E. Hicken and D.W. Zingg, ''A simplified and flexible variant
|
||||
of GCROT for solving nonsymmetric linear systems'',
|
||||
SIAM J. Sci. Comput. 32, 172 (2010).
|
||||
.. [3] M.L. Parks, E. de Sturler, G. Mackey, D.D. Johnson, S. Maiti,
|
||||
''Recycling Krylov subspaces for sequences of linear systems'',
|
||||
SIAM J. Sci. Comput. 28, 1651 (2006).
|
||||
|
||||
"""
|
||||
A,M,x,b,postprocess = make_system(A,M,x0,b)
|
||||
|
||||
if not np.isfinite(b).all():
|
||||
raise ValueError("RHS must contain only finite numbers")
|
||||
|
||||
if truncate not in ('oldest', 'smallest'):
|
||||
raise ValueError("Invalid value for 'truncate': %r" % (truncate,))
|
||||
|
||||
if atol is None:
|
||||
warnings.warn("scipy.sparse.linalg.gcrotmk called without specifying `atol`. "
|
||||
"The default value will change in the future. To preserve "
|
||||
"current behavior, set ``atol=tol``.",
|
||||
category=DeprecationWarning, stacklevel=2)
|
||||
atol = tol
|
||||
|
||||
matvec = A.matvec
|
||||
psolve = M.matvec
|
||||
|
||||
if CU is None:
|
||||
CU = []
|
||||
|
||||
if k is None:
|
||||
k = m
|
||||
|
||||
axpy, dot, scal = None, None, None
|
||||
|
||||
r = b - matvec(x)
|
||||
|
||||
axpy, dot, scal, nrm2 = get_blas_funcs(['axpy', 'dot', 'scal', 'nrm2'], (x, r))
|
||||
|
||||
b_norm = nrm2(b)
|
||||
|
||||
if discard_C:
|
||||
CU[:] = [(None, u) for c, u in CU]
|
||||
|
||||
# Reorthogonalize old vectors
|
||||
if CU:
|
||||
# Sort already existing vectors to the front
|
||||
CU.sort(key=lambda cu: cu[0] is not None)
|
||||
|
||||
# Fill-in missing ones
|
||||
C = np.empty((A.shape[0], len(CU)), dtype=r.dtype, order='F')
|
||||
us = []
|
||||
j = 0
|
||||
while CU:
|
||||
# More memory-efficient: throw away old vectors as we go
|
||||
c, u = CU.pop(0)
|
||||
if c is None:
|
||||
c = matvec(u)
|
||||
C[:,j] = c
|
||||
j += 1
|
||||
us.append(u)
|
||||
|
||||
# Orthogonalize
|
||||
Q, R, P = qr(C, overwrite_a=True, mode='economic', pivoting=True)
|
||||
del C
|
||||
|
||||
# C := Q
|
||||
cs = list(Q.T)
|
||||
|
||||
# U := U P R^-1, back-substitution
|
||||
new_us = []
|
||||
for j in xrange(len(cs)):
|
||||
u = us[P[j]]
|
||||
for i in xrange(j):
|
||||
u = axpy(us[P[i]], u, u.shape[0], -R[i,j])
|
||||
if abs(R[j,j]) < 1e-12 * abs(R[0,0]):
|
||||
# discard rest of the vectors
|
||||
break
|
||||
u = scal(1.0/R[j,j], u)
|
||||
new_us.append(u)
|
||||
|
||||
# Form the new CU lists
|
||||
CU[:] = list(zip(cs, new_us))[::-1]
|
||||
|
||||
if CU:
|
||||
axpy, dot = get_blas_funcs(['axpy', 'dot'], (r,))
|
||||
|
||||
# Solve first the projection operation with respect to the CU
|
||||
# vectors. This corresponds to modifying the initial guess to
|
||||
# be
|
||||
#
|
||||
# x' = x + U y
|
||||
# y = argmin_y || b - A (x + U y) ||^2
|
||||
#
|
||||
# The solution is y = C^H (b - A x)
|
||||
for c, u in CU:
|
||||
yc = dot(c, r)
|
||||
x = axpy(u, x, x.shape[0], yc)
|
||||
r = axpy(c, r, r.shape[0], -yc)
|
||||
|
||||
# GCROT main iteration
|
||||
for j_outer in xrange(maxiter):
|
||||
# -- callback
|
||||
if callback is not None:
|
||||
callback(x)
|
||||
|
||||
beta = nrm2(r)
|
||||
|
||||
# -- check stopping condition
|
||||
beta_tol = max(atol, tol * b_norm)
|
||||
|
||||
if beta <= beta_tol and (j_outer > 0 or CU):
|
||||
# recompute residual to avoid rounding error
|
||||
r = b - matvec(x)
|
||||
beta = nrm2(r)
|
||||
|
||||
if beta <= beta_tol:
|
||||
j_outer = -1
|
||||
break
|
||||
|
||||
ml = m + max(k - len(CU), 0)
|
||||
|
||||
cs = [c for c, u in CU]
|
||||
|
||||
try:
|
||||
Q, R, B, vs, zs, y, pres = _fgmres(matvec,
|
||||
r/beta,
|
||||
ml,
|
||||
rpsolve=psolve,
|
||||
atol=max(atol, tol*b_norm)/beta,
|
||||
cs=cs)
|
||||
y *= beta
|
||||
except LinAlgError:
|
||||
# Floating point over/underflow, non-finite result from
|
||||
# matmul etc. -- report failure.
|
||||
break
|
||||
|
||||
#
|
||||
# At this point,
|
||||
#
|
||||
# [A U, A Z] = [C, V] G; G = [ I B ]
|
||||
# [ 0 H ]
|
||||
#
|
||||
# where [C, V] has orthonormal columns, and r = beta v_0. Moreover,
|
||||
#
|
||||
# || b - A (x + Z y + U q) ||_2 = || r - C B y - V H y - C q ||_2 = min!
|
||||
#
|
||||
# from which y = argmin_y || beta e_1 - H y ||_2, and q = -B y
|
||||
#
|
||||
|
||||
#
|
||||
# GCROT(m,k) update
|
||||
#
|
||||
|
||||
# Define new outer vectors
|
||||
|
||||
# ux := (Z - U B) y
|
||||
ux = zs[0]*y[0]
|
||||
for z, yc in zip(zs[1:], y[1:]):
|
||||
ux = axpy(z, ux, ux.shape[0], yc) # ux += z*yc
|
||||
by = B.dot(y)
|
||||
for cu, byc in zip(CU, by):
|
||||
c, u = cu
|
||||
ux = axpy(u, ux, ux.shape[0], -byc) # ux -= u*byc
|
||||
|
||||
# cx := V H y
|
||||
hy = Q.dot(R.dot(y))
|
||||
cx = vs[0] * hy[0]
|
||||
for v, hyc in zip(vs[1:], hy[1:]):
|
||||
cx = axpy(v, cx, cx.shape[0], hyc) # cx += v*hyc
|
||||
|
||||
# Normalize cx, maintaining cx = A ux
|
||||
# This new cx is orthogonal to the previous C, by construction
|
||||
try:
|
||||
alpha = 1/nrm2(cx)
|
||||
if not np.isfinite(alpha):
|
||||
raise FloatingPointError()
|
||||
except (FloatingPointError, ZeroDivisionError):
|
||||
# Cannot update, so skip it
|
||||
continue
|
||||
|
||||
cx = scal(alpha, cx)
|
||||
ux = scal(alpha, ux)
|
||||
|
||||
# Update residual and solution
|
||||
gamma = dot(cx, r)
|
||||
r = axpy(cx, r, r.shape[0], -gamma) # r -= gamma*cx
|
||||
x = axpy(ux, x, x.shape[0], gamma) # x += gamma*ux
|
||||
|
||||
# Truncate CU
|
||||
if truncate == 'oldest':
|
||||
while len(CU) >= k and CU:
|
||||
del CU[0]
|
||||
elif truncate == 'smallest':
|
||||
if len(CU) >= k and CU:
|
||||
# cf. [1,2]
|
||||
D = solve(R[:-1,:].T, B.T).T
|
||||
W, sigma, V = svd(D)
|
||||
|
||||
# C := C W[:,:k-1], U := U W[:,:k-1]
|
||||
new_CU = []
|
||||
for j, w in enumerate(W[:,:k-1].T):
|
||||
c, u = CU[0]
|
||||
c = c * w[0]
|
||||
u = u * w[0]
|
||||
for cup, wp in zip(CU[1:], w[1:]):
|
||||
cp, up = cup
|
||||
c = axpy(cp, c, c.shape[0], wp)
|
||||
u = axpy(up, u, u.shape[0], wp)
|
||||
|
||||
# Reorthogonalize at the same time; not necessary
|
||||
# in exact arithmetic, but floating point error
|
||||
# tends to accumulate here
|
||||
for cp, up in new_CU:
|
||||
alpha = dot(cp, c)
|
||||
c = axpy(cp, c, c.shape[0], -alpha)
|
||||
u = axpy(up, u, u.shape[0], -alpha)
|
||||
alpha = nrm2(c)
|
||||
c = scal(1.0/alpha, c)
|
||||
u = scal(1.0/alpha, u)
|
||||
|
||||
new_CU.append((c, u))
|
||||
CU[:] = new_CU
|
||||
|
||||
# Add new vector to CU
|
||||
CU.append((cx, ux))
|
||||
|
||||
# Include the solution vector to the span
|
||||
CU.append((None, x.copy()))
|
||||
if discard_C:
|
||||
CU[:] = [(None, uz) for cz, uz in CU]
|
||||
|
||||
return postprocess(x), j_outer + 1
|
||||
BIN
Binary file not shown.
@@ -0,0 +1,753 @@
|
||||
"""Iterative methods for solving linear systems"""
|
||||
|
||||
from __future__ import division, print_function, absolute_import
|
||||
|
||||
__all__ = ['bicg','bicgstab','cg','cgs','gmres','qmr']
|
||||
|
||||
import warnings
|
||||
import numpy as np
|
||||
|
||||
from . import _iterative
|
||||
|
||||
from scipy.sparse.linalg.interface import LinearOperator
|
||||
from .utils import make_system
|
||||
from scipy._lib._util import _aligned_zeros
|
||||
from scipy._lib._threadsafety import non_reentrant
|
||||
|
||||
_type_conv = {'f':'s', 'd':'d', 'F':'c', 'D':'z'}
|
||||
|
||||
|
||||
# Part of the docstring common to all iterative solvers
|
||||
common_doc1 = \
|
||||
"""
|
||||
Parameters
|
||||
----------
|
||||
A : {sparse matrix, dense matrix, LinearOperator}"""
|
||||
|
||||
common_doc2 = \
|
||||
"""b : {array, matrix}
|
||||
Right hand side of the linear system. Has shape (N,) or (N,1).
|
||||
|
||||
Returns
|
||||
-------
|
||||
x : {array, matrix}
|
||||
The converged solution.
|
||||
info : integer
|
||||
Provides convergence information:
|
||||
0 : successful exit
|
||||
>0 : convergence to tolerance not achieved, number of iterations
|
||||
<0 : illegal input or breakdown
|
||||
|
||||
Other Parameters
|
||||
----------------
|
||||
x0 : {array, matrix}
|
||||
Starting guess for the solution.
|
||||
tol, atol : float, optional
|
||||
Tolerances for convergence, ``norm(residual) <= max(tol*norm(b), atol)``.
|
||||
The default for ``atol`` is ``'legacy'``, which emulates
|
||||
a different legacy behavior.
|
||||
|
||||
.. warning::
|
||||
|
||||
The default value for `atol` will be changed in a future release.
|
||||
For future compatibility, specify `atol` explicitly.
|
||||
maxiter : integer
|
||||
Maximum number of iterations. Iteration will stop after maxiter
|
||||
steps even if the specified tolerance has not been achieved.
|
||||
M : {sparse matrix, dense matrix, LinearOperator}
|
||||
Preconditioner for A. The preconditioner should approximate the
|
||||
inverse of A. Effective preconditioning dramatically improves the
|
||||
rate of convergence, which implies that fewer iterations are needed
|
||||
to reach a given error tolerance.
|
||||
callback : function
|
||||
User-supplied function to call after each iteration. It is called
|
||||
as callback(xk), where xk is the current solution vector.
|
||||
|
||||
"""
|
||||
|
||||
|
||||
def _stoptest(residual, atol):
|
||||
"""
|
||||
Successful termination condition for the solvers.
|
||||
"""
|
||||
resid = np.linalg.norm(residual)
|
||||
if resid <= atol:
|
||||
return resid, 1
|
||||
else:
|
||||
return resid, 0
|
||||
|
||||
|
||||
def _get_atol(tol, atol, bnrm2, get_residual, routine_name):
|
||||
"""
|
||||
Parse arguments for absolute tolerance in termination condition.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
tol, atol : object
|
||||
The arguments passed into the solver routine by user.
|
||||
bnrm2 : float
|
||||
2-norm of the rhs vector.
|
||||
get_residual : callable
|
||||
Callable ``get_residual()`` that returns the initial value of
|
||||
the residual.
|
||||
routine_name : str
|
||||
Name of the routine.
|
||||
"""
|
||||
|
||||
if atol is None:
|
||||
warnings.warn("scipy.sparse.linalg.{name} called without specifying `atol`. "
|
||||
"The default value will be changed in a future release. "
|
||||
"For compatibility, specify a value for `atol` explicitly, e.g., "
|
||||
"``{name}(..., atol=0)``, or to retain the old behavior "
|
||||
"``{name}(..., atol='legacy')``".format(name=routine_name),
|
||||
category=DeprecationWarning, stacklevel=4)
|
||||
atol = 'legacy'
|
||||
|
||||
tol = float(tol)
|
||||
|
||||
if atol == 'legacy':
|
||||
# emulate old legacy behavior
|
||||
resid = get_residual()
|
||||
if resid <= tol:
|
||||
return 'exit'
|
||||
if bnrm2 == 0:
|
||||
return tol
|
||||
else:
|
||||
return tol * float(bnrm2)
|
||||
else:
|
||||
return max(float(atol), tol * float(bnrm2))
|
||||
|
||||
|
||||
def set_docstring(header, Ainfo, footer='', atol_default='0'):
|
||||
def combine(fn):
|
||||
fn.__doc__ = '\n'.join((header, common_doc1,
|
||||
' ' + Ainfo.replace('\n', '\n '),
|
||||
common_doc2, footer))
|
||||
return fn
|
||||
return combine
|
||||
|
||||
|
||||
@set_docstring('Use BIConjugate Gradient iteration to solve ``Ax = b``.',
|
||||
'The real or complex N-by-N matrix of the linear system.\n'
|
||||
'It is required that the linear operator can produce\n'
|
||||
'``Ax`` and ``A^T x``.')
|
||||
@non_reentrant()
|
||||
def bicg(A, b, x0=None, tol=1e-5, maxiter=None, M=None, callback=None, atol=None):
|
||||
A,M,x,b,postprocess = make_system(A, M, x0, b)
|
||||
|
||||
n = len(b)
|
||||
if maxiter is None:
|
||||
maxiter = n*10
|
||||
|
||||
matvec, rmatvec = A.matvec, A.rmatvec
|
||||
psolve, rpsolve = M.matvec, M.rmatvec
|
||||
ltr = _type_conv[x.dtype.char]
|
||||
revcom = getattr(_iterative, ltr + 'bicgrevcom')
|
||||
|
||||
get_residual = lambda: np.linalg.norm(matvec(x) - b)
|
||||
atol = _get_atol(tol, atol, np.linalg.norm(b), get_residual, 'bicg')
|
||||
if atol == 'exit':
|
||||
return postprocess(x), 0
|
||||
|
||||
resid = atol
|
||||
ndx1 = 1
|
||||
ndx2 = -1
|
||||
# Use _aligned_zeros to work around a f2py bug in Numpy 1.9.1
|
||||
work = _aligned_zeros(6*n,dtype=x.dtype)
|
||||
ijob = 1
|
||||
info = 0
|
||||
ftflag = True
|
||||
iter_ = maxiter
|
||||
while True:
|
||||
olditer = iter_
|
||||
x, iter_, resid, info, ndx1, ndx2, sclr1, sclr2, ijob = \
|
||||
revcom(b, x, work, iter_, resid, info, ndx1, ndx2, ijob)
|
||||
if callback is not None and iter_ > olditer:
|
||||
callback(x)
|
||||
slice1 = slice(ndx1-1, ndx1-1+n)
|
||||
slice2 = slice(ndx2-1, ndx2-1+n)
|
||||
if (ijob == -1):
|
||||
if callback is not None:
|
||||
callback(x)
|
||||
break
|
||||
elif (ijob == 1):
|
||||
work[slice2] *= sclr2
|
||||
work[slice2] += sclr1*matvec(work[slice1])
|
||||
elif (ijob == 2):
|
||||
work[slice2] *= sclr2
|
||||
work[slice2] += sclr1*rmatvec(work[slice1])
|
||||
elif (ijob == 3):
|
||||
work[slice1] = psolve(work[slice2])
|
||||
elif (ijob == 4):
|
||||
work[slice1] = rpsolve(work[slice2])
|
||||
elif (ijob == 5):
|
||||
work[slice2] *= sclr2
|
||||
work[slice2] += sclr1*matvec(x)
|
||||
elif (ijob == 6):
|
||||
if ftflag:
|
||||
info = -1
|
||||
ftflag = False
|
||||
resid, info = _stoptest(work[slice1], atol)
|
||||
ijob = 2
|
||||
|
||||
if info > 0 and iter_ == maxiter and not (resid <= atol):
|
||||
# info isn't set appropriately otherwise
|
||||
info = iter_
|
||||
|
||||
return postprocess(x), info
|
||||
|
||||
|
||||
@set_docstring('Use BIConjugate Gradient STABilized iteration to solve '
|
||||
'``Ax = b``.',
|
||||
'The real or complex N-by-N matrix of the linear system.')
|
||||
@non_reentrant()
|
||||
def bicgstab(A, b, x0=None, tol=1e-5, maxiter=None, M=None, callback=None, atol=None):
|
||||
A, M, x, b, postprocess = make_system(A, M, x0, b)
|
||||
|
||||
n = len(b)
|
||||
if maxiter is None:
|
||||
maxiter = n*10
|
||||
|
||||
matvec = A.matvec
|
||||
psolve = M.matvec
|
||||
ltr = _type_conv[x.dtype.char]
|
||||
revcom = getattr(_iterative, ltr + 'bicgstabrevcom')
|
||||
|
||||
get_residual = lambda: np.linalg.norm(matvec(x) - b)
|
||||
atol = _get_atol(tol, atol, np.linalg.norm(b), get_residual, 'bicgstab')
|
||||
if atol == 'exit':
|
||||
return postprocess(x), 0
|
||||
|
||||
resid = atol
|
||||
ndx1 = 1
|
||||
ndx2 = -1
|
||||
# Use _aligned_zeros to work around a f2py bug in Numpy 1.9.1
|
||||
work = _aligned_zeros(7*n,dtype=x.dtype)
|
||||
ijob = 1
|
||||
info = 0
|
||||
ftflag = True
|
||||
iter_ = maxiter
|
||||
while True:
|
||||
olditer = iter_
|
||||
x, iter_, resid, info, ndx1, ndx2, sclr1, sclr2, ijob = \
|
||||
revcom(b, x, work, iter_, resid, info, ndx1, ndx2, ijob)
|
||||
if callback is not None and iter_ > olditer:
|
||||
callback(x)
|
||||
slice1 = slice(ndx1-1, ndx1-1+n)
|
||||
slice2 = slice(ndx2-1, ndx2-1+n)
|
||||
if (ijob == -1):
|
||||
if callback is not None:
|
||||
callback(x)
|
||||
break
|
||||
elif (ijob == 1):
|
||||
work[slice2] *= sclr2
|
||||
work[slice2] += sclr1*matvec(work[slice1])
|
||||
elif (ijob == 2):
|
||||
work[slice1] = psolve(work[slice2])
|
||||
elif (ijob == 3):
|
||||
work[slice2] *= sclr2
|
||||
work[slice2] += sclr1*matvec(x)
|
||||
elif (ijob == 4):
|
||||
if ftflag:
|
||||
info = -1
|
||||
ftflag = False
|
||||
resid, info = _stoptest(work[slice1], atol)
|
||||
ijob = 2
|
||||
|
||||
if info > 0 and iter_ == maxiter and not (resid <= atol):
|
||||
# info isn't set appropriately otherwise
|
||||
info = iter_
|
||||
|
||||
return postprocess(x), info
|
||||
|
||||
|
||||
@set_docstring('Use Conjugate Gradient iteration to solve ``Ax = b``.',
|
||||
'The real or complex N-by-N matrix of the linear system.\n'
|
||||
'``A`` must represent a hermitian, positive definite matrix.')
|
||||
@non_reentrant()
|
||||
def cg(A, b, x0=None, tol=1e-5, maxiter=None, M=None, callback=None, atol=None):
|
||||
A, M, x, b, postprocess = make_system(A, M, x0, b)
|
||||
|
||||
n = len(b)
|
||||
if maxiter is None:
|
||||
maxiter = n*10
|
||||
|
||||
matvec = A.matvec
|
||||
psolve = M.matvec
|
||||
ltr = _type_conv[x.dtype.char]
|
||||
revcom = getattr(_iterative, ltr + 'cgrevcom')
|
||||
|
||||
get_residual = lambda: np.linalg.norm(matvec(x) - b)
|
||||
atol = _get_atol(tol, atol, np.linalg.norm(b), get_residual, 'cg')
|
||||
if atol == 'exit':
|
||||
return postprocess(x), 0
|
||||
|
||||
resid = atol
|
||||
ndx1 = 1
|
||||
ndx2 = -1
|
||||
# Use _aligned_zeros to work around a f2py bug in Numpy 1.9.1
|
||||
work = _aligned_zeros(4*n,dtype=x.dtype)
|
||||
ijob = 1
|
||||
info = 0
|
||||
ftflag = True
|
||||
iter_ = maxiter
|
||||
while True:
|
||||
olditer = iter_
|
||||
x, iter_, resid, info, ndx1, ndx2, sclr1, sclr2, ijob = \
|
||||
revcom(b, x, work, iter_, resid, info, ndx1, ndx2, ijob)
|
||||
if callback is not None and iter_ > olditer:
|
||||
callback(x)
|
||||
slice1 = slice(ndx1-1, ndx1-1+n)
|
||||
slice2 = slice(ndx2-1, ndx2-1+n)
|
||||
if (ijob == -1):
|
||||
if callback is not None:
|
||||
callback(x)
|
||||
break
|
||||
elif (ijob == 1):
|
||||
work[slice2] *= sclr2
|
||||
work[slice2] += sclr1*matvec(work[slice1])
|
||||
elif (ijob == 2):
|
||||
work[slice1] = psolve(work[slice2])
|
||||
elif (ijob == 3):
|
||||
work[slice2] *= sclr2
|
||||
work[slice2] += sclr1*matvec(x)
|
||||
elif (ijob == 4):
|
||||
if ftflag:
|
||||
info = -1
|
||||
ftflag = False
|
||||
resid, info = _stoptest(work[slice1], atol)
|
||||
if info == 1 and iter_ > 1:
|
||||
# recompute residual and recheck, to avoid
|
||||
# accumulating rounding error
|
||||
work[slice1] = b - matvec(x)
|
||||
resid, info = _stoptest(work[slice1], atol)
|
||||
ijob = 2
|
||||
|
||||
if info > 0 and iter_ == maxiter and not (resid <= atol):
|
||||
# info isn't set appropriately otherwise
|
||||
info = iter_
|
||||
|
||||
return postprocess(x), info
|
||||
|
||||
|
||||
@set_docstring('Use Conjugate Gradient Squared iteration to solve ``Ax = b``.',
|
||||
'The real-valued N-by-N matrix of the linear system.')
|
||||
@non_reentrant()
|
||||
def cgs(A, b, x0=None, tol=1e-5, maxiter=None, M=None, callback=None, atol=None):
|
||||
A, M, x, b, postprocess = make_system(A, M, x0, b)
|
||||
|
||||
n = len(b)
|
||||
if maxiter is None:
|
||||
maxiter = n*10
|
||||
|
||||
matvec = A.matvec
|
||||
psolve = M.matvec
|
||||
ltr = _type_conv[x.dtype.char]
|
||||
revcom = getattr(_iterative, ltr + 'cgsrevcom')
|
||||
|
||||
get_residual = lambda: np.linalg.norm(matvec(x) - b)
|
||||
atol = _get_atol(tol, atol, np.linalg.norm(b), get_residual, 'cgs')
|
||||
if atol == 'exit':
|
||||
return postprocess(x), 0
|
||||
|
||||
resid = atol
|
||||
ndx1 = 1
|
||||
ndx2 = -1
|
||||
# Use _aligned_zeros to work around a f2py bug in Numpy 1.9.1
|
||||
work = _aligned_zeros(7*n,dtype=x.dtype)
|
||||
ijob = 1
|
||||
info = 0
|
||||
ftflag = True
|
||||
iter_ = maxiter
|
||||
while True:
|
||||
olditer = iter_
|
||||
x, iter_, resid, info, ndx1, ndx2, sclr1, sclr2, ijob = \
|
||||
revcom(b, x, work, iter_, resid, info, ndx1, ndx2, ijob)
|
||||
if callback is not None and iter_ > olditer:
|
||||
callback(x)
|
||||
slice1 = slice(ndx1-1, ndx1-1+n)
|
||||
slice2 = slice(ndx2-1, ndx2-1+n)
|
||||
if (ijob == -1):
|
||||
if callback is not None:
|
||||
callback(x)
|
||||
break
|
||||
elif (ijob == 1):
|
||||
work[slice2] *= sclr2
|
||||
work[slice2] += sclr1*matvec(work[slice1])
|
||||
elif (ijob == 2):
|
||||
work[slice1] = psolve(work[slice2])
|
||||
elif (ijob == 3):
|
||||
work[slice2] *= sclr2
|
||||
work[slice2] += sclr1*matvec(x)
|
||||
elif (ijob == 4):
|
||||
if ftflag:
|
||||
info = -1
|
||||
ftflag = False
|
||||
resid, info = _stoptest(work[slice1], atol)
|
||||
if info == 1 and iter_ > 1:
|
||||
# recompute residual and recheck, to avoid
|
||||
# accumulating rounding error
|
||||
work[slice1] = b - matvec(x)
|
||||
resid, info = _stoptest(work[slice1], atol)
|
||||
ijob = 2
|
||||
|
||||
if info == -10:
|
||||
# termination due to breakdown: check for convergence
|
||||
resid, ok = _stoptest(b - matvec(x), atol)
|
||||
if ok:
|
||||
info = 0
|
||||
|
||||
if info > 0 and iter_ == maxiter and not (resid <= atol):
|
||||
# info isn't set appropriately otherwise
|
||||
info = iter_
|
||||
|
||||
return postprocess(x), info
|
||||
|
||||
|
||||
@non_reentrant()
|
||||
def gmres(A, b, x0=None, tol=1e-5, restart=None, maxiter=None, M=None, callback=None,
|
||||
restrt=None, atol=None):
|
||||
"""
|
||||
Use Generalized Minimal RESidual iteration to solve ``Ax = b``.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
A : {sparse matrix, dense matrix, LinearOperator}
|
||||
The real or complex N-by-N matrix of the linear system.
|
||||
b : {array, matrix}
|
||||
Right hand side of the linear system. Has shape (N,) or (N,1).
|
||||
|
||||
Returns
|
||||
-------
|
||||
x : {array, matrix}
|
||||
The converged solution.
|
||||
info : int
|
||||
Provides convergence information:
|
||||
* 0 : successful exit
|
||||
* >0 : convergence to tolerance not achieved, number of iterations
|
||||
* <0 : illegal input or breakdown
|
||||
|
||||
Other parameters
|
||||
----------------
|
||||
x0 : {array, matrix}
|
||||
Starting guess for the solution (a vector of zeros by default).
|
||||
tol, atol : float, optional
|
||||
Tolerances for convergence, ``norm(residual) <= max(tol*norm(b), atol)``.
|
||||
The default for ``atol`` is ``'legacy'``, which emulates
|
||||
a different legacy behavior.
|
||||
|
||||
.. warning::
|
||||
|
||||
The default value for `atol` will be changed in a future release.
|
||||
For future compatibility, specify `atol` explicitly.
|
||||
restart : int, optional
|
||||
Number of iterations between restarts. Larger values increase
|
||||
iteration cost, but may be necessary for convergence.
|
||||
Default is 20.
|
||||
maxiter : int, optional
|
||||
Maximum number of iterations (restart cycles). Iteration will stop
|
||||
after maxiter steps even if the specified tolerance has not been
|
||||
achieved.
|
||||
M : {sparse matrix, dense matrix, LinearOperator}
|
||||
Inverse of the preconditioner of A. M should approximate the
|
||||
inverse of A and be easy to solve for (see Notes). Effective
|
||||
preconditioning dramatically improves the rate of convergence,
|
||||
which implies that fewer iterations are needed to reach a given
|
||||
error tolerance. By default, no preconditioner is used.
|
||||
callback : function
|
||||
User-supplied function to call after each iteration. It is called
|
||||
as callback(rk), where rk is the current residual vector.
|
||||
restrt : int, optional
|
||||
DEPRECATED - use `restart` instead.
|
||||
|
||||
See Also
|
||||
--------
|
||||
LinearOperator
|
||||
|
||||
Notes
|
||||
-----
|
||||
A preconditioner, P, is chosen such that P is close to A but easy to solve
|
||||
for. The preconditioner parameter required by this routine is
|
||||
``M = P^-1``. The inverse should preferably not be calculated
|
||||
explicitly. Rather, use the following template to produce M::
|
||||
|
||||
# Construct a linear operator that computes P^-1 * x.
|
||||
import scipy.sparse.linalg as spla
|
||||
M_x = lambda x: spla.spsolve(P, x)
|
||||
M = spla.LinearOperator((n, n), M_x)
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> from scipy.sparse import csc_matrix
|
||||
>>> from scipy.sparse.linalg import gmres
|
||||
>>> A = csc_matrix([[3, 2, 0], [1, -1, 0], [0, 5, 1]], dtype=float)
|
||||
>>> b = np.array([2, 4, -1], dtype=float)
|
||||
>>> x, exitCode = gmres(A, b)
|
||||
>>> print(exitCode) # 0 indicates successful convergence
|
||||
0
|
||||
>>> np.allclose(A.dot(x), b)
|
||||
True
|
||||
"""
|
||||
|
||||
# Change 'restrt' keyword to 'restart'
|
||||
if restrt is None:
|
||||
restrt = restart
|
||||
elif restart is not None:
|
||||
raise ValueError("Cannot specify both restart and restrt keywords. "
|
||||
"Preferably use 'restart' only.")
|
||||
|
||||
A, M, x, b,postprocess = make_system(A, M, x0, b)
|
||||
|
||||
n = len(b)
|
||||
if maxiter is None:
|
||||
maxiter = n*10
|
||||
|
||||
if restrt is None:
|
||||
restrt = 20
|
||||
restrt = min(restrt, n)
|
||||
|
||||
matvec = A.matvec
|
||||
psolve = M.matvec
|
||||
ltr = _type_conv[x.dtype.char]
|
||||
revcom = getattr(_iterative, ltr + 'gmresrevcom')
|
||||
|
||||
bnrm2 = np.linalg.norm(b)
|
||||
Mb_nrm2 = np.linalg.norm(psolve(b))
|
||||
get_residual = lambda: np.linalg.norm(matvec(x) - b)
|
||||
atol = _get_atol(tol, atol, bnrm2, get_residual, 'gmres')
|
||||
if atol == 'exit':
|
||||
return postprocess(x), 0
|
||||
|
||||
if bnrm2 == 0:
|
||||
return postprocess(b), 0
|
||||
|
||||
# Tolerance passed to GMRESREVCOM applies to the inner iteration
|
||||
# and deals with the left-preconditioned residual.
|
||||
ptol_max_factor = 1.0
|
||||
ptol = Mb_nrm2 * min(ptol_max_factor, atol / bnrm2)
|
||||
resid = np.nan
|
||||
presid = np.nan
|
||||
ndx1 = 1
|
||||
ndx2 = -1
|
||||
# Use _aligned_zeros to work around a f2py bug in Numpy 1.9.1
|
||||
work = _aligned_zeros((6+restrt)*n,dtype=x.dtype)
|
||||
work2 = _aligned_zeros((restrt+1)*(2*restrt+2),dtype=x.dtype)
|
||||
ijob = 1
|
||||
info = 0
|
||||
ftflag = True
|
||||
iter_ = maxiter
|
||||
old_ijob = ijob
|
||||
first_pass = True
|
||||
resid_ready = False
|
||||
iter_num = 1
|
||||
while True:
|
||||
x, iter_, presid, info, ndx1, ndx2, sclr1, sclr2, ijob = \
|
||||
revcom(b, x, restrt, work, work2, iter_, presid, info, ndx1, ndx2, ijob, ptol)
|
||||
slice1 = slice(ndx1-1, ndx1-1+n)
|
||||
slice2 = slice(ndx2-1, ndx2-1+n)
|
||||
if (ijob == -1): # gmres success, update last residual
|
||||
if resid_ready and callback is not None:
|
||||
callback(presid / bnrm2)
|
||||
resid_ready = False
|
||||
break
|
||||
elif (ijob == 1):
|
||||
work[slice2] *= sclr2
|
||||
work[slice2] += sclr1*matvec(x)
|
||||
elif (ijob == 2):
|
||||
work[slice1] = psolve(work[slice2])
|
||||
if not first_pass and old_ijob == 3:
|
||||
resid_ready = True
|
||||
|
||||
first_pass = False
|
||||
elif (ijob == 3):
|
||||
work[slice2] *= sclr2
|
||||
work[slice2] += sclr1*matvec(work[slice1])
|
||||
if resid_ready and callback is not None:
|
||||
callback(presid / bnrm2)
|
||||
resid_ready = False
|
||||
iter_num = iter_num+1
|
||||
|
||||
elif (ijob == 4):
|
||||
if ftflag:
|
||||
info = -1
|
||||
ftflag = False
|
||||
resid, info = _stoptest(work[slice1], atol)
|
||||
|
||||
# Inner loop tolerance control
|
||||
if info or presid > ptol:
|
||||
ptol_max_factor = min(1.0, 1.5 * ptol_max_factor)
|
||||
else:
|
||||
# Inner loop tolerance OK, but outer loop not.
|
||||
ptol_max_factor = max(1e-16, 0.25 * ptol_max_factor)
|
||||
|
||||
if resid != 0:
|
||||
ptol = presid * min(ptol_max_factor, atol / resid)
|
||||
else:
|
||||
ptol = presid * ptol_max_factor
|
||||
|
||||
old_ijob = ijob
|
||||
ijob = 2
|
||||
|
||||
if iter_num > maxiter:
|
||||
info = maxiter
|
||||
break
|
||||
|
||||
if info >= 0 and not (resid <= atol):
|
||||
# info isn't set appropriately otherwise
|
||||
info = maxiter
|
||||
|
||||
return postprocess(x), info
|
||||
|
||||
|
||||
@non_reentrant()
|
||||
def qmr(A, b, x0=None, tol=1e-5, maxiter=None, M1=None, M2=None, callback=None,
|
||||
atol=None):
|
||||
"""Use Quasi-Minimal Residual iteration to solve ``Ax = b``.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
A : {sparse matrix, dense matrix, LinearOperator}
|
||||
The real-valued N-by-N matrix of the linear system.
|
||||
It is required that the linear operator can produce
|
||||
``Ax`` and ``A^T x``.
|
||||
b : {array, matrix}
|
||||
Right hand side of the linear system. Has shape (N,) or (N,1).
|
||||
|
||||
Returns
|
||||
-------
|
||||
x : {array, matrix}
|
||||
The converged solution.
|
||||
info : integer
|
||||
Provides convergence information:
|
||||
0 : successful exit
|
||||
>0 : convergence to tolerance not achieved, number of iterations
|
||||
<0 : illegal input or breakdown
|
||||
|
||||
Other Parameters
|
||||
----------------
|
||||
x0 : {array, matrix}
|
||||
Starting guess for the solution.
|
||||
tol, atol : float, optional
|
||||
Tolerances for convergence, ``norm(residual) <= max(tol*norm(b), atol)``.
|
||||
The default for ``atol`` is ``'legacy'``, which emulates
|
||||
a different legacy behavior.
|
||||
|
||||
.. warning::
|
||||
|
||||
The default value for `atol` will be changed in a future release.
|
||||
For future compatibility, specify `atol` explicitly.
|
||||
maxiter : integer
|
||||
Maximum number of iterations. Iteration will stop after maxiter
|
||||
steps even if the specified tolerance has not been achieved.
|
||||
M1 : {sparse matrix, dense matrix, LinearOperator}
|
||||
Left preconditioner for A.
|
||||
M2 : {sparse matrix, dense matrix, LinearOperator}
|
||||
Right preconditioner for A. Used together with the left
|
||||
preconditioner M1. The matrix M1*A*M2 should have better
|
||||
conditioned than A alone.
|
||||
callback : function
|
||||
User-supplied function to call after each iteration. It is called
|
||||
as callback(xk), where xk is the current solution vector.
|
||||
|
||||
See Also
|
||||
--------
|
||||
LinearOperator
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> from scipy.sparse import csc_matrix
|
||||
>>> from scipy.sparse.linalg import qmr
|
||||
>>> A = csc_matrix([[3, 2, 0], [1, -1, 0], [0, 5, 1]], dtype=float)
|
||||
>>> b = np.array([2, 4, -1], dtype=float)
|
||||
>>> x, exitCode = qmr(A, b)
|
||||
>>> print(exitCode) # 0 indicates successful convergence
|
||||
0
|
||||
>>> np.allclose(A.dot(x), b)
|
||||
True
|
||||
"""
|
||||
A_ = A
|
||||
A, M, x, b, postprocess = make_system(A, None, x0, b)
|
||||
|
||||
if M1 is None and M2 is None:
|
||||
if hasattr(A_,'psolve'):
|
||||
def left_psolve(b):
|
||||
return A_.psolve(b,'left')
|
||||
|
||||
def right_psolve(b):
|
||||
return A_.psolve(b,'right')
|
||||
|
||||
def left_rpsolve(b):
|
||||
return A_.rpsolve(b,'left')
|
||||
|
||||
def right_rpsolve(b):
|
||||
return A_.rpsolve(b,'right')
|
||||
M1 = LinearOperator(A.shape, matvec=left_psolve, rmatvec=left_rpsolve)
|
||||
M2 = LinearOperator(A.shape, matvec=right_psolve, rmatvec=right_rpsolve)
|
||||
else:
|
||||
def id(b):
|
||||
return b
|
||||
M1 = LinearOperator(A.shape, matvec=id, rmatvec=id)
|
||||
M2 = LinearOperator(A.shape, matvec=id, rmatvec=id)
|
||||
|
||||
n = len(b)
|
||||
if maxiter is None:
|
||||
maxiter = n*10
|
||||
|
||||
ltr = _type_conv[x.dtype.char]
|
||||
revcom = getattr(_iterative, ltr + 'qmrrevcom')
|
||||
|
||||
get_residual = lambda: np.linalg.norm(A.matvec(x) - b)
|
||||
atol = _get_atol(tol, atol, np.linalg.norm(b), get_residual, 'qmr')
|
||||
if atol == 'exit':
|
||||
return postprocess(x), 0
|
||||
|
||||
resid = atol
|
||||
ndx1 = 1
|
||||
ndx2 = -1
|
||||
# Use _aligned_zeros to work around a f2py bug in Numpy 1.9.1
|
||||
work = _aligned_zeros(11*n,x.dtype)
|
||||
ijob = 1
|
||||
info = 0
|
||||
ftflag = True
|
||||
iter_ = maxiter
|
||||
while True:
|
||||
olditer = iter_
|
||||
x, iter_, resid, info, ndx1, ndx2, sclr1, sclr2, ijob = \
|
||||
revcom(b, x, work, iter_, resid, info, ndx1, ndx2, ijob)
|
||||
if callback is not None and iter_ > olditer:
|
||||
callback(x)
|
||||
slice1 = slice(ndx1-1, ndx1-1+n)
|
||||
slice2 = slice(ndx2-1, ndx2-1+n)
|
||||
if (ijob == -1):
|
||||
if callback is not None:
|
||||
callback(x)
|
||||
break
|
||||
elif (ijob == 1):
|
||||
work[slice2] *= sclr2
|
||||
work[slice2] += sclr1*A.matvec(work[slice1])
|
||||
elif (ijob == 2):
|
||||
work[slice2] *= sclr2
|
||||
work[slice2] += sclr1*A.rmatvec(work[slice1])
|
||||
elif (ijob == 3):
|
||||
work[slice1] = M1.matvec(work[slice2])
|
||||
elif (ijob == 4):
|
||||
work[slice1] = M2.matvec(work[slice2])
|
||||
elif (ijob == 5):
|
||||
work[slice1] = M1.rmatvec(work[slice2])
|
||||
elif (ijob == 6):
|
||||
work[slice1] = M2.rmatvec(work[slice2])
|
||||
elif (ijob == 7):
|
||||
work[slice2] *= sclr2
|
||||
work[slice2] += sclr1*A.matvec(x)
|
||||
elif (ijob == 8):
|
||||
if ftflag:
|
||||
info = -1
|
||||
ftflag = False
|
||||
resid, info = _stoptest(work[slice1], atol)
|
||||
ijob = 2
|
||||
|
||||
if info > 0 and iter_ == maxiter and not (resid <= atol):
|
||||
# info isn't set appropriately otherwise
|
||||
info = iter_
|
||||
|
||||
return postprocess(x), info
|
||||
@@ -0,0 +1,232 @@
|
||||
# Copyright (C) 2009, Pauli Virtanen <pav@iki.fi>
|
||||
# Distributed under the same license as Scipy.
|
||||
|
||||
from __future__ import division, print_function, absolute_import
|
||||
|
||||
import warnings
|
||||
import numpy as np
|
||||
from numpy.linalg import LinAlgError
|
||||
from scipy._lib.six import xrange
|
||||
from scipy.linalg import get_blas_funcs, get_lapack_funcs
|
||||
from .utils import make_system
|
||||
|
||||
from ._gcrotmk import _fgmres
|
||||
|
||||
__all__ = ['lgmres']
|
||||
|
||||
|
||||
def lgmres(A, b, x0=None, tol=1e-5, maxiter=1000, M=None, callback=None,
|
||||
inner_m=30, outer_k=3, outer_v=None, store_outer_Av=True,
|
||||
prepend_outer_v=False, atol=None):
|
||||
"""
|
||||
Solve a matrix equation using the LGMRES algorithm.
|
||||
|
||||
The LGMRES algorithm [1]_ [2]_ is designed to avoid some problems
|
||||
in the convergence in restarted GMRES, and often converges in fewer
|
||||
iterations.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
A : {sparse matrix, dense matrix, LinearOperator}
|
||||
The real or complex N-by-N matrix of the linear system.
|
||||
b : {array, matrix}
|
||||
Right hand side of the linear system. Has shape (N,) or (N,1).
|
||||
x0 : {array, matrix}
|
||||
Starting guess for the solution.
|
||||
tol, atol : float, optional
|
||||
Tolerances for convergence, ``norm(residual) <= max(tol*norm(b), atol)``.
|
||||
The default for ``atol`` is `tol`.
|
||||
|
||||
.. warning::
|
||||
|
||||
The default value for `atol` will be changed in a future release.
|
||||
For future compatibility, specify `atol` explicitly.
|
||||
maxiter : int, optional
|
||||
Maximum number of iterations. Iteration will stop after maxiter
|
||||
steps even if the specified tolerance has not been achieved.
|
||||
M : {sparse matrix, dense matrix, LinearOperator}, optional
|
||||
Preconditioner for A. The preconditioner should approximate the
|
||||
inverse of A. Effective preconditioning dramatically improves the
|
||||
rate of convergence, which implies that fewer iterations are needed
|
||||
to reach a given error tolerance.
|
||||
callback : function, optional
|
||||
User-supplied function to call after each iteration. It is called
|
||||
as callback(xk), where xk is the current solution vector.
|
||||
inner_m : int, optional
|
||||
Number of inner GMRES iterations per each outer iteration.
|
||||
outer_k : int, optional
|
||||
Number of vectors to carry between inner GMRES iterations.
|
||||
According to [1]_, good values are in the range of 1...3.
|
||||
However, note that if you want to use the additional vectors to
|
||||
accelerate solving multiple similar problems, larger values may
|
||||
be beneficial.
|
||||
outer_v : list of tuples, optional
|
||||
List containing tuples ``(v, Av)`` of vectors and corresponding
|
||||
matrix-vector products, used to augment the Krylov subspace, and
|
||||
carried between inner GMRES iterations. The element ``Av`` can
|
||||
be `None` if the matrix-vector product should be re-evaluated.
|
||||
This parameter is modified in-place by `lgmres`, and can be used
|
||||
to pass "guess" vectors in and out of the algorithm when solving
|
||||
similar problems.
|
||||
store_outer_Av : bool, optional
|
||||
Whether LGMRES should store also A*v in addition to vectors `v`
|
||||
in the `outer_v` list. Default is True.
|
||||
prepend_outer_v : bool, optional
|
||||
Whether to put outer_v augmentation vectors before Krylov iterates.
|
||||
In standard LGMRES, prepend_outer_v=False.
|
||||
|
||||
Returns
|
||||
-------
|
||||
x : array or matrix
|
||||
The converged solution.
|
||||
info : int
|
||||
Provides convergence information:
|
||||
|
||||
- 0 : successful exit
|
||||
- >0 : convergence to tolerance not achieved, number of iterations
|
||||
- <0 : illegal input or breakdown
|
||||
|
||||
Notes
|
||||
-----
|
||||
The LGMRES algorithm [1]_ [2]_ is designed to avoid the
|
||||
slowing of convergence in restarted GMRES, due to alternating
|
||||
residual vectors. Typically, it often outperforms GMRES(m) of
|
||||
comparable memory requirements by some measure, or at least is not
|
||||
much worse.
|
||||
|
||||
Another advantage in this algorithm is that you can supply it with
|
||||
'guess' vectors in the `outer_v` argument that augment the Krylov
|
||||
subspace. If the solution lies close to the span of these vectors,
|
||||
the algorithm converges faster. This can be useful if several very
|
||||
similar matrices need to be inverted one after another, such as in
|
||||
Newton-Krylov iteration where the Jacobian matrix often changes
|
||||
little in the nonlinear steps.
|
||||
|
||||
References
|
||||
----------
|
||||
.. [1] A.H. Baker and E.R. Jessup and T. Manteuffel, "A Technique for
|
||||
Accelerating the Convergence of Restarted GMRES", SIAM J. Matrix
|
||||
Anal. Appl. 26, 962 (2005).
|
||||
.. [2] A.H. Baker, "On Improving the Performance of the Linear Solver
|
||||
restarted GMRES", PhD thesis, University of Colorado (2003).
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> from scipy.sparse import csc_matrix
|
||||
>>> from scipy.sparse.linalg import lgmres
|
||||
>>> A = csc_matrix([[3, 2, 0], [1, -1, 0], [0, 5, 1]], dtype=float)
|
||||
>>> b = np.array([2, 4, -1], dtype=float)
|
||||
>>> x, exitCode = lgmres(A, b)
|
||||
>>> print(exitCode) # 0 indicates successful convergence
|
||||
0
|
||||
>>> np.allclose(A.dot(x), b)
|
||||
True
|
||||
"""
|
||||
A,M,x,b,postprocess = make_system(A,M,x0,b)
|
||||
|
||||
if not np.isfinite(b).all():
|
||||
raise ValueError("RHS must contain only finite numbers")
|
||||
|
||||
if atol is None:
|
||||
warnings.warn("scipy.sparse.linalg.lgmres called without specifying `atol`. "
|
||||
"The default value will change in the future. To preserve "
|
||||
"current behavior, set ``atol=tol``.",
|
||||
category=DeprecationWarning, stacklevel=2)
|
||||
atol = tol
|
||||
|
||||
matvec = A.matvec
|
||||
psolve = M.matvec
|
||||
|
||||
if outer_v is None:
|
||||
outer_v = []
|
||||
|
||||
axpy, dot, scal = None, None, None
|
||||
nrm2 = get_blas_funcs('nrm2', [b])
|
||||
|
||||
b_norm = nrm2(b)
|
||||
ptol_max_factor = 1.0
|
||||
|
||||
for k_outer in xrange(maxiter):
|
||||
r_outer = matvec(x) - b
|
||||
|
||||
# -- callback
|
||||
if callback is not None:
|
||||
callback(x)
|
||||
|
||||
# -- determine input type routines
|
||||
if axpy is None:
|
||||
if np.iscomplexobj(r_outer) and not np.iscomplexobj(x):
|
||||
x = x.astype(r_outer.dtype)
|
||||
axpy, dot, scal, nrm2 = get_blas_funcs(['axpy', 'dot', 'scal', 'nrm2'],
|
||||
(x, r_outer))
|
||||
|
||||
# -- check stopping condition
|
||||
r_norm = nrm2(r_outer)
|
||||
if r_norm <= max(atol, tol * b_norm):
|
||||
break
|
||||
|
||||
# -- inner LGMRES iteration
|
||||
v0 = -psolve(r_outer)
|
||||
inner_res_0 = nrm2(v0)
|
||||
|
||||
if inner_res_0 == 0:
|
||||
rnorm = nrm2(r_outer)
|
||||
raise RuntimeError("Preconditioner returned a zero vector; "
|
||||
"|v| ~ %.1g, |M v| = 0" % rnorm)
|
||||
|
||||
v0 = scal(1.0/inner_res_0, v0)
|
||||
|
||||
ptol = min(ptol_max_factor, max(atol, tol*b_norm)/r_norm)
|
||||
|
||||
try:
|
||||
Q, R, B, vs, zs, y, pres = _fgmres(matvec,
|
||||
v0,
|
||||
inner_m,
|
||||
lpsolve=psolve,
|
||||
atol=ptol,
|
||||
outer_v=outer_v,
|
||||
prepend_outer_v=prepend_outer_v)
|
||||
y *= inner_res_0
|
||||
if not np.isfinite(y).all():
|
||||
# Overflow etc. in computation. There's no way to
|
||||
# recover from this, so we have to bail out.
|
||||
raise LinAlgError()
|
||||
except LinAlgError:
|
||||
# Floating point over/underflow, non-finite result from
|
||||
# matmul etc. -- report failure.
|
||||
return postprocess(x), k_outer + 1
|
||||
|
||||
# Inner loop tolerance control
|
||||
if pres > ptol:
|
||||
ptol_max_factor = min(1.0, 1.5 * ptol_max_factor)
|
||||
else:
|
||||
ptol_max_factor = max(1e-16, 0.25 * ptol_max_factor)
|
||||
|
||||
# -- GMRES terminated: eval solution
|
||||
dx = zs[0]*y[0]
|
||||
for w, yc in zip(zs[1:], y[1:]):
|
||||
dx = axpy(w, dx, dx.shape[0], yc) # dx += w*yc
|
||||
|
||||
# -- Store LGMRES augmentation vectors
|
||||
nx = nrm2(dx)
|
||||
if nx > 0:
|
||||
if store_outer_Av:
|
||||
q = Q.dot(R.dot(y))
|
||||
ax = vs[0]*q[0]
|
||||
for v, qc in zip(vs[1:], q[1:]):
|
||||
ax = axpy(v, ax, ax.shape[0], qc)
|
||||
outer_v.append((dx/nx, ax/nx))
|
||||
else:
|
||||
outer_v.append((dx/nx, None))
|
||||
|
||||
# -- Retain only a finite number of augmentation vectors
|
||||
while len(outer_v) > outer_k:
|
||||
del outer_v[0]
|
||||
|
||||
# -- Apply step
|
||||
x += dx
|
||||
else:
|
||||
# didn't converge ...
|
||||
return postprocess(x), maxiter
|
||||
|
||||
return postprocess(x), 0
|
||||
@@ -0,0 +1,470 @@
|
||||
"""
|
||||
Copyright (C) 2010 David Fong and Michael Saunders
|
||||
|
||||
LSMR uses an iterative method.
|
||||
|
||||
07 Jun 2010: Documentation updated
|
||||
03 Jun 2010: First release version in Python
|
||||
|
||||
David Chin-lung Fong clfong@stanford.edu
|
||||
Institute for Computational and Mathematical Engineering
|
||||
Stanford University
|
||||
|
||||
Michael Saunders saunders@stanford.edu
|
||||
Systems Optimization Laboratory
|
||||
Dept of MS&E, Stanford University.
|
||||
|
||||
"""
|
||||
|
||||
from __future__ import division, print_function, absolute_import
|
||||
|
||||
__all__ = ['lsmr']
|
||||
|
||||
from numpy import zeros, infty, atleast_1d
|
||||
from numpy.linalg import norm
|
||||
from math import sqrt
|
||||
from scipy.sparse.linalg.interface import aslinearoperator
|
||||
|
||||
from .lsqr import _sym_ortho
|
||||
|
||||
|
||||
def lsmr(A, b, damp=0.0, atol=1e-6, btol=1e-6, conlim=1e8,
|
||||
maxiter=None, show=False, x0=None):
|
||||
"""Iterative solver for least-squares problems.
|
||||
|
||||
lsmr solves the system of linear equations ``Ax = b``. If the system
|
||||
is inconsistent, it solves the least-squares problem ``min ||b - Ax||_2``.
|
||||
A is a rectangular matrix of dimension m-by-n, where all cases are
|
||||
allowed: m = n, m > n, or m < n. B is a vector of length m.
|
||||
The matrix A may be dense or sparse (usually sparse).
|
||||
|
||||
Parameters
|
||||
----------
|
||||
A : {matrix, sparse matrix, ndarray, LinearOperator}
|
||||
Matrix A in the linear system.
|
||||
b : array_like, shape (m,)
|
||||
Vector b in the linear system.
|
||||
damp : float
|
||||
Damping factor for regularized least-squares. `lsmr` solves
|
||||
the regularized least-squares problem::
|
||||
|
||||
min ||(b) - ( A )x||
|
||||
||(0) (damp*I) ||_2
|
||||
|
||||
where damp is a scalar. If damp is None or 0, the system
|
||||
is solved without regularization.
|
||||
atol, btol : float, optional
|
||||
Stopping tolerances. `lsmr` continues iterations until a
|
||||
certain backward error estimate is smaller than some quantity
|
||||
depending on atol and btol. Let ``r = b - Ax`` be the
|
||||
residual vector for the current approximate solution ``x``.
|
||||
If ``Ax = b`` seems to be consistent, ``lsmr`` terminates
|
||||
when ``norm(r) <= atol * norm(A) * norm(x) + btol * norm(b)``.
|
||||
Otherwise, lsmr terminates when ``norm(A^{T} r) <=
|
||||
atol * norm(A) * norm(r)``. If both tolerances are 1.0e-6 (say),
|
||||
the final ``norm(r)`` should be accurate to about 6
|
||||
digits. (The final x will usually have fewer correct digits,
|
||||
depending on ``cond(A)`` and the size of LAMBDA.) If `atol`
|
||||
or `btol` is None, a default value of 1.0e-6 will be used.
|
||||
Ideally, they should be estimates of the relative error in the
|
||||
entries of A and B respectively. For example, if the entries
|
||||
of `A` have 7 correct digits, set atol = 1e-7. This prevents
|
||||
the algorithm from doing unnecessary work beyond the
|
||||
uncertainty of the input data.
|
||||
conlim : float, optional
|
||||
`lsmr` terminates if an estimate of ``cond(A)`` exceeds
|
||||
`conlim`. For compatible systems ``Ax = b``, conlim could be
|
||||
as large as 1.0e+12 (say). For least-squares problems,
|
||||
`conlim` should be less than 1.0e+8. If `conlim` is None, the
|
||||
default value is 1e+8. Maximum precision can be obtained by
|
||||
setting ``atol = btol = conlim = 0``, but the number of
|
||||
iterations may then be excessive.
|
||||
maxiter : int, optional
|
||||
`lsmr` terminates if the number of iterations reaches
|
||||
`maxiter`. The default is ``maxiter = min(m, n)``. For
|
||||
ill-conditioned systems, a larger value of `maxiter` may be
|
||||
needed.
|
||||
show : bool, optional
|
||||
Print iterations logs if ``show=True``.
|
||||
x0 : array_like, shape (n,), optional
|
||||
Initial guess of x, if None zeros are used.
|
||||
|
||||
.. versionadded:: 1.0.0
|
||||
Returns
|
||||
-------
|
||||
x : ndarray of float
|
||||
Least-square solution returned.
|
||||
istop : int
|
||||
istop gives the reason for stopping::
|
||||
|
||||
istop = 0 means x=0 is a solution. If x0 was given, then x=x0 is a
|
||||
solution.
|
||||
= 1 means x is an approximate solution to A*x = B,
|
||||
according to atol and btol.
|
||||
= 2 means x approximately solves the least-squares problem
|
||||
according to atol.
|
||||
= 3 means COND(A) seems to be greater than CONLIM.
|
||||
= 4 is the same as 1 with atol = btol = eps (machine
|
||||
precision)
|
||||
= 5 is the same as 2 with atol = eps.
|
||||
= 6 is the same as 3 with CONLIM = 1/eps.
|
||||
= 7 means ITN reached maxiter before the other stopping
|
||||
conditions were satisfied.
|
||||
|
||||
itn : int
|
||||
Number of iterations used.
|
||||
normr : float
|
||||
``norm(b-Ax)``
|
||||
normar : float
|
||||
``norm(A^T (b - Ax))``
|
||||
norma : float
|
||||
``norm(A)``
|
||||
conda : float
|
||||
Condition number of A.
|
||||
normx : float
|
||||
``norm(x)``
|
||||
|
||||
Notes
|
||||
-----
|
||||
|
||||
.. versionadded:: 0.11.0
|
||||
|
||||
References
|
||||
----------
|
||||
.. [1] D. C.-L. Fong and M. A. Saunders,
|
||||
"LSMR: An iterative algorithm for sparse least-squares problems",
|
||||
SIAM J. Sci. Comput., vol. 33, pp. 2950-2971, 2011.
|
||||
https://arxiv.org/abs/1006.0758
|
||||
.. [2] LSMR Software, https://web.stanford.edu/group/SOL/software/lsmr/
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> from scipy.sparse import csc_matrix
|
||||
>>> from scipy.sparse.linalg import lsmr
|
||||
>>> A = csc_matrix([[1., 0.], [1., 1.], [0., 1.]], dtype=float)
|
||||
|
||||
The first example has the trivial solution `[0, 0]`
|
||||
|
||||
>>> b = np.array([0., 0., 0.], dtype=float)
|
||||
>>> x, istop, itn, normr = lsmr(A, b)[:4]
|
||||
>>> istop
|
||||
0
|
||||
>>> x
|
||||
array([ 0., 0.])
|
||||
|
||||
The stopping code `istop=0` returned indicates that a vector of zeros was
|
||||
found as a solution. The returned solution `x` indeed contains `[0., 0.]`.
|
||||
The next example has a non-trivial solution:
|
||||
|
||||
>>> b = np.array([1., 0., -1.], dtype=float)
|
||||
>>> x, istop, itn, normr = lsmr(A, b)[:4]
|
||||
>>> istop
|
||||
1
|
||||
>>> x
|
||||
array([ 1., -1.])
|
||||
>>> itn
|
||||
1
|
||||
>>> normr
|
||||
4.440892098500627e-16
|
||||
|
||||
As indicated by `istop=1`, `lsmr` found a solution obeying the tolerance
|
||||
limits. The given solution `[1., -1.]` obviously solves the equation. The
|
||||
remaining return values include information about the number of iterations
|
||||
(`itn=1`) and the remaining difference of left and right side of the solved
|
||||
equation.
|
||||
The final example demonstrates the behavior in the case where there is no
|
||||
solution for the equation:
|
||||
|
||||
>>> b = np.array([1., 0.01, -1.], dtype=float)
|
||||
>>> x, istop, itn, normr = lsmr(A, b)[:4]
|
||||
>>> istop
|
||||
2
|
||||
>>> x
|
||||
array([ 1.00333333, -0.99666667])
|
||||
>>> A.dot(x)-b
|
||||
array([ 0.00333333, -0.00333333, 0.00333333])
|
||||
>>> normr
|
||||
0.005773502691896255
|
||||
|
||||
`istop` indicates that the system is inconsistent and thus `x` is rather an
|
||||
approximate solution to the corresponding least-squares problem. `normr`
|
||||
contains the minimal distance that was found.
|
||||
"""
|
||||
|
||||
A = aslinearoperator(A)
|
||||
b = atleast_1d(b)
|
||||
if b.ndim > 1:
|
||||
b = b.squeeze()
|
||||
|
||||
msg = ('The exact solution is x = 0, or x = x0, if x0 was given ',
|
||||
'Ax - b is small enough, given atol, btol ',
|
||||
'The least-squares solution is good enough, given atol ',
|
||||
'The estimate of cond(Abar) has exceeded conlim ',
|
||||
'Ax - b is small enough for this machine ',
|
||||
'The least-squares solution is good enough for this machine',
|
||||
'Cond(Abar) seems to be too large for this machine ',
|
||||
'The iteration limit has been reached ')
|
||||
|
||||
hdg1 = ' itn x(1) norm r norm A''r'
|
||||
hdg2 = ' compatible LS norm A cond A'
|
||||
pfreq = 20 # print frequency (for repeating the heading)
|
||||
pcount = 0 # print counter
|
||||
|
||||
m, n = A.shape
|
||||
|
||||
# stores the num of singular values
|
||||
minDim = min([m, n])
|
||||
|
||||
if maxiter is None:
|
||||
maxiter = minDim
|
||||
|
||||
if show:
|
||||
print(' ')
|
||||
print('LSMR Least-squares solution of Ax = b\n')
|
||||
print('The matrix A has %8g rows and %8g cols' % (m, n))
|
||||
print('damp = %20.14e\n' % (damp))
|
||||
print('atol = %8.2e conlim = %8.2e\n' % (atol, conlim))
|
||||
print('btol = %8.2e maxiter = %8g\n' % (btol, maxiter))
|
||||
|
||||
u = b
|
||||
normb = norm(b)
|
||||
if x0 is None:
|
||||
x = zeros(n)
|
||||
beta = normb.copy()
|
||||
else:
|
||||
x = atleast_1d(x0)
|
||||
u = u - A.matvec(x)
|
||||
beta = norm(u)
|
||||
|
||||
if beta > 0:
|
||||
u = (1 / beta) * u
|
||||
v = A.rmatvec(u)
|
||||
alpha = norm(v)
|
||||
else:
|
||||
v = zeros(n)
|
||||
alpha = 0
|
||||
|
||||
if alpha > 0:
|
||||
v = (1 / alpha) * v
|
||||
|
||||
# Initialize variables for 1st iteration.
|
||||
|
||||
itn = 0
|
||||
zetabar = alpha * beta
|
||||
alphabar = alpha
|
||||
rho = 1
|
||||
rhobar = 1
|
||||
cbar = 1
|
||||
sbar = 0
|
||||
|
||||
h = v.copy()
|
||||
hbar = zeros(n)
|
||||
|
||||
# Initialize variables for estimation of ||r||.
|
||||
|
||||
betadd = beta
|
||||
betad = 0
|
||||
rhodold = 1
|
||||
tautildeold = 0
|
||||
thetatilde = 0
|
||||
zeta = 0
|
||||
d = 0
|
||||
|
||||
# Initialize variables for estimation of ||A|| and cond(A)
|
||||
|
||||
normA2 = alpha * alpha
|
||||
maxrbar = 0
|
||||
minrbar = 1e+100
|
||||
normA = sqrt(normA2)
|
||||
condA = 1
|
||||
normx = 0
|
||||
|
||||
# Items for use in stopping rules, normb set earlier
|
||||
istop = 0
|
||||
ctol = 0
|
||||
if conlim > 0:
|
||||
ctol = 1 / conlim
|
||||
normr = beta
|
||||
|
||||
# Reverse the order here from the original matlab code because
|
||||
# there was an error on return when arnorm==0
|
||||
normar = alpha * beta
|
||||
if normar == 0:
|
||||
if show:
|
||||
print(msg[0])
|
||||
return x, istop, itn, normr, normar, normA, condA, normx
|
||||
|
||||
if show:
|
||||
print(' ')
|
||||
print(hdg1, hdg2)
|
||||
test1 = 1
|
||||
test2 = alpha / beta
|
||||
str1 = '%6g %12.5e' % (itn, x[0])
|
||||
str2 = ' %10.3e %10.3e' % (normr, normar)
|
||||
str3 = ' %8.1e %8.1e' % (test1, test2)
|
||||
print(''.join([str1, str2, str3]))
|
||||
|
||||
# Main iteration loop.
|
||||
while itn < maxiter:
|
||||
itn = itn + 1
|
||||
|
||||
# Perform the next step of the bidiagonalization to obtain the
|
||||
# next beta, u, alpha, v. These satisfy the relations
|
||||
# beta*u = a*v - alpha*u,
|
||||
# alpha*v = A'*u - beta*v.
|
||||
|
||||
u = A.matvec(v) - alpha * u
|
||||
beta = norm(u)
|
||||
|
||||
if beta > 0:
|
||||
u = (1 / beta) * u
|
||||
v = A.rmatvec(u) - beta * v
|
||||
alpha = norm(v)
|
||||
if alpha > 0:
|
||||
v = (1 / alpha) * v
|
||||
|
||||
# At this point, beta = beta_{k+1}, alpha = alpha_{k+1}.
|
||||
|
||||
# Construct rotation Qhat_{k,2k+1}.
|
||||
|
||||
chat, shat, alphahat = _sym_ortho(alphabar, damp)
|
||||
|
||||
# Use a plane rotation (Q_i) to turn B_i to R_i
|
||||
|
||||
rhoold = rho
|
||||
c, s, rho = _sym_ortho(alphahat, beta)
|
||||
thetanew = s*alpha
|
||||
alphabar = c*alpha
|
||||
|
||||
# Use a plane rotation (Qbar_i) to turn R_i^T to R_i^bar
|
||||
|
||||
rhobarold = rhobar
|
||||
zetaold = zeta
|
||||
thetabar = sbar * rho
|
||||
rhotemp = cbar * rho
|
||||
cbar, sbar, rhobar = _sym_ortho(cbar * rho, thetanew)
|
||||
zeta = cbar * zetabar
|
||||
zetabar = - sbar * zetabar
|
||||
|
||||
# Update h, h_hat, x.
|
||||
|
||||
hbar = h - (thetabar * rho / (rhoold * rhobarold)) * hbar
|
||||
x = x + (zeta / (rho * rhobar)) * hbar
|
||||
h = v - (thetanew / rho) * h
|
||||
|
||||
# Estimate of ||r||.
|
||||
|
||||
# Apply rotation Qhat_{k,2k+1}.
|
||||
betaacute = chat * betadd
|
||||
betacheck = -shat * betadd
|
||||
|
||||
# Apply rotation Q_{k,k+1}.
|
||||
betahat = c * betaacute
|
||||
betadd = -s * betaacute
|
||||
|
||||
# Apply rotation Qtilde_{k-1}.
|
||||
# betad = betad_{k-1} here.
|
||||
|
||||
thetatildeold = thetatilde
|
||||
ctildeold, stildeold, rhotildeold = _sym_ortho(rhodold, thetabar)
|
||||
thetatilde = stildeold * rhobar
|
||||
rhodold = ctildeold * rhobar
|
||||
betad = - stildeold * betad + ctildeold * betahat
|
||||
|
||||
# betad = betad_k here.
|
||||
# rhodold = rhod_k here.
|
||||
|
||||
tautildeold = (zetaold - thetatildeold * tautildeold) / rhotildeold
|
||||
taud = (zeta - thetatilde * tautildeold) / rhodold
|
||||
d = d + betacheck * betacheck
|
||||
normr = sqrt(d + (betad - taud)**2 + betadd * betadd)
|
||||
|
||||
# Estimate ||A||.
|
||||
normA2 = normA2 + beta * beta
|
||||
normA = sqrt(normA2)
|
||||
normA2 = normA2 + alpha * alpha
|
||||
|
||||
# Estimate cond(A).
|
||||
maxrbar = max(maxrbar, rhobarold)
|
||||
if itn > 1:
|
||||
minrbar = min(minrbar, rhobarold)
|
||||
condA = max(maxrbar, rhotemp) / min(minrbar, rhotemp)
|
||||
|
||||
# Test for convergence.
|
||||
|
||||
# Compute norms for convergence testing.
|
||||
normar = abs(zetabar)
|
||||
normx = norm(x)
|
||||
|
||||
# Now use these norms to estimate certain other quantities,
|
||||
# some of which will be small near a solution.
|
||||
|
||||
test1 = normr / normb
|
||||
if (normA * normr) != 0:
|
||||
test2 = normar / (normA * normr)
|
||||
else:
|
||||
test2 = infty
|
||||
test3 = 1 / condA
|
||||
t1 = test1 / (1 + normA * normx / normb)
|
||||
rtol = btol + atol * normA * normx / normb
|
||||
|
||||
# The following tests guard against extremely small values of
|
||||
# atol, btol or ctol. (The user may have set any or all of
|
||||
# the parameters atol, btol, conlim to 0.)
|
||||
# The effect is equivalent to the normAl tests using
|
||||
# atol = eps, btol = eps, conlim = 1/eps.
|
||||
|
||||
if itn >= maxiter:
|
||||
istop = 7
|
||||
if 1 + test3 <= 1:
|
||||
istop = 6
|
||||
if 1 + test2 <= 1:
|
||||
istop = 5
|
||||
if 1 + t1 <= 1:
|
||||
istop = 4
|
||||
|
||||
# Allow for tolerances set by the user.
|
||||
|
||||
if test3 <= ctol:
|
||||
istop = 3
|
||||
if test2 <= atol:
|
||||
istop = 2
|
||||
if test1 <= rtol:
|
||||
istop = 1
|
||||
|
||||
# See if it is time to print something.
|
||||
|
||||
if show:
|
||||
if (n <= 40) or (itn <= 10) or (itn >= maxiter - 10) or \
|
||||
(itn % 10 == 0) or (test3 <= 1.1 * ctol) or \
|
||||
(test2 <= 1.1 * atol) or (test1 <= 1.1 * rtol) or \
|
||||
(istop != 0):
|
||||
|
||||
if pcount >= pfreq:
|
||||
pcount = 0
|
||||
print(' ')
|
||||
print(hdg1, hdg2)
|
||||
pcount = pcount + 1
|
||||
str1 = '%6g %12.5e' % (itn, x[0])
|
||||
str2 = ' %10.3e %10.3e' % (normr, normar)
|
||||
str3 = ' %8.1e %8.1e' % (test1, test2)
|
||||
str4 = ' %8.1e %8.1e' % (normA, condA)
|
||||
print(''.join([str1, str2, str3, str4]))
|
||||
|
||||
if istop > 0:
|
||||
break
|
||||
|
||||
# Print the stopping condition.
|
||||
|
||||
if show:
|
||||
print(' ')
|
||||
print('LSMR finished')
|
||||
print(msg[istop])
|
||||
print('istop =%8g normr =%8.1e' % (istop, normr))
|
||||
print(' normA =%8.1e normAr =%8.1e' % (normA, normar))
|
||||
print('itn =%8g condA =%8.1e' % (itn, condA))
|
||||
print(' normx =%8.1e' % (normx))
|
||||
print(str1, str2)
|
||||
print(str3, str4)
|
||||
|
||||
return x, istop, itn, normr, normar, normA, condA, normx
|
||||
@@ -0,0 +1,568 @@
|
||||
"""Sparse Equations and Least Squares.
|
||||
|
||||
The original Fortran code was written by C. C. Paige and M. A. Saunders as
|
||||
described in
|
||||
|
||||
C. C. Paige and M. A. Saunders, LSQR: An algorithm for sparse linear
|
||||
equations and sparse least squares, TOMS 8(1), 43--71 (1982).
|
||||
|
||||
C. C. Paige and M. A. Saunders, Algorithm 583; LSQR: Sparse linear
|
||||
equations and least-squares problems, TOMS 8(2), 195--209 (1982).
|
||||
|
||||
It is licensed under the following BSD license:
|
||||
|
||||
Copyright (c) 2006, Systems Optimization Laboratory
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are
|
||||
met:
|
||||
|
||||
* Redistributions of source code must retain the above copyright
|
||||
notice, this list of conditions and the following disclaimer.
|
||||
|
||||
* Redistributions in binary form must reproduce the above
|
||||
copyright notice, this list of conditions and the following
|
||||
disclaimer in the documentation and/or other materials provided
|
||||
with the distribution.
|
||||
|
||||
* Neither the name of Stanford University nor the names of its
|
||||
contributors may be used to endorse or promote products derived
|
||||
from this software without specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
The Fortran code was translated to Python for use in CVXOPT by Jeffery
|
||||
Kline with contributions by Mridul Aanjaneya and Bob Myhill.
|
||||
|
||||
Adapted for SciPy by Stefan van der Walt.
|
||||
|
||||
"""
|
||||
|
||||
from __future__ import division, print_function, absolute_import
|
||||
|
||||
__all__ = ['lsqr']
|
||||
|
||||
import numpy as np
|
||||
from math import sqrt
|
||||
from scipy.sparse.linalg.interface import aslinearoperator
|
||||
|
||||
eps = np.finfo(np.float64).eps
|
||||
|
||||
|
||||
def _sym_ortho(a, b):
|
||||
"""
|
||||
Stable implementation of Givens rotation.
|
||||
|
||||
Notes
|
||||
-----
|
||||
The routine 'SymOrtho' was added for numerical stability. This is
|
||||
recommended by S.-C. Choi in [1]_. It removes the unpleasant potential of
|
||||
``1/eps`` in some important places (see, for example text following
|
||||
"Compute the next plane rotation Qk" in minres.py).
|
||||
|
||||
References
|
||||
----------
|
||||
.. [1] S.-C. Choi, "Iterative Methods for Singular Linear Equations
|
||||
and Least-Squares Problems", Dissertation,
|
||||
http://www.stanford.edu/group/SOL/dissertations/sou-cheng-choi-thesis.pdf
|
||||
|
||||
"""
|
||||
if b == 0:
|
||||
return np.sign(a), 0, abs(a)
|
||||
elif a == 0:
|
||||
return 0, np.sign(b), abs(b)
|
||||
elif abs(b) > abs(a):
|
||||
tau = a / b
|
||||
s = np.sign(b) / sqrt(1 + tau * tau)
|
||||
c = s * tau
|
||||
r = b / s
|
||||
else:
|
||||
tau = b / a
|
||||
c = np.sign(a) / sqrt(1+tau*tau)
|
||||
s = c * tau
|
||||
r = a / c
|
||||
return c, s, r
|
||||
|
||||
|
||||
def lsqr(A, b, damp=0.0, atol=1e-8, btol=1e-8, conlim=1e8,
|
||||
iter_lim=None, show=False, calc_var=False, x0=None):
|
||||
"""Find the least-squares solution to a large, sparse, linear system
|
||||
of equations.
|
||||
|
||||
The function solves ``Ax = b`` or ``min ||b - Ax||^2`` or
|
||||
``min ||Ax - b||^2 + d^2 ||x||^2``.
|
||||
|
||||
The matrix A may be square or rectangular (over-determined or
|
||||
under-determined), and may have any rank.
|
||||
|
||||
::
|
||||
|
||||
1. Unsymmetric equations -- solve A*x = b
|
||||
|
||||
2. Linear least squares -- solve A*x = b
|
||||
in the least-squares sense
|
||||
|
||||
3. Damped least squares -- solve ( A )*x = ( b )
|
||||
( damp*I ) ( 0 )
|
||||
in the least-squares sense
|
||||
|
||||
Parameters
|
||||
----------
|
||||
A : {sparse matrix, ndarray, LinearOperator}
|
||||
Representation of an m-by-n matrix. It is required that
|
||||
the linear operator can produce ``Ax`` and ``A^T x``.
|
||||
b : array_like, shape (m,)
|
||||
Right-hand side vector ``b``.
|
||||
damp : float
|
||||
Damping coefficient.
|
||||
atol, btol : float, optional
|
||||
Stopping tolerances. If both are 1.0e-9 (say), the final
|
||||
residual norm should be accurate to about 9 digits. (The
|
||||
final x will usually have fewer correct digits, depending on
|
||||
cond(A) and the size of damp.)
|
||||
conlim : float, optional
|
||||
Another stopping tolerance. lsqr terminates if an estimate of
|
||||
``cond(A)`` exceeds `conlim`. For compatible systems ``Ax =
|
||||
b``, `conlim` could be as large as 1.0e+12 (say). For
|
||||
least-squares problems, conlim should be less than 1.0e+8.
|
||||
Maximum precision can be obtained by setting ``atol = btol =
|
||||
conlim = zero``, but the number of iterations may then be
|
||||
excessive.
|
||||
iter_lim : int, optional
|
||||
Explicit limitation on number of iterations (for safety).
|
||||
show : bool, optional
|
||||
Display an iteration log.
|
||||
calc_var : bool, optional
|
||||
Whether to estimate diagonals of ``(A'A + damp^2*I)^{-1}``.
|
||||
x0 : array_like, shape (n,), optional
|
||||
Initial guess of x, if None zeros are used.
|
||||
|
||||
.. versionadded:: 1.0.0
|
||||
|
||||
Returns
|
||||
-------
|
||||
x : ndarray of float
|
||||
The final solution.
|
||||
istop : int
|
||||
Gives the reason for termination.
|
||||
1 means x is an approximate solution to Ax = b.
|
||||
2 means x approximately solves the least-squares problem.
|
||||
itn : int
|
||||
Iteration number upon termination.
|
||||
r1norm : float
|
||||
``norm(r)``, where ``r = b - Ax``.
|
||||
r2norm : float
|
||||
``sqrt( norm(r)^2 + damp^2 * norm(x)^2 )``. Equal to `r1norm` if
|
||||
``damp == 0``.
|
||||
anorm : float
|
||||
Estimate of Frobenius norm of ``Abar = [[A]; [damp*I]]``.
|
||||
acond : float
|
||||
Estimate of ``cond(Abar)``.
|
||||
arnorm : float
|
||||
Estimate of ``norm(A'*r - damp^2*x)``.
|
||||
xnorm : float
|
||||
``norm(x)``
|
||||
var : ndarray of float
|
||||
If ``calc_var`` is True, estimates all diagonals of
|
||||
``(A'A)^{-1}`` (if ``damp == 0``) or more generally ``(A'A +
|
||||
damp^2*I)^{-1}``. This is well defined if A has full column
|
||||
rank or ``damp > 0``. (Not sure what var means if ``rank(A)
|
||||
< n`` and ``damp = 0.``)
|
||||
|
||||
Notes
|
||||
-----
|
||||
LSQR uses an iterative method to approximate the solution. The
|
||||
number of iterations required to reach a certain accuracy depends
|
||||
strongly on the scaling of the problem. Poor scaling of the rows
|
||||
or columns of A should therefore be avoided where possible.
|
||||
|
||||
For example, in problem 1 the solution is unaltered by
|
||||
row-scaling. If a row of A is very small or large compared to
|
||||
the other rows of A, the corresponding row of ( A b ) should be
|
||||
scaled up or down.
|
||||
|
||||
In problems 1 and 2, the solution x is easily recovered
|
||||
following column-scaling. Unless better information is known,
|
||||
the nonzero columns of A should be scaled so that they all have
|
||||
the same Euclidean norm (e.g., 1.0).
|
||||
|
||||
In problem 3, there is no freedom to re-scale if damp is
|
||||
nonzero. However, the value of damp should be assigned only
|
||||
after attention has been paid to the scaling of A.
|
||||
|
||||
The parameter damp is intended to help regularize
|
||||
ill-conditioned systems, by preventing the true solution from
|
||||
being very large. Another aid to regularization is provided by
|
||||
the parameter acond, which may be used to terminate iterations
|
||||
before the computed solution becomes very large.
|
||||
|
||||
If some initial estimate ``x0`` is known and if ``damp == 0``,
|
||||
one could proceed as follows:
|
||||
|
||||
1. Compute a residual vector ``r0 = b - A*x0``.
|
||||
2. Use LSQR to solve the system ``A*dx = r0``.
|
||||
3. Add the correction dx to obtain a final solution ``x = x0 + dx``.
|
||||
|
||||
This requires that ``x0`` be available before and after the call
|
||||
to LSQR. To judge the benefits, suppose LSQR takes k1 iterations
|
||||
to solve A*x = b and k2 iterations to solve A*dx = r0.
|
||||
If x0 is "good", norm(r0) will be smaller than norm(b).
|
||||
If the same stopping tolerances atol and btol are used for each
|
||||
system, k1 and k2 will be similar, but the final solution x0 + dx
|
||||
should be more accurate. The only way to reduce the total work
|
||||
is to use a larger stopping tolerance for the second system.
|
||||
If some value btol is suitable for A*x = b, the larger value
|
||||
btol*norm(b)/norm(r0) should be suitable for A*dx = r0.
|
||||
|
||||
Preconditioning is another way to reduce the number of iterations.
|
||||
If it is possible to solve a related system ``M*x = b``
|
||||
efficiently, where M approximates A in some helpful way (e.g. M -
|
||||
A has low rank or its elements are small relative to those of A),
|
||||
LSQR may converge more rapidly on the system ``A*M(inverse)*z =
|
||||
b``, after which x can be recovered by solving M*x = z.
|
||||
|
||||
If A is symmetric, LSQR should not be used!
|
||||
|
||||
Alternatives are the symmetric conjugate-gradient method (cg)
|
||||
and/or SYMMLQ. SYMMLQ is an implementation of symmetric cg that
|
||||
applies to any symmetric A and will converge more rapidly than
|
||||
LSQR. If A is positive definite, there are other implementations
|
||||
of symmetric cg that require slightly less work per iteration than
|
||||
SYMMLQ (but will take the same number of iterations).
|
||||
|
||||
References
|
||||
----------
|
||||
.. [1] C. C. Paige and M. A. Saunders (1982a).
|
||||
"LSQR: An algorithm for sparse linear equations and
|
||||
sparse least squares", ACM TOMS 8(1), 43-71.
|
||||
.. [2] C. C. Paige and M. A. Saunders (1982b).
|
||||
"Algorithm 583. LSQR: Sparse linear equations and least
|
||||
squares problems", ACM TOMS 8(2), 195-209.
|
||||
.. [3] M. A. Saunders (1995). "Solution of sparse rectangular
|
||||
systems using LSQR and CRAIG", BIT 35, 588-604.
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> from scipy.sparse import csc_matrix
|
||||
>>> from scipy.sparse.linalg import lsqr
|
||||
>>> A = csc_matrix([[1., 0.], [1., 1.], [0., 1.]], dtype=float)
|
||||
|
||||
The first example has the trivial solution `[0, 0]`
|
||||
|
||||
>>> b = np.array([0., 0., 0.], dtype=float)
|
||||
>>> x, istop, itn, normr = lsqr(A, b)[:4]
|
||||
The exact solution is x = 0
|
||||
>>> istop
|
||||
0
|
||||
>>> x
|
||||
array([ 0., 0.])
|
||||
|
||||
The stopping code `istop=0` returned indicates that a vector of zeros was
|
||||
found as a solution. The returned solution `x` indeed contains `[0., 0.]`.
|
||||
The next example has a non-trivial solution:
|
||||
|
||||
>>> b = np.array([1., 0., -1.], dtype=float)
|
||||
>>> x, istop, itn, r1norm = lsqr(A, b)[:4]
|
||||
>>> istop
|
||||
1
|
||||
>>> x
|
||||
array([ 1., -1.])
|
||||
>>> itn
|
||||
1
|
||||
>>> r1norm
|
||||
4.440892098500627e-16
|
||||
|
||||
As indicated by `istop=1`, `lsqr` found a solution obeying the tolerance
|
||||
limits. The given solution `[1., -1.]` obviously solves the equation. The
|
||||
remaining return values include information about the number of iterations
|
||||
(`itn=1`) and the remaining difference of left and right side of the solved
|
||||
equation.
|
||||
The final example demonstrates the behavior in the case where there is no
|
||||
solution for the equation:
|
||||
|
||||
>>> b = np.array([1., 0.01, -1.], dtype=float)
|
||||
>>> x, istop, itn, r1norm = lsqr(A, b)[:4]
|
||||
>>> istop
|
||||
2
|
||||
>>> x
|
||||
array([ 1.00333333, -0.99666667])
|
||||
>>> A.dot(x)-b
|
||||
array([ 0.00333333, -0.00333333, 0.00333333])
|
||||
>>> r1norm
|
||||
0.005773502691896255
|
||||
|
||||
`istop` indicates that the system is inconsistent and thus `x` is rather an
|
||||
approximate solution to the corresponding least-squares problem. `r1norm`
|
||||
contains the norm of the minimal residual that was found.
|
||||
"""
|
||||
A = aslinearoperator(A)
|
||||
b = np.atleast_1d(b)
|
||||
if b.ndim > 1:
|
||||
b = b.squeeze()
|
||||
|
||||
m, n = A.shape
|
||||
if iter_lim is None:
|
||||
iter_lim = 2 * n
|
||||
var = np.zeros(n)
|
||||
|
||||
msg = ('The exact solution is x = 0 ',
|
||||
'Ax - b is small enough, given atol, btol ',
|
||||
'The least-squares solution is good enough, given atol ',
|
||||
'The estimate of cond(Abar) has exceeded conlim ',
|
||||
'Ax - b is small enough for this machine ',
|
||||
'The least-squares solution is good enough for this machine',
|
||||
'Cond(Abar) seems to be too large for this machine ',
|
||||
'The iteration limit has been reached ')
|
||||
|
||||
if show:
|
||||
print(' ')
|
||||
print('LSQR Least-squares solution of Ax = b')
|
||||
str1 = 'The matrix A has %8g rows and %8g cols' % (m, n)
|
||||
str2 = 'damp = %20.14e calc_var = %8g' % (damp, calc_var)
|
||||
str3 = 'atol = %8.2e conlim = %8.2e' % (atol, conlim)
|
||||
str4 = 'btol = %8.2e iter_lim = %8g' % (btol, iter_lim)
|
||||
print(str1)
|
||||
print(str2)
|
||||
print(str3)
|
||||
print(str4)
|
||||
|
||||
itn = 0
|
||||
istop = 0
|
||||
ctol = 0
|
||||
if conlim > 0:
|
||||
ctol = 1/conlim
|
||||
anorm = 0
|
||||
acond = 0
|
||||
dampsq = damp**2
|
||||
ddnorm = 0
|
||||
res2 = 0
|
||||
xnorm = 0
|
||||
xxnorm = 0
|
||||
z = 0
|
||||
cs2 = -1
|
||||
sn2 = 0
|
||||
|
||||
"""
|
||||
Set up the first vectors u and v for the bidiagonalization.
|
||||
These satisfy beta*u = b - A*x, alfa*v = A'*u.
|
||||
"""
|
||||
u = b
|
||||
bnorm = np.linalg.norm(b)
|
||||
if x0 is None:
|
||||
x = np.zeros(n)
|
||||
beta = bnorm.copy()
|
||||
else:
|
||||
x = np.asarray(x0)
|
||||
u = u - A.matvec(x)
|
||||
beta = np.linalg.norm(u)
|
||||
|
||||
if beta > 0:
|
||||
u = (1/beta) * u
|
||||
v = A.rmatvec(u)
|
||||
alfa = np.linalg.norm(v)
|
||||
else:
|
||||
v = x.copy()
|
||||
alfa = 0
|
||||
|
||||
if alfa > 0:
|
||||
v = (1/alfa) * v
|
||||
w = v.copy()
|
||||
|
||||
rhobar = alfa
|
||||
phibar = beta
|
||||
rnorm = beta
|
||||
r1norm = rnorm
|
||||
r2norm = rnorm
|
||||
|
||||
# Reverse the order here from the original matlab code because
|
||||
# there was an error on return when arnorm==0
|
||||
arnorm = alfa * beta
|
||||
if arnorm == 0:
|
||||
print(msg[0])
|
||||
return x, istop, itn, r1norm, r2norm, anorm, acond, arnorm, xnorm, var
|
||||
|
||||
head1 = ' Itn x[0] r1norm r2norm '
|
||||
head2 = ' Compatible LS Norm A Cond A'
|
||||
|
||||
if show:
|
||||
print(' ')
|
||||
print(head1, head2)
|
||||
test1 = 1
|
||||
test2 = alfa / beta
|
||||
str1 = '%6g %12.5e' % (itn, x[0])
|
||||
str2 = ' %10.3e %10.3e' % (r1norm, r2norm)
|
||||
str3 = ' %8.1e %8.1e' % (test1, test2)
|
||||
print(str1, str2, str3)
|
||||
|
||||
# Main iteration loop.
|
||||
while itn < iter_lim:
|
||||
itn = itn + 1
|
||||
"""
|
||||
% Perform the next step of the bidiagonalization to obtain the
|
||||
% next beta, u, alfa, v. These satisfy the relations
|
||||
% beta*u = a*v - alfa*u,
|
||||
% alfa*v = A'*u - beta*v.
|
||||
"""
|
||||
u = A.matvec(v) - alfa * u
|
||||
beta = np.linalg.norm(u)
|
||||
|
||||
if beta > 0:
|
||||
u = (1/beta) * u
|
||||
anorm = sqrt(anorm**2 + alfa**2 + beta**2 + damp**2)
|
||||
v = A.rmatvec(u) - beta * v
|
||||
alfa = np.linalg.norm(v)
|
||||
if alfa > 0:
|
||||
v = (1 / alfa) * v
|
||||
|
||||
# Use a plane rotation to eliminate the damping parameter.
|
||||
# This alters the diagonal (rhobar) of the lower-bidiagonal matrix.
|
||||
rhobar1 = sqrt(rhobar**2 + damp**2)
|
||||
cs1 = rhobar / rhobar1
|
||||
sn1 = damp / rhobar1
|
||||
psi = sn1 * phibar
|
||||
phibar = cs1 * phibar
|
||||
|
||||
# Use a plane rotation to eliminate the subdiagonal element (beta)
|
||||
# of the lower-bidiagonal matrix, giving an upper-bidiagonal matrix.
|
||||
cs, sn, rho = _sym_ortho(rhobar1, beta)
|
||||
|
||||
theta = sn * alfa
|
||||
rhobar = -cs * alfa
|
||||
phi = cs * phibar
|
||||
phibar = sn * phibar
|
||||
tau = sn * phi
|
||||
|
||||
# Update x and w.
|
||||
t1 = phi / rho
|
||||
t2 = -theta / rho
|
||||
dk = (1 / rho) * w
|
||||
|
||||
x = x + t1 * w
|
||||
w = v + t2 * w
|
||||
ddnorm = ddnorm + np.linalg.norm(dk)**2
|
||||
|
||||
if calc_var:
|
||||
var = var + dk**2
|
||||
|
||||
# Use a plane rotation on the right to eliminate the
|
||||
# super-diagonal element (theta) of the upper-bidiagonal matrix.
|
||||
# Then use the result to estimate norm(x).
|
||||
delta = sn2 * rho
|
||||
gambar = -cs2 * rho
|
||||
rhs = phi - delta * z
|
||||
zbar = rhs / gambar
|
||||
xnorm = sqrt(xxnorm + zbar**2)
|
||||
gamma = sqrt(gambar**2 + theta**2)
|
||||
cs2 = gambar / gamma
|
||||
sn2 = theta / gamma
|
||||
z = rhs / gamma
|
||||
xxnorm = xxnorm + z**2
|
||||
|
||||
# Test for convergence.
|
||||
# First, estimate the condition of the matrix Abar,
|
||||
# and the norms of rbar and Abar'rbar.
|
||||
acond = anorm * sqrt(ddnorm)
|
||||
res1 = phibar**2
|
||||
res2 = res2 + psi**2
|
||||
rnorm = sqrt(res1 + res2)
|
||||
arnorm = alfa * abs(tau)
|
||||
|
||||
# Distinguish between
|
||||
# r1norm = ||b - Ax|| and
|
||||
# r2norm = rnorm in current code
|
||||
# = sqrt(r1norm^2 + damp^2*||x||^2).
|
||||
# Estimate r1norm from
|
||||
# r1norm = sqrt(r2norm^2 - damp^2*||x||^2).
|
||||
# Although there is cancellation, it might be accurate enough.
|
||||
r1sq = rnorm**2 - dampsq * xxnorm
|
||||
r1norm = sqrt(abs(r1sq))
|
||||
if r1sq < 0:
|
||||
r1norm = -r1norm
|
||||
r2norm = rnorm
|
||||
|
||||
# Now use these norms to estimate certain other quantities,
|
||||
# some of which will be small near a solution.
|
||||
test1 = rnorm / bnorm
|
||||
test2 = arnorm / (anorm * rnorm + eps)
|
||||
test3 = 1 / (acond + eps)
|
||||
t1 = test1 / (1 + anorm * xnorm / bnorm)
|
||||
rtol = btol + atol * anorm * xnorm / bnorm
|
||||
|
||||
# The following tests guard against extremely small values of
|
||||
# atol, btol or ctol. (The user may have set any or all of
|
||||
# the parameters atol, btol, conlim to 0.)
|
||||
# The effect is equivalent to the normal tests using
|
||||
# atol = eps, btol = eps, conlim = 1/eps.
|
||||
if itn >= iter_lim:
|
||||
istop = 7
|
||||
if 1 + test3 <= 1:
|
||||
istop = 6
|
||||
if 1 + test2 <= 1:
|
||||
istop = 5
|
||||
if 1 + t1 <= 1:
|
||||
istop = 4
|
||||
|
||||
# Allow for tolerances set by the user.
|
||||
if test3 <= ctol:
|
||||
istop = 3
|
||||
if test2 <= atol:
|
||||
istop = 2
|
||||
if test1 <= rtol:
|
||||
istop = 1
|
||||
|
||||
# See if it is time to print something.
|
||||
prnt = False
|
||||
if n <= 40:
|
||||
prnt = True
|
||||
if itn <= 10:
|
||||
prnt = True
|
||||
if itn >= iter_lim-10:
|
||||
prnt = True
|
||||
# if itn%10 == 0: prnt = True
|
||||
if test3 <= 2*ctol:
|
||||
prnt = True
|
||||
if test2 <= 10*atol:
|
||||
prnt = True
|
||||
if test1 <= 10*rtol:
|
||||
prnt = True
|
||||
if istop != 0:
|
||||
prnt = True
|
||||
|
||||
if prnt:
|
||||
if show:
|
||||
str1 = '%6g %12.5e' % (itn, x[0])
|
||||
str2 = ' %10.3e %10.3e' % (r1norm, r2norm)
|
||||
str3 = ' %8.1e %8.1e' % (test1, test2)
|
||||
str4 = ' %8.1e %8.1e' % (anorm, acond)
|
||||
print(str1, str2, str3, str4)
|
||||
|
||||
if istop != 0:
|
||||
break
|
||||
|
||||
# End of iteration loop.
|
||||
# Print the stopping condition.
|
||||
if show:
|
||||
print(' ')
|
||||
print('LSQR finished')
|
||||
print(msg[istop])
|
||||
print(' ')
|
||||
str1 = 'istop =%8g r1norm =%8.1e' % (istop, r1norm)
|
||||
str2 = 'anorm =%8.1e arnorm =%8.1e' % (anorm, arnorm)
|
||||
str3 = 'itn =%8g r2norm =%8.1e' % (itn, r2norm)
|
||||
str4 = 'acond =%8.1e xnorm =%8.1e' % (acond, xnorm)
|
||||
print(str1 + ' ' + str2)
|
||||
print(str3 + ' ' + str4)
|
||||
print(' ')
|
||||
|
||||
return x, istop, itn, r1norm, r2norm, anorm, acond, arnorm, xnorm, var
|
||||
@@ -0,0 +1,365 @@
|
||||
from __future__ import division, print_function, absolute_import
|
||||
|
||||
from numpy import sqrt, inner, zeros, inf, finfo
|
||||
from numpy.linalg import norm
|
||||
|
||||
from .utils import make_system
|
||||
|
||||
__all__ = ['minres']
|
||||
|
||||
|
||||
def minres(A, b, x0=None, shift=0.0, tol=1e-5, maxiter=None,
|
||||
M=None, callback=None, show=False, check=False):
|
||||
"""
|
||||
Use MINimum RESidual iteration to solve Ax=b
|
||||
|
||||
MINRES minimizes norm(A*x - b) for a real symmetric matrix A. Unlike
|
||||
the Conjugate Gradient method, A can be indefinite or singular.
|
||||
|
||||
If shift != 0 then the method solves (A - shift*I)x = b
|
||||
|
||||
Parameters
|
||||
----------
|
||||
A : {sparse matrix, dense matrix, LinearOperator}
|
||||
The real symmetric N-by-N matrix of the linear system
|
||||
b : {array, matrix}
|
||||
Right hand side of the linear system. Has shape (N,) or (N,1).
|
||||
|
||||
Returns
|
||||
-------
|
||||
x : {array, matrix}
|
||||
The converged solution.
|
||||
info : integer
|
||||
Provides convergence information:
|
||||
0 : successful exit
|
||||
>0 : convergence to tolerance not achieved, number of iterations
|
||||
<0 : illegal input or breakdown
|
||||
|
||||
Other Parameters
|
||||
----------------
|
||||
x0 : {array, matrix}
|
||||
Starting guess for the solution.
|
||||
tol : float
|
||||
Tolerance to achieve. The algorithm terminates when the relative
|
||||
residual is below `tol`.
|
||||
maxiter : integer
|
||||
Maximum number of iterations. Iteration will stop after maxiter
|
||||
steps even if the specified tolerance has not been achieved.
|
||||
M : {sparse matrix, dense matrix, LinearOperator}
|
||||
Preconditioner for A. The preconditioner should approximate the
|
||||
inverse of A. Effective preconditioning dramatically improves the
|
||||
rate of convergence, which implies that fewer iterations are needed
|
||||
to reach a given error tolerance.
|
||||
callback : function
|
||||
User-supplied function to call after each iteration. It is called
|
||||
as callback(xk), where xk is the current solution vector.
|
||||
|
||||
References
|
||||
----------
|
||||
Solution of sparse indefinite systems of linear equations,
|
||||
C. C. Paige and M. A. Saunders (1975),
|
||||
SIAM J. Numer. Anal. 12(4), pp. 617-629.
|
||||
https://web.stanford.edu/group/SOL/software/minres/
|
||||
|
||||
This file is a translation of the following MATLAB implementation:
|
||||
https://web.stanford.edu/group/SOL/software/minres/minres-matlab.zip
|
||||
|
||||
"""
|
||||
A, M, x, b, postprocess = make_system(A, M, x0, b)
|
||||
|
||||
matvec = A.matvec
|
||||
psolve = M.matvec
|
||||
|
||||
first = 'Enter minres. '
|
||||
last = 'Exit minres. '
|
||||
|
||||
n = A.shape[0]
|
||||
|
||||
if maxiter is None:
|
||||
maxiter = 5 * n
|
||||
|
||||
msg = [' beta2 = 0. If M = I, b and x are eigenvectors ', # -1
|
||||
' beta1 = 0. The exact solution is x = 0 ', # 0
|
||||
' A solution to Ax = b was found, given rtol ', # 1
|
||||
' A least-squares solution was found, given rtol ', # 2
|
||||
' Reasonable accuracy achieved, given eps ', # 3
|
||||
' x has converged to an eigenvector ', # 4
|
||||
' acond has exceeded 0.1/eps ', # 5
|
||||
' The iteration limit was reached ', # 6
|
||||
' A does not define a symmetric matrix ', # 7
|
||||
' M does not define a symmetric matrix ', # 8
|
||||
' M does not define a pos-def preconditioner '] # 9
|
||||
|
||||
if show:
|
||||
print(first + 'Solution of symmetric Ax = b')
|
||||
print(first + 'n = %3g shift = %23.14e' % (n,shift))
|
||||
print(first + 'itnlim = %3g rtol = %11.2e' % (maxiter,tol))
|
||||
print()
|
||||
|
||||
istop = 0
|
||||
itn = 0
|
||||
Anorm = 0
|
||||
Acond = 0
|
||||
rnorm = 0
|
||||
ynorm = 0
|
||||
|
||||
xtype = x.dtype
|
||||
|
||||
eps = finfo(xtype).eps
|
||||
|
||||
x = zeros(n, dtype=xtype)
|
||||
|
||||
# Set up y and v for the first Lanczos vector v1.
|
||||
# y = beta1 P' v1, where P = C**(-1).
|
||||
# v is really P' v1.
|
||||
|
||||
y = b
|
||||
r1 = b
|
||||
|
||||
y = psolve(b)
|
||||
|
||||
beta1 = inner(b,y)
|
||||
|
||||
if beta1 < 0:
|
||||
raise ValueError('indefinite preconditioner')
|
||||
elif beta1 == 0:
|
||||
return (postprocess(x), 0)
|
||||
|
||||
beta1 = sqrt(beta1)
|
||||
|
||||
if check:
|
||||
# are these too strict?
|
||||
|
||||
# see if A is symmetric
|
||||
w = matvec(y)
|
||||
r2 = matvec(w)
|
||||
s = inner(w,w)
|
||||
t = inner(y,r2)
|
||||
z = abs(s - t)
|
||||
epsa = (s + eps) * eps**(1.0/3.0)
|
||||
if z > epsa:
|
||||
raise ValueError('non-symmetric matrix')
|
||||
|
||||
# see if M is symmetric
|
||||
r2 = psolve(y)
|
||||
s = inner(y,y)
|
||||
t = inner(r1,r2)
|
||||
z = abs(s - t)
|
||||
epsa = (s + eps) * eps**(1.0/3.0)
|
||||
if z > epsa:
|
||||
raise ValueError('non-symmetric preconditioner')
|
||||
|
||||
# Initialize other quantities
|
||||
oldb = 0
|
||||
beta = beta1
|
||||
dbar = 0
|
||||
epsln = 0
|
||||
qrnorm = beta1
|
||||
phibar = beta1
|
||||
rhs1 = beta1
|
||||
rhs2 = 0
|
||||
tnorm2 = 0
|
||||
gmax = 0
|
||||
gmin = finfo(xtype).max
|
||||
cs = -1
|
||||
sn = 0
|
||||
w = zeros(n, dtype=xtype)
|
||||
w2 = zeros(n, dtype=xtype)
|
||||
r2 = r1
|
||||
|
||||
if show:
|
||||
print()
|
||||
print()
|
||||
print(' Itn x(1) Compatible LS norm(A) cond(A) gbar/|A|')
|
||||
|
||||
while itn < maxiter:
|
||||
itn += 1
|
||||
|
||||
s = 1.0/beta
|
||||
v = s*y
|
||||
|
||||
y = matvec(v)
|
||||
y = y - shift * v
|
||||
|
||||
if itn >= 2:
|
||||
y = y - (beta/oldb)*r1
|
||||
|
||||
alfa = inner(v,y)
|
||||
y = y - (alfa/beta)*r2
|
||||
r1 = r2
|
||||
r2 = y
|
||||
y = psolve(r2)
|
||||
oldb = beta
|
||||
beta = inner(r2,y)
|
||||
if beta < 0:
|
||||
raise ValueError('non-symmetric matrix')
|
||||
beta = sqrt(beta)
|
||||
tnorm2 += alfa**2 + oldb**2 + beta**2
|
||||
|
||||
if itn == 1:
|
||||
if beta/beta1 <= 10*eps:
|
||||
istop = -1 # Terminate later
|
||||
|
||||
# Apply previous rotation Qk-1 to get
|
||||
# [deltak epslnk+1] = [cs sn][dbark 0 ]
|
||||
# [gbar k dbar k+1] [sn -cs][alfak betak+1].
|
||||
|
||||
oldeps = epsln
|
||||
delta = cs * dbar + sn * alfa # delta1 = 0 deltak
|
||||
gbar = sn * dbar - cs * alfa # gbar 1 = alfa1 gbar k
|
||||
epsln = sn * beta # epsln2 = 0 epslnk+1
|
||||
dbar = - cs * beta # dbar 2 = beta2 dbar k+1
|
||||
root = norm([gbar, dbar])
|
||||
Arnorm = phibar * root
|
||||
|
||||
# Compute the next plane rotation Qk
|
||||
|
||||
gamma = norm([gbar, beta]) # gammak
|
||||
gamma = max(gamma, eps)
|
||||
cs = gbar / gamma # ck
|
||||
sn = beta / gamma # sk
|
||||
phi = cs * phibar # phik
|
||||
phibar = sn * phibar # phibark+1
|
||||
|
||||
# Update x.
|
||||
|
||||
denom = 1.0/gamma
|
||||
w1 = w2
|
||||
w2 = w
|
||||
w = (v - oldeps*w1 - delta*w2) * denom
|
||||
x = x + phi*w
|
||||
|
||||
# Go round again.
|
||||
|
||||
gmax = max(gmax, gamma)
|
||||
gmin = min(gmin, gamma)
|
||||
z = rhs1 / gamma
|
||||
rhs1 = rhs2 - delta*z
|
||||
rhs2 = - epsln*z
|
||||
|
||||
# Estimate various norms and test for convergence.
|
||||
|
||||
Anorm = sqrt(tnorm2)
|
||||
ynorm = norm(x)
|
||||
epsa = Anorm * eps
|
||||
epsx = Anorm * ynorm * eps
|
||||
epsr = Anorm * ynorm * tol
|
||||
diag = gbar
|
||||
|
||||
if diag == 0:
|
||||
diag = epsa
|
||||
|
||||
qrnorm = phibar
|
||||
rnorm = qrnorm
|
||||
if ynorm == 0 or Anorm == 0:
|
||||
test1 = inf
|
||||
else:
|
||||
test1 = rnorm / (Anorm*ynorm) # ||r|| / (||A|| ||x||)
|
||||
if Anorm == 0:
|
||||
test2 = inf
|
||||
else:
|
||||
test2 = root / Anorm # ||Ar|| / (||A|| ||r||)
|
||||
|
||||
# Estimate cond(A).
|
||||
# In this version we look at the diagonals of R in the
|
||||
# factorization of the lower Hessenberg matrix, Q * H = R,
|
||||
# where H is the tridiagonal matrix from Lanczos with one
|
||||
# extra row, beta(k+1) e_k^T.
|
||||
|
||||
Acond = gmax/gmin
|
||||
|
||||
# See if any of the stopping criteria are satisfied.
|
||||
# In rare cases, istop is already -1 from above (Abar = const*I).
|
||||
|
||||
if istop == 0:
|
||||
t1 = 1 + test1 # These tests work if tol < eps
|
||||
t2 = 1 + test2
|
||||
if t2 <= 1:
|
||||
istop = 2
|
||||
if t1 <= 1:
|
||||
istop = 1
|
||||
|
||||
if itn >= maxiter:
|
||||
istop = 6
|
||||
if Acond >= 0.1/eps:
|
||||
istop = 4
|
||||
if epsx >= beta1:
|
||||
istop = 3
|
||||
# if rnorm <= epsx : istop = 2
|
||||
# if rnorm <= epsr : istop = 1
|
||||
if test2 <= tol:
|
||||
istop = 2
|
||||
if test1 <= tol:
|
||||
istop = 1
|
||||
|
||||
# See if it is time to print something.
|
||||
|
||||
prnt = False
|
||||
if n <= 40:
|
||||
prnt = True
|
||||
if itn <= 10:
|
||||
prnt = True
|
||||
if itn >= maxiter-10:
|
||||
prnt = True
|
||||
if itn % 10 == 0:
|
||||
prnt = True
|
||||
if qrnorm <= 10*epsx:
|
||||
prnt = True
|
||||
if qrnorm <= 10*epsr:
|
||||
prnt = True
|
||||
if Acond <= 1e-2/eps:
|
||||
prnt = True
|
||||
if istop != 0:
|
||||
prnt = True
|
||||
|
||||
if show and prnt:
|
||||
str1 = '%6g %12.5e %10.3e' % (itn, x[0], test1)
|
||||
str2 = ' %10.3e' % (test2,)
|
||||
str3 = ' %8.1e %8.1e %8.1e' % (Anorm, Acond, gbar/Anorm)
|
||||
|
||||
print(str1 + str2 + str3)
|
||||
|
||||
if itn % 10 == 0:
|
||||
print()
|
||||
|
||||
if callback is not None:
|
||||
callback(x)
|
||||
|
||||
if istop != 0:
|
||||
break # TODO check this
|
||||
|
||||
if show:
|
||||
print()
|
||||
print(last + ' istop = %3g itn =%5g' % (istop,itn))
|
||||
print(last + ' Anorm = %12.4e Acond = %12.4e' % (Anorm,Acond))
|
||||
print(last + ' rnorm = %12.4e ynorm = %12.4e' % (rnorm,ynorm))
|
||||
print(last + ' Arnorm = %12.4e' % (Arnorm,))
|
||||
print(last + msg[istop+1])
|
||||
|
||||
if istop == 6:
|
||||
info = maxiter
|
||||
else:
|
||||
info = 0
|
||||
|
||||
return (postprocess(x),info)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
from scipy import ones, arange
|
||||
from scipy.linalg import norm
|
||||
from scipy.sparse import spdiags
|
||||
|
||||
n = 10
|
||||
|
||||
residuals = []
|
||||
|
||||
def cb(x):
|
||||
residuals.append(norm(b - A*x))
|
||||
|
||||
# A = poisson((10,),format='csr')
|
||||
A = spdiags([arange(1,n+1,dtype=float)], [0], n, n, format='csr')
|
||||
M = spdiags([1.0/arange(1,n+1,dtype=float)], [0], n, n, format='csr')
|
||||
A.psolve = M.matvec
|
||||
b = 0*ones(A.shape[0])
|
||||
x = minres(A,b,tol=1e-12,maxiter=None,callback=cb)
|
||||
# x = cg(A,b,x0=b,tol=1e-12,maxiter=None,callback=cb)[0]
|
||||
@@ -0,0 +1,44 @@
|
||||
from __future__ import division, print_function, absolute_import
|
||||
|
||||
from os.path import join
|
||||
|
||||
|
||||
def configuration(parent_package='',top_path=None):
|
||||
from scipy._build_utils.system_info import get_info, NotFoundError
|
||||
from numpy.distutils.misc_util import Configuration
|
||||
from scipy._build_utils import get_g77_abi_wrappers
|
||||
|
||||
config = Configuration('isolve',parent_package,top_path)
|
||||
|
||||
lapack_opt = get_info('lapack_opt')
|
||||
|
||||
# iterative methods
|
||||
methods = ['BiCGREVCOM.f.src',
|
||||
'BiCGSTABREVCOM.f.src',
|
||||
'CGREVCOM.f.src',
|
||||
'CGSREVCOM.f.src',
|
||||
# 'ChebyREVCOM.f.src',
|
||||
'GMRESREVCOM.f.src',
|
||||
# 'JacobiREVCOM.f.src',
|
||||
'QMRREVCOM.f.src',
|
||||
# 'SORREVCOM.f.src'
|
||||
]
|
||||
|
||||
Util = ['getbreak.f.src']
|
||||
sources = Util + methods + ['_iterative.pyf.src']
|
||||
sources = [join('iterative', x) for x in sources]
|
||||
sources += get_g77_abi_wrappers(lapack_opt)
|
||||
|
||||
config.add_extension('_iterative',
|
||||
sources=sources,
|
||||
extra_info=lapack_opt)
|
||||
|
||||
config.add_data_dir('tests')
|
||||
|
||||
return config
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
from numpy.distutils.core import setup
|
||||
|
||||
setup(**configuration(top_path='').todict())
|
||||
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
+63
@@ -0,0 +1,63 @@
|
||||
from __future__ import division, print_function, absolute_import
|
||||
|
||||
import scipy.sparse.linalg as la
|
||||
import scipy.sparse as sp
|
||||
import scipy.io as io
|
||||
import numpy as np
|
||||
import sys
|
||||
|
||||
#problem = "SPARSKIT/drivcav/e05r0100"
|
||||
problem = "SPARSKIT/drivcav/e05r0200"
|
||||
#problem = "Harwell-Boeing/sherman/sherman1"
|
||||
#problem = "misc/hamm/add32"
|
||||
|
||||
mm = np.lib._datasource.Repository('ftp://math.nist.gov/pub/MatrixMarket2/')
|
||||
f = mm.open('%s.mtx.gz' % problem)
|
||||
Am = io.mmread(f).tocsr()
|
||||
f.close()
|
||||
|
||||
f = mm.open('%s_rhs1.mtx.gz' % problem)
|
||||
b = np.array(io.mmread(f)).ravel()
|
||||
f.close()
|
||||
|
||||
count = [0]
|
||||
|
||||
|
||||
def matvec(v):
|
||||
count[0] += 1
|
||||
sys.stderr.write('%d\r' % count[0])
|
||||
return Am*v
|
||||
|
||||
|
||||
A = la.LinearOperator(matvec=matvec, shape=Am.shape, dtype=Am.dtype)
|
||||
|
||||
M = 100
|
||||
|
||||
print("MatrixMarket problem %s" % problem)
|
||||
print("Invert %d x %d matrix; nnz = %d" % (Am.shape[0], Am.shape[1], Am.nnz))
|
||||
|
||||
count[0] = 0
|
||||
x0, info = la.gmres(A, b, restrt=M, tol=1e-14)
|
||||
count_0 = count[0]
|
||||
err0 = np.linalg.norm(Am*x0 - b) / np.linalg.norm(b)
|
||||
print("GMRES(%d):" % M, count_0, "matvecs, residual", err0)
|
||||
if info != 0:
|
||||
print("Didn't converge")
|
||||
|
||||
count[0] = 0
|
||||
x1, info = la.lgmres(A, b, inner_m=M-6*2, outer_k=6, tol=1e-14)
|
||||
count_1 = count[0]
|
||||
err1 = np.linalg.norm(Am*x1 - b) / np.linalg.norm(b)
|
||||
print("LGMRES(%d,6) [same memory req.]:" % (M-2*6), count_1,
|
||||
"matvecs, residual:", err1)
|
||||
if info != 0:
|
||||
print("Didn't converge")
|
||||
|
||||
count[0] = 0
|
||||
x2, info = la.lgmres(A, b, inner_m=M-6, outer_k=6, tol=1e-14)
|
||||
count_2 = count[0]
|
||||
err2 = np.linalg.norm(Am*x2 - b) / np.linalg.norm(b)
|
||||
print("LGMRES(%d,6) [same subspace size]:" % (M-6), count_2,
|
||||
"matvecs, residual:", err2)
|
||||
if info != 0:
|
||||
print("Didn't converge")
|
||||
+167
@@ -0,0 +1,167 @@
|
||||
#!/usr/bin/env python
|
||||
"""Tests for the linalg.isolve.gcrotmk module
|
||||
"""
|
||||
|
||||
from __future__ import division, print_function, absolute_import
|
||||
|
||||
from numpy.testing import assert_, assert_allclose, assert_equal
|
||||
from scipy._lib._numpy_compat import suppress_warnings
|
||||
|
||||
import numpy as np
|
||||
from numpy import zeros, array, allclose
|
||||
from scipy.linalg import norm
|
||||
from scipy.sparse import csr_matrix, eye, rand
|
||||
|
||||
from scipy.sparse.linalg.interface import LinearOperator
|
||||
from scipy.sparse.linalg import splu
|
||||
from scipy.sparse.linalg.isolve import gcrotmk, gmres
|
||||
|
||||
|
||||
Am = csr_matrix(array([[-2,1,0,0,0,9],
|
||||
[1,-2,1,0,5,0],
|
||||
[0,1,-2,1,0,0],
|
||||
[0,0,1,-2,1,0],
|
||||
[0,3,0,1,-2,1],
|
||||
[1,0,0,0,1,-2]]))
|
||||
b = array([1,2,3,4,5,6])
|
||||
count = [0]
|
||||
|
||||
|
||||
def matvec(v):
|
||||
count[0] += 1
|
||||
return Am*v
|
||||
|
||||
|
||||
A = LinearOperator(matvec=matvec, shape=Am.shape, dtype=Am.dtype)
|
||||
|
||||
|
||||
def do_solve(**kw):
|
||||
count[0] = 0
|
||||
with suppress_warnings() as sup:
|
||||
sup.filter(DeprecationWarning, ".*called without specifying.*")
|
||||
x0, flag = gcrotmk(A, b, x0=zeros(A.shape[0]), tol=1e-14, **kw)
|
||||
count_0 = count[0]
|
||||
assert_(allclose(A*x0, b, rtol=1e-12, atol=1e-12), norm(A*x0-b))
|
||||
return x0, count_0
|
||||
|
||||
|
||||
class TestGCROTMK(object):
|
||||
def test_preconditioner(self):
|
||||
# Check that preconditioning works
|
||||
pc = splu(Am.tocsc())
|
||||
M = LinearOperator(matvec=pc.solve, shape=A.shape, dtype=A.dtype)
|
||||
|
||||
x0, count_0 = do_solve()
|
||||
x1, count_1 = do_solve(M=M)
|
||||
|
||||
assert_equal(count_1, 3)
|
||||
assert_(count_1 < count_0/2)
|
||||
assert_(allclose(x1, x0, rtol=1e-14))
|
||||
|
||||
def test_arnoldi(self):
|
||||
np.random.rand(1234)
|
||||
|
||||
A = eye(2000) + rand(2000, 2000, density=5e-4)
|
||||
b = np.random.rand(2000)
|
||||
|
||||
# The inner arnoldi should be equivalent to gmres
|
||||
with suppress_warnings() as sup:
|
||||
sup.filter(DeprecationWarning, ".*called without specifying.*")
|
||||
x0, flag0 = gcrotmk(A, b, x0=zeros(A.shape[0]), m=15, k=0, maxiter=1)
|
||||
x1, flag1 = gmres(A, b, x0=zeros(A.shape[0]), restart=15, maxiter=1)
|
||||
|
||||
assert_equal(flag0, 1)
|
||||
assert_equal(flag1, 1)
|
||||
assert_(np.linalg.norm(A.dot(x0) - b) > 1e-3)
|
||||
|
||||
assert_allclose(x0, x1)
|
||||
|
||||
def test_cornercase(self):
|
||||
np.random.seed(1234)
|
||||
|
||||
# Rounding error may prevent convergence with tol=0 --- ensure
|
||||
# that the return values in this case are correct, and no
|
||||
# exceptions are raised
|
||||
|
||||
for n in [3, 5, 10, 100]:
|
||||
A = 2*eye(n)
|
||||
|
||||
with suppress_warnings() as sup:
|
||||
sup.filter(DeprecationWarning, ".*called without specifying.*")
|
||||
b = np.ones(n)
|
||||
x, info = gcrotmk(A, b, maxiter=10)
|
||||
assert_equal(info, 0)
|
||||
assert_allclose(A.dot(x) - b, 0, atol=1e-14)
|
||||
|
||||
x, info = gcrotmk(A, b, tol=0, maxiter=10)
|
||||
if info == 0:
|
||||
assert_allclose(A.dot(x) - b, 0, atol=1e-14)
|
||||
|
||||
b = np.random.rand(n)
|
||||
x, info = gcrotmk(A, b, maxiter=10)
|
||||
assert_equal(info, 0)
|
||||
assert_allclose(A.dot(x) - b, 0, atol=1e-14)
|
||||
|
||||
x, info = gcrotmk(A, b, tol=0, maxiter=10)
|
||||
if info == 0:
|
||||
assert_allclose(A.dot(x) - b, 0, atol=1e-14)
|
||||
|
||||
def test_nans(self):
|
||||
A = eye(3, format='lil')
|
||||
A[1,1] = np.nan
|
||||
b = np.ones(3)
|
||||
|
||||
with suppress_warnings() as sup:
|
||||
sup.filter(DeprecationWarning, ".*called without specifying.*")
|
||||
x, info = gcrotmk(A, b, tol=0, maxiter=10)
|
||||
assert_equal(info, 1)
|
||||
|
||||
def test_truncate(self):
|
||||
np.random.seed(1234)
|
||||
A = np.random.rand(30, 30) + np.eye(30)
|
||||
b = np.random.rand(30)
|
||||
|
||||
for truncate in ['oldest', 'smallest']:
|
||||
with suppress_warnings() as sup:
|
||||
sup.filter(DeprecationWarning, ".*called without specifying.*")
|
||||
x, info = gcrotmk(A, b, m=10, k=10, truncate=truncate, tol=1e-4,
|
||||
maxiter=200)
|
||||
assert_equal(info, 0)
|
||||
assert_allclose(A.dot(x) - b, 0, atol=1e-3)
|
||||
|
||||
def test_CU(self):
|
||||
for discard_C in (True, False):
|
||||
# Check that C,U behave as expected
|
||||
CU = []
|
||||
x0, count_0 = do_solve(CU=CU, discard_C=discard_C)
|
||||
assert_(len(CU) > 0)
|
||||
assert_(len(CU) <= 6)
|
||||
|
||||
if discard_C:
|
||||
for c, u in CU:
|
||||
assert_(c is None)
|
||||
|
||||
# should converge immediately
|
||||
x1, count_1 = do_solve(CU=CU, discard_C=discard_C)
|
||||
if discard_C:
|
||||
assert_equal(count_1, 2 + len(CU))
|
||||
else:
|
||||
assert_equal(count_1, 3)
|
||||
assert_(count_1 <= count_0/2)
|
||||
assert_allclose(x1, x0, atol=1e-14)
|
||||
|
||||
def test_denormals(self):
|
||||
# Check that no warnings are emitted if the matrix contains
|
||||
# numbers for which 1/x has no float representation, and that
|
||||
# the solver behaves properly.
|
||||
A = np.array([[1, 2], [3, 4]], dtype=float)
|
||||
A *= 100 * np.nextafter(0, 1)
|
||||
|
||||
b = np.array([1, 1])
|
||||
|
||||
with suppress_warnings() as sup:
|
||||
sup.filter(DeprecationWarning, ".*called without specifying.*")
|
||||
xp, info = gcrotmk(A, b)
|
||||
|
||||
if info == 0:
|
||||
assert_allclose(A.dot(xp), b)
|
||||
+635
@@ -0,0 +1,635 @@
|
||||
""" Test functions for the sparse.linalg.isolve module
|
||||
"""
|
||||
|
||||
from __future__ import division, print_function, absolute_import
|
||||
|
||||
import itertools
|
||||
import numpy as np
|
||||
|
||||
from numpy.testing import (assert_equal, assert_array_equal,
|
||||
assert_, assert_allclose)
|
||||
import pytest
|
||||
from pytest import raises as assert_raises
|
||||
from scipy._lib._numpy_compat import suppress_warnings
|
||||
|
||||
from numpy import zeros, arange, array, ones, eye, iscomplexobj
|
||||
from scipy.linalg import norm
|
||||
from scipy.sparse import spdiags, csr_matrix, SparseEfficiencyWarning
|
||||
|
||||
from scipy.sparse.linalg import LinearOperator, aslinearoperator
|
||||
from scipy.sparse.linalg.isolve import cg, cgs, bicg, bicgstab, gmres, qmr, minres, lgmres, gcrotmk
|
||||
|
||||
# TODO check that method preserve shape and type
|
||||
# TODO test both preconditioner methods
|
||||
|
||||
|
||||
class Case(object):
|
||||
def __init__(self, name, A, b=None, skip=None, nonconvergence=None):
|
||||
self.name = name
|
||||
self.A = A
|
||||
if b is None:
|
||||
self.b = arange(A.shape[0], dtype=float)
|
||||
else:
|
||||
self.b = b
|
||||
if skip is None:
|
||||
self.skip = []
|
||||
else:
|
||||
self.skip = skip
|
||||
if nonconvergence is None:
|
||||
self.nonconvergence = []
|
||||
else:
|
||||
self.nonconvergence = nonconvergence
|
||||
|
||||
def __repr__(self):
|
||||
return "<%s>" % self.name
|
||||
|
||||
|
||||
class IterativeParams(object):
|
||||
def __init__(self):
|
||||
# list of tuples (solver, symmetric, positive_definite )
|
||||
solvers = [cg, cgs, bicg, bicgstab, gmres, qmr, minres, lgmres, gcrotmk]
|
||||
sym_solvers = [minres, cg]
|
||||
posdef_solvers = [cg]
|
||||
real_solvers = [minres]
|
||||
|
||||
self.solvers = solvers
|
||||
|
||||
# list of tuples (A, symmetric, positive_definite )
|
||||
self.cases = []
|
||||
|
||||
# Symmetric and Positive Definite
|
||||
N = 40
|
||||
data = ones((3,N))
|
||||
data[0,:] = 2
|
||||
data[1,:] = -1
|
||||
data[2,:] = -1
|
||||
Poisson1D = spdiags(data, [0,-1,1], N, N, format='csr')
|
||||
self.Poisson1D = Case("poisson1d", Poisson1D)
|
||||
self.cases.append(Case("poisson1d", Poisson1D))
|
||||
# note: minres fails for single precision
|
||||
self.cases.append(Case("poisson1d", Poisson1D.astype('f'),
|
||||
skip=[minres]))
|
||||
|
||||
# Symmetric and Negative Definite
|
||||
self.cases.append(Case("neg-poisson1d", -Poisson1D,
|
||||
skip=posdef_solvers))
|
||||
# note: minres fails for single precision
|
||||
self.cases.append(Case("neg-poisson1d", (-Poisson1D).astype('f'),
|
||||
skip=posdef_solvers + [minres]))
|
||||
|
||||
# Symmetric and Indefinite
|
||||
data = array([[6, -5, 2, 7, -1, 10, 4, -3, -8, 9]],dtype='d')
|
||||
RandDiag = spdiags(data, [0], 10, 10, format='csr')
|
||||
self.cases.append(Case("rand-diag", RandDiag, skip=posdef_solvers))
|
||||
self.cases.append(Case("rand-diag", RandDiag.astype('f'),
|
||||
skip=posdef_solvers))
|
||||
|
||||
# Random real-valued
|
||||
np.random.seed(1234)
|
||||
data = np.random.rand(4, 4)
|
||||
self.cases.append(Case("rand", data, skip=posdef_solvers+sym_solvers))
|
||||
self.cases.append(Case("rand", data.astype('f'),
|
||||
skip=posdef_solvers+sym_solvers))
|
||||
|
||||
# Random symmetric real-valued
|
||||
np.random.seed(1234)
|
||||
data = np.random.rand(4, 4)
|
||||
data = data + data.T
|
||||
self.cases.append(Case("rand-sym", data, skip=posdef_solvers))
|
||||
self.cases.append(Case("rand-sym", data.astype('f'),
|
||||
skip=posdef_solvers))
|
||||
|
||||
# Random pos-def symmetric real
|
||||
np.random.seed(1234)
|
||||
data = np.random.rand(9, 9)
|
||||
data = np.dot(data.conj(), data.T)
|
||||
self.cases.append(Case("rand-sym-pd", data))
|
||||
# note: minres fails for single precision
|
||||
self.cases.append(Case("rand-sym-pd", data.astype('f'),
|
||||
skip=[minres]))
|
||||
|
||||
# Random complex-valued
|
||||
np.random.seed(1234)
|
||||
data = np.random.rand(4, 4) + 1j*np.random.rand(4, 4)
|
||||
self.cases.append(Case("rand-cmplx", data,
|
||||
skip=posdef_solvers+sym_solvers+real_solvers))
|
||||
self.cases.append(Case("rand-cmplx", data.astype('F'),
|
||||
skip=posdef_solvers+sym_solvers+real_solvers))
|
||||
|
||||
# Random hermitian complex-valued
|
||||
np.random.seed(1234)
|
||||
data = np.random.rand(4, 4) + 1j*np.random.rand(4, 4)
|
||||
data = data + data.T.conj()
|
||||
self.cases.append(Case("rand-cmplx-herm", data,
|
||||
skip=posdef_solvers+real_solvers))
|
||||
self.cases.append(Case("rand-cmplx-herm", data.astype('F'),
|
||||
skip=posdef_solvers+real_solvers))
|
||||
|
||||
# Random pos-def hermitian complex-valued
|
||||
np.random.seed(1234)
|
||||
data = np.random.rand(9, 9) + 1j*np.random.rand(9, 9)
|
||||
data = np.dot(data.conj(), data.T)
|
||||
self.cases.append(Case("rand-cmplx-sym-pd", data, skip=real_solvers))
|
||||
self.cases.append(Case("rand-cmplx-sym-pd", data.astype('F'),
|
||||
skip=real_solvers))
|
||||
|
||||
# Non-symmetric and Positive Definite
|
||||
#
|
||||
# cgs, qmr, and bicg fail to converge on this one
|
||||
# -- algorithmic limitation apparently
|
||||
data = ones((2,10))
|
||||
data[0,:] = 2
|
||||
data[1,:] = -1
|
||||
A = spdiags(data, [0,-1], 10, 10, format='csr')
|
||||
self.cases.append(Case("nonsymposdef", A,
|
||||
skip=sym_solvers+[cgs, qmr, bicg]))
|
||||
self.cases.append(Case("nonsymposdef", A.astype('F'),
|
||||
skip=sym_solvers+[cgs, qmr, bicg]))
|
||||
|
||||
# Symmetric, non-pd, hitting cgs/bicg/bicgstab/qmr breakdown
|
||||
A = np.array([[0, 0, 0, 0, 0, 1, -1, -0, -0, -0, -0],
|
||||
[0, 0, 0, 0, 0, 2, -0, -1, -0, -0, -0],
|
||||
[0, 0, 0, 0, 0, 2, -0, -0, -1, -0, -0],
|
||||
[0, 0, 0, 0, 0, 2, -0, -0, -0, -1, -0],
|
||||
[0, 0, 0, 0, 0, 1, -0, -0, -0, -0, -1],
|
||||
[1, 2, 2, 2, 1, 0, -0, -0, -0, -0, -0],
|
||||
[-1, 0, 0, 0, 0, 0, -1, -0, -0, -0, -0],
|
||||
[0, -1, 0, 0, 0, 0, -0, -1, -0, -0, -0],
|
||||
[0, 0, -1, 0, 0, 0, -0, -0, -1, -0, -0],
|
||||
[0, 0, 0, -1, 0, 0, -0, -0, -0, -1, -0],
|
||||
[0, 0, 0, 0, -1, 0, -0, -0, -0, -0, -1]], dtype=float)
|
||||
b = np.array([0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0], dtype=float)
|
||||
assert (A == A.T).all()
|
||||
self.cases.append(Case("sym-nonpd", A, b,
|
||||
skip=posdef_solvers,
|
||||
nonconvergence=[cgs,bicg,bicgstab,qmr]))
|
||||
|
||||
|
||||
params = IterativeParams()
|
||||
|
||||
|
||||
def check_maxiter(solver, case):
|
||||
A = case.A
|
||||
tol = 1e-12
|
||||
|
||||
b = case.b
|
||||
x0 = 0*b
|
||||
|
||||
residuals = []
|
||||
|
||||
def callback(x):
|
||||
residuals.append(norm(b - case.A*x))
|
||||
|
||||
x, info = solver(A, b, x0=x0, tol=tol, maxiter=1, callback=callback)
|
||||
|
||||
assert_equal(len(residuals), 1)
|
||||
assert_equal(info, 1)
|
||||
|
||||
|
||||
def test_maxiter():
|
||||
case = params.Poisson1D
|
||||
for solver in params.solvers:
|
||||
if solver in case.skip:
|
||||
continue
|
||||
with suppress_warnings() as sup:
|
||||
sup.filter(DeprecationWarning, ".*called without specifying.*")
|
||||
check_maxiter(solver, case)
|
||||
|
||||
|
||||
def assert_normclose(a, b, tol=1e-8):
|
||||
residual = norm(a - b)
|
||||
tolerance = tol*norm(b)
|
||||
msg = "residual (%g) not smaller than tolerance %g" % (residual, tolerance)
|
||||
assert_(residual < tolerance, msg=msg)
|
||||
|
||||
|
||||
def check_convergence(solver, case):
|
||||
A = case.A
|
||||
|
||||
if A.dtype.char in "dD":
|
||||
tol = 1e-8
|
||||
else:
|
||||
tol = 1e-2
|
||||
|
||||
b = case.b
|
||||
x0 = 0*b
|
||||
|
||||
x, info = solver(A, b, x0=x0, tol=tol)
|
||||
|
||||
assert_array_equal(x0, 0*b) # ensure that x0 is not overwritten
|
||||
if solver not in case.nonconvergence:
|
||||
assert_equal(info,0)
|
||||
assert_normclose(A.dot(x), b, tol=tol)
|
||||
else:
|
||||
assert_(info != 0)
|
||||
assert_(np.linalg.norm(A.dot(x) - b) <= np.linalg.norm(b))
|
||||
|
||||
|
||||
def test_convergence():
|
||||
for solver in params.solvers:
|
||||
for case in params.cases:
|
||||
if solver in case.skip:
|
||||
continue
|
||||
with suppress_warnings() as sup:
|
||||
sup.filter(DeprecationWarning, ".*called without specifying.*")
|
||||
check_convergence(solver, case)
|
||||
|
||||
|
||||
def check_precond_dummy(solver, case):
|
||||
tol = 1e-8
|
||||
|
||||
def identity(b,which=None):
|
||||
"""trivial preconditioner"""
|
||||
return b
|
||||
|
||||
A = case.A
|
||||
|
||||
M,N = A.shape
|
||||
D = spdiags([1.0/A.diagonal()], [0], M, N)
|
||||
|
||||
b = case.b
|
||||
x0 = 0*b
|
||||
|
||||
precond = LinearOperator(A.shape, identity, rmatvec=identity)
|
||||
|
||||
if solver is qmr:
|
||||
x, info = solver(A, b, M1=precond, M2=precond, x0=x0, tol=tol)
|
||||
else:
|
||||
x, info = solver(A, b, M=precond, x0=x0, tol=tol)
|
||||
assert_equal(info,0)
|
||||
assert_normclose(A.dot(x), b, tol)
|
||||
|
||||
A = aslinearoperator(A)
|
||||
A.psolve = identity
|
||||
A.rpsolve = identity
|
||||
|
||||
x, info = solver(A, b, x0=x0, tol=tol)
|
||||
assert_equal(info,0)
|
||||
assert_normclose(A*x, b, tol=tol)
|
||||
|
||||
|
||||
def test_precond_dummy():
|
||||
case = params.Poisson1D
|
||||
for solver in params.solvers:
|
||||
if solver in case.skip:
|
||||
continue
|
||||
with suppress_warnings() as sup:
|
||||
sup.filter(DeprecationWarning, ".*called without specifying.*")
|
||||
check_precond_dummy(solver, case)
|
||||
|
||||
|
||||
def check_precond_inverse(solver, case):
|
||||
tol = 1e-8
|
||||
|
||||
def inverse(b,which=None):
|
||||
"""inverse preconditioner"""
|
||||
A = case.A
|
||||
if not isinstance(A, np.ndarray):
|
||||
A = A.todense()
|
||||
return np.linalg.solve(A, b)
|
||||
|
||||
def rinverse(b,which=None):
|
||||
"""inverse preconditioner"""
|
||||
A = case.A
|
||||
if not isinstance(A, np.ndarray):
|
||||
A = A.todense()
|
||||
return np.linalg.solve(A.T, b)
|
||||
|
||||
matvec_count = [0]
|
||||
|
||||
def matvec(b):
|
||||
matvec_count[0] += 1
|
||||
return case.A.dot(b)
|
||||
|
||||
def rmatvec(b):
|
||||
matvec_count[0] += 1
|
||||
return case.A.T.dot(b)
|
||||
|
||||
b = case.b
|
||||
x0 = 0*b
|
||||
|
||||
A = LinearOperator(case.A.shape, matvec, rmatvec=rmatvec)
|
||||
precond = LinearOperator(case.A.shape, inverse, rmatvec=rinverse)
|
||||
|
||||
# Solve with preconditioner
|
||||
matvec_count = [0]
|
||||
x, info = solver(A, b, M=precond, x0=x0, tol=tol)
|
||||
|
||||
assert_equal(info, 0)
|
||||
assert_normclose(case.A.dot(x), b, tol)
|
||||
|
||||
# Solution should be nearly instant
|
||||
assert_(matvec_count[0] <= 3, repr(matvec_count))
|
||||
|
||||
|
||||
def test_precond_inverse():
|
||||
case = params.Poisson1D
|
||||
for solver in params.solvers:
|
||||
if solver in case.skip:
|
||||
continue
|
||||
if solver is qmr:
|
||||
continue
|
||||
with suppress_warnings() as sup:
|
||||
sup.filter(DeprecationWarning, ".*called without specifying.*")
|
||||
check_precond_inverse(solver, case)
|
||||
|
||||
|
||||
def test_gmres_basic():
|
||||
A = np.vander(np.arange(10) + 1)[:, ::-1]
|
||||
b = np.zeros(10)
|
||||
b[0] = 1
|
||||
x = np.linalg.solve(A, b)
|
||||
|
||||
with suppress_warnings() as sup:
|
||||
sup.filter(DeprecationWarning, ".*called without specifying.*")
|
||||
x_gm, err = gmres(A, b, restart=5, maxiter=1)
|
||||
|
||||
assert_allclose(x_gm[0], 0.359, rtol=1e-2)
|
||||
|
||||
|
||||
def test_reentrancy():
|
||||
non_reentrant = [cg, cgs, bicg, bicgstab, gmres, qmr]
|
||||
reentrant = [lgmres, minres, gcrotmk]
|
||||
for solver in reentrant + non_reentrant:
|
||||
with suppress_warnings() as sup:
|
||||
sup.filter(DeprecationWarning, ".*called without specifying.*")
|
||||
_check_reentrancy(solver, solver in reentrant)
|
||||
|
||||
|
||||
def _check_reentrancy(solver, is_reentrant):
|
||||
def matvec(x):
|
||||
A = np.array([[1.0, 0, 0], [0, 2.0, 0], [0, 0, 3.0]])
|
||||
y, info = solver(A, x)
|
||||
assert_equal(info, 0)
|
||||
return y
|
||||
b = np.array([1, 1./2, 1./3])
|
||||
op = LinearOperator((3, 3), matvec=matvec, rmatvec=matvec,
|
||||
dtype=b.dtype)
|
||||
|
||||
if not is_reentrant:
|
||||
assert_raises(RuntimeError, solver, op, b)
|
||||
else:
|
||||
y, info = solver(op, b)
|
||||
assert_equal(info, 0)
|
||||
assert_allclose(y, [1, 1, 1])
|
||||
|
||||
|
||||
@pytest.mark.parametrize("solver", [cg, cgs, bicg, bicgstab, gmres, qmr, lgmres, gcrotmk])
|
||||
def test_atol(solver):
|
||||
# TODO: minres. It didn't historically use absolute tolerances, so
|
||||
# fixing it is less urgent.
|
||||
|
||||
np.random.seed(1234)
|
||||
A = np.random.rand(10, 10)
|
||||
A = A.dot(A.T) + 10 * np.eye(10)
|
||||
b = 1e3 * np.random.rand(10)
|
||||
b_norm = np.linalg.norm(b)
|
||||
|
||||
tols = np.r_[0, np.logspace(np.log10(1e-10), np.log10(1e2), 7), np.inf]
|
||||
|
||||
# Check effect of badly scaled preconditioners
|
||||
M0 = np.random.randn(10, 10)
|
||||
M0 = M0.dot(M0.T)
|
||||
Ms = [None, 1e-6 * M0, 1e6 * M0]
|
||||
|
||||
for M, tol, atol in itertools.product(Ms, tols, tols):
|
||||
if tol == 0 and atol == 0:
|
||||
continue
|
||||
|
||||
if solver is qmr:
|
||||
if M is not None:
|
||||
M = aslinearoperator(M)
|
||||
M2 = aslinearoperator(np.eye(10))
|
||||
else:
|
||||
M2 = None
|
||||
x, info = solver(A, b, M1=M, M2=M2, tol=tol, atol=atol)
|
||||
else:
|
||||
x, info = solver(A, b, M=M, tol=tol, atol=atol)
|
||||
assert_equal(info, 0)
|
||||
|
||||
residual = A.dot(x) - b
|
||||
err = np.linalg.norm(residual)
|
||||
atol2 = tol * b_norm
|
||||
assert_(err <= max(atol, atol2))
|
||||
|
||||
|
||||
@pytest.mark.parametrize("solver", [cg, cgs, bicg, bicgstab, gmres, qmr, minres, lgmres, gcrotmk])
|
||||
def test_zero_rhs(solver):
|
||||
np.random.seed(1234)
|
||||
A = np.random.rand(10, 10)
|
||||
A = A.dot(A.T) + 10 * np.eye(10)
|
||||
|
||||
b = np.zeros(10)
|
||||
tols = np.r_[np.logspace(np.log10(1e-10), np.log10(1e2), 7)]
|
||||
|
||||
for tol in tols:
|
||||
with suppress_warnings() as sup:
|
||||
sup.filter(DeprecationWarning, ".*called without specifying.*")
|
||||
|
||||
x, info = solver(A, b, tol=tol)
|
||||
assert_equal(info, 0)
|
||||
assert_allclose(x, 0, atol=1e-15)
|
||||
|
||||
x, info = solver(A, b, tol=tol, x0=ones(10))
|
||||
assert_equal(info, 0)
|
||||
assert_allclose(x, 0, atol=tol)
|
||||
|
||||
if solver is not minres:
|
||||
x, info = solver(A, b, tol=tol, atol=0, x0=ones(10))
|
||||
if info == 0:
|
||||
assert_allclose(x, 0)
|
||||
|
||||
x, info = solver(A, b, tol=tol, atol=tol)
|
||||
assert_equal(info, 0)
|
||||
assert_allclose(x, 0, atol=1e-300)
|
||||
|
||||
x, info = solver(A, b, tol=tol, atol=0)
|
||||
assert_equal(info, 0)
|
||||
assert_allclose(x, 0, atol=1e-300)
|
||||
|
||||
|
||||
@pytest.mark.parametrize("solver", [
|
||||
gmres, qmr, lgmres,
|
||||
pytest.param(cgs, marks=pytest.mark.xfail),
|
||||
pytest.param(bicg, marks=pytest.mark.xfail),
|
||||
pytest.param(bicgstab, marks=pytest.mark.xfail),
|
||||
pytest.param(gcrotmk, marks=pytest.mark.xfail)])
|
||||
def test_maxiter_worsening(solver):
|
||||
# Check error does not grow (boundlessly) with increasing maxiter.
|
||||
# This can occur due to the solvers hitting close to breakdown,
|
||||
# which they should detect and halt as necessary.
|
||||
# cf. gh-9100
|
||||
|
||||
# Singular matrix, rhs numerically not in range
|
||||
A = np.array([[-0.1112795288033378, 0, 0, 0.16127952880333685],
|
||||
[0, -0.13627952880333782+6.283185307179586j, 0, 0],
|
||||
[0, 0, -0.13627952880333782-6.283185307179586j, 0],
|
||||
[0.1112795288033368, 0j, 0j, -0.16127952880333785]])
|
||||
v = np.ones(4)
|
||||
best_error = np.inf
|
||||
|
||||
for maxiter in range(1, 20):
|
||||
x, info = solver(A, v, maxiter=maxiter, tol=1e-8, atol=0)
|
||||
|
||||
if info == 0:
|
||||
assert_(np.linalg.norm(A.dot(x) - v) <= 1e-8*np.linalg.norm(v))
|
||||
|
||||
error = np.linalg.norm(A.dot(x) - v)
|
||||
best_error = min(best_error, error)
|
||||
|
||||
# Check with slack
|
||||
assert_(error <= 5*best_error)
|
||||
|
||||
|
||||
#------------------------------------------------------------------------------
|
||||
|
||||
class TestQMR(object):
|
||||
def test_leftright_precond(self):
|
||||
"""Check that QMR works with left and right preconditioners"""
|
||||
|
||||
from scipy.sparse.linalg.dsolve import splu
|
||||
from scipy.sparse.linalg.interface import LinearOperator
|
||||
|
||||
n = 100
|
||||
|
||||
dat = ones(n)
|
||||
A = spdiags([-2*dat, 4*dat, -dat], [-1,0,1],n,n)
|
||||
b = arange(n,dtype='d')
|
||||
|
||||
L = spdiags([-dat/2, dat], [-1,0], n, n)
|
||||
U = spdiags([4*dat, -dat], [0,1], n, n)
|
||||
|
||||
with suppress_warnings() as sup:
|
||||
sup.filter(SparseEfficiencyWarning, "splu requires CSC matrix format")
|
||||
L_solver = splu(L)
|
||||
U_solver = splu(U)
|
||||
|
||||
def L_solve(b):
|
||||
return L_solver.solve(b)
|
||||
|
||||
def U_solve(b):
|
||||
return U_solver.solve(b)
|
||||
|
||||
def LT_solve(b):
|
||||
return L_solver.solve(b,'T')
|
||||
|
||||
def UT_solve(b):
|
||||
return U_solver.solve(b,'T')
|
||||
|
||||
M1 = LinearOperator((n,n), matvec=L_solve, rmatvec=LT_solve)
|
||||
M2 = LinearOperator((n,n), matvec=U_solve, rmatvec=UT_solve)
|
||||
|
||||
with suppress_warnings() as sup:
|
||||
sup.filter(DeprecationWarning, ".*called without specifying.*")
|
||||
x,info = qmr(A, b, tol=1e-8, maxiter=15, M1=M1, M2=M2)
|
||||
|
||||
assert_equal(info,0)
|
||||
assert_normclose(A*x, b, tol=1e-8)
|
||||
|
||||
|
||||
class TestGMRES(object):
|
||||
def test_callback(self):
|
||||
|
||||
def store_residual(r, rvec):
|
||||
rvec[rvec.nonzero()[0].max()+1] = r
|
||||
|
||||
# Define, A,b
|
||||
A = csr_matrix(array([[-2,1,0,0,0,0],[1,-2,1,0,0,0],[0,1,-2,1,0,0],[0,0,1,-2,1,0],[0,0,0,1,-2,1],[0,0,0,0,1,-2]]))
|
||||
b = ones((A.shape[0],))
|
||||
maxiter = 1
|
||||
rvec = zeros(maxiter+1)
|
||||
rvec[0] = 1.0
|
||||
callback = lambda r:store_residual(r, rvec)
|
||||
with suppress_warnings() as sup:
|
||||
sup.filter(DeprecationWarning, ".*called without specifying.*")
|
||||
x,flag = gmres(A, b, x0=zeros(A.shape[0]), tol=1e-16, maxiter=maxiter, callback=callback)
|
||||
|
||||
# Expected output from Scipy 1.0.0
|
||||
assert_allclose(rvec, array([1.0, 0.81649658092772603]), rtol=1e-10)
|
||||
|
||||
# Test preconditioned callback
|
||||
M = 1e-3 * np.eye(A.shape[0])
|
||||
rvec = zeros(maxiter+1)
|
||||
rvec[0] = 1.0
|
||||
with suppress_warnings() as sup:
|
||||
sup.filter(DeprecationWarning, ".*called without specifying.*")
|
||||
x, flag = gmres(A, b, M=M, tol=1e-16, maxiter=maxiter, callback=callback)
|
||||
|
||||
# Expected output from Scipy 1.0.0 (callback has preconditioned residual!)
|
||||
assert_allclose(rvec, array([1.0, 1e-3 * 0.81649658092772603]), rtol=1e-10)
|
||||
|
||||
def test_abi(self):
|
||||
# Check we don't segfault on gmres with complex argument
|
||||
A = eye(2)
|
||||
b = ones(2)
|
||||
with suppress_warnings() as sup:
|
||||
sup.filter(DeprecationWarning, ".*called without specifying.*")
|
||||
r_x, r_info = gmres(A, b)
|
||||
r_x = r_x.astype(complex)
|
||||
|
||||
x, info = gmres(A.astype(complex), b.astype(complex))
|
||||
|
||||
assert_(iscomplexobj(x))
|
||||
assert_allclose(r_x, x)
|
||||
assert_(r_info == info)
|
||||
|
||||
def test_atol_legacy(self):
|
||||
with suppress_warnings() as sup:
|
||||
sup.filter(DeprecationWarning, ".*called without specifying.*")
|
||||
|
||||
# Check the strange legacy behavior: the tolerance is interpreted
|
||||
# as atol, but only for the initial residual
|
||||
A = eye(2)
|
||||
b = 1e-6 * ones(2)
|
||||
x, info = gmres(A, b, tol=1e-5)
|
||||
assert_array_equal(x, np.zeros(2))
|
||||
|
||||
A = eye(2)
|
||||
b = ones(2)
|
||||
x, info = gmres(A, b, tol=1e-5)
|
||||
assert_(np.linalg.norm(A.dot(x) - b) <= 1e-5*np.linalg.norm(b))
|
||||
assert_allclose(x, b, atol=0, rtol=1e-8)
|
||||
|
||||
rndm = np.random.RandomState(12345)
|
||||
A = rndm.rand(30, 30)
|
||||
b = 1e-6 * ones(30)
|
||||
x, info = gmres(A, b, tol=1e-7, restart=20)
|
||||
assert_(np.linalg.norm(A.dot(x) - b) > 1e-7)
|
||||
|
||||
A = eye(2)
|
||||
b = 1e-10 * ones(2)
|
||||
x, info = gmres(A, b, tol=1e-8, atol=0)
|
||||
assert_(np.linalg.norm(A.dot(x) - b) <= 1e-8*np.linalg.norm(b))
|
||||
|
||||
def test_defective_precond_breakdown(self):
|
||||
# Breakdown due to defective preconditioner
|
||||
M = np.eye(3)
|
||||
M[2,2] = 0
|
||||
|
||||
b = np.array([0, 1, 1])
|
||||
x = np.array([1, 0, 0])
|
||||
A = np.diag([2, 3, 4])
|
||||
|
||||
x, info = gmres(A, b, x0=x, M=M, tol=1e-15, atol=0)
|
||||
|
||||
# Should not return nans, nor terminate with false success
|
||||
assert_(not np.isnan(x).any())
|
||||
if info == 0:
|
||||
assert_(np.linalg.norm(A.dot(x) - b) <= 1e-15*np.linalg.norm(b))
|
||||
|
||||
# The solution should be OK outside null space of M
|
||||
assert_allclose(M.dot(A.dot(x)), M.dot(b))
|
||||
|
||||
def test_defective_matrix_breakdown(self):
|
||||
# Breakdown due to defective matrix
|
||||
A = np.array([[0, 1, 0], [1, 0, 0], [0, 0, 0]])
|
||||
b = np.array([1, 0, 1])
|
||||
x, info = gmres(A, b, tol=1e-8, atol=0)
|
||||
|
||||
# Should not return nans, nor terminate with false success
|
||||
assert_(not np.isnan(x).any())
|
||||
if info == 0:
|
||||
assert_(np.linalg.norm(A.dot(x) - b) <= 1e-8*np.linalg.norm(b))
|
||||
|
||||
# The solution should be OK outside null space of A
|
||||
assert_allclose(A.dot(A.dot(x)), A.dot(b))
|
||||
+214
@@ -0,0 +1,214 @@
|
||||
"""Tests for the linalg.isolve.lgmres module
|
||||
"""
|
||||
|
||||
from __future__ import division, print_function, absolute_import
|
||||
|
||||
from numpy.testing import assert_, assert_allclose, assert_equal
|
||||
|
||||
import pytest
|
||||
from platform import python_implementation
|
||||
|
||||
import numpy as np
|
||||
from numpy import zeros, array, allclose
|
||||
from scipy.linalg import norm
|
||||
from scipy.sparse import csr_matrix, eye, rand
|
||||
|
||||
from scipy.sparse.linalg.interface import LinearOperator
|
||||
from scipy.sparse.linalg import splu
|
||||
from scipy.sparse.linalg.isolve import lgmres, gmres
|
||||
|
||||
from scipy._lib._numpy_compat import suppress_warnings
|
||||
|
||||
Am = csr_matrix(array([[-2, 1, 0, 0, 0, 9],
|
||||
[1, -2, 1, 0, 5, 0],
|
||||
[0, 1, -2, 1, 0, 0],
|
||||
[0, 0, 1, -2, 1, 0],
|
||||
[0, 3, 0, 1, -2, 1],
|
||||
[1, 0, 0, 0, 1, -2]]))
|
||||
b = array([1, 2, 3, 4, 5, 6])
|
||||
count = [0]
|
||||
|
||||
|
||||
def matvec(v):
|
||||
count[0] += 1
|
||||
return Am*v
|
||||
|
||||
|
||||
A = LinearOperator(matvec=matvec, shape=Am.shape, dtype=Am.dtype)
|
||||
|
||||
|
||||
def do_solve(**kw):
|
||||
count[0] = 0
|
||||
with suppress_warnings() as sup:
|
||||
sup.filter(DeprecationWarning, ".*called without specifying.*")
|
||||
x0, flag = lgmres(A, b, x0=zeros(A.shape[0]),
|
||||
inner_m=6, tol=1e-14, **kw)
|
||||
count_0 = count[0]
|
||||
assert_(allclose(A*x0, b, rtol=1e-12, atol=1e-12), norm(A*x0-b))
|
||||
return x0, count_0
|
||||
|
||||
|
||||
class TestLGMRES(object):
|
||||
def test_preconditioner(self):
|
||||
# Check that preconditioning works
|
||||
pc = splu(Am.tocsc())
|
||||
M = LinearOperator(matvec=pc.solve, shape=A.shape, dtype=A.dtype)
|
||||
|
||||
x0, count_0 = do_solve()
|
||||
x1, count_1 = do_solve(M=M)
|
||||
|
||||
assert_(count_1 == 3)
|
||||
assert_(count_1 < count_0/2)
|
||||
assert_(allclose(x1, x0, rtol=1e-14))
|
||||
|
||||
def test_outer_v(self):
|
||||
# Check that the augmentation vectors behave as expected
|
||||
|
||||
outer_v = []
|
||||
x0, count_0 = do_solve(outer_k=6, outer_v=outer_v)
|
||||
assert_(len(outer_v) > 0)
|
||||
assert_(len(outer_v) <= 6)
|
||||
|
||||
x1, count_1 = do_solve(outer_k=6, outer_v=outer_v,
|
||||
prepend_outer_v=True)
|
||||
assert_(count_1 == 2, count_1)
|
||||
assert_(count_1 < count_0/2)
|
||||
assert_(allclose(x1, x0, rtol=1e-14))
|
||||
|
||||
# ---
|
||||
|
||||
outer_v = []
|
||||
x0, count_0 = do_solve(outer_k=6, outer_v=outer_v,
|
||||
store_outer_Av=False)
|
||||
assert_(array([v[1] is None for v in outer_v]).all())
|
||||
assert_(len(outer_v) > 0)
|
||||
assert_(len(outer_v) <= 6)
|
||||
|
||||
x1, count_1 = do_solve(outer_k=6, outer_v=outer_v,
|
||||
prepend_outer_v=True)
|
||||
assert_(count_1 == 3, count_1)
|
||||
assert_(count_1 < count_0/2)
|
||||
assert_(allclose(x1, x0, rtol=1e-14))
|
||||
|
||||
@pytest.mark.skipif(python_implementation() == 'PyPy',
|
||||
reason="Fails on PyPy CI runs. See #9507")
|
||||
def test_arnoldi(self):
|
||||
np.random.rand(1234)
|
||||
|
||||
A = eye(10000) + rand(10000, 10000, density=1e-4)
|
||||
b = np.random.rand(10000)
|
||||
|
||||
# The inner arnoldi should be equivalent to gmres
|
||||
with suppress_warnings() as sup:
|
||||
sup.filter(DeprecationWarning, ".*called without specifying.*")
|
||||
x0, flag0 = lgmres(A, b, x0=zeros(A.shape[0]),
|
||||
inner_m=15, maxiter=1)
|
||||
x1, flag1 = gmres(A, b, x0=zeros(A.shape[0]),
|
||||
restart=15, maxiter=1)
|
||||
|
||||
assert_equal(flag0, 1)
|
||||
assert_equal(flag1, 1)
|
||||
assert_(np.linalg.norm(A.dot(x0) - b) > 1e-3)
|
||||
|
||||
assert_allclose(x0, x1)
|
||||
|
||||
def test_cornercase(self):
|
||||
np.random.seed(1234)
|
||||
|
||||
# Rounding error may prevent convergence with tol=0 --- ensure
|
||||
# that the return values in this case are correct, and no
|
||||
# exceptions are raised
|
||||
|
||||
for n in [3, 5, 10, 100]:
|
||||
A = 2*eye(n)
|
||||
|
||||
with suppress_warnings() as sup:
|
||||
sup.filter(DeprecationWarning, ".*called without specifying.*")
|
||||
|
||||
b = np.ones(n)
|
||||
x, info = lgmres(A, b, maxiter=10)
|
||||
assert_equal(info, 0)
|
||||
assert_allclose(A.dot(x) - b, 0, atol=1e-14)
|
||||
|
||||
x, info = lgmres(A, b, tol=0, maxiter=10)
|
||||
if info == 0:
|
||||
assert_allclose(A.dot(x) - b, 0, atol=1e-14)
|
||||
|
||||
b = np.random.rand(n)
|
||||
x, info = lgmres(A, b, maxiter=10)
|
||||
assert_equal(info, 0)
|
||||
assert_allclose(A.dot(x) - b, 0, atol=1e-14)
|
||||
|
||||
x, info = lgmres(A, b, tol=0, maxiter=10)
|
||||
if info == 0:
|
||||
assert_allclose(A.dot(x) - b, 0, atol=1e-14)
|
||||
|
||||
def test_nans(self):
|
||||
A = eye(3, format='lil')
|
||||
A[1, 1] = np.nan
|
||||
b = np.ones(3)
|
||||
|
||||
with suppress_warnings() as sup:
|
||||
sup.filter(DeprecationWarning, ".*called without specifying.*")
|
||||
x, info = lgmres(A, b, tol=0, maxiter=10)
|
||||
assert_equal(info, 1)
|
||||
|
||||
def test_breakdown_with_outer_v(self):
|
||||
A = np.array([[1, 2], [3, 4]], dtype=float)
|
||||
b = np.array([1, 2])
|
||||
|
||||
x = np.linalg.solve(A, b)
|
||||
v0 = np.array([1, 0])
|
||||
|
||||
# The inner iteration should converge to the correct solution,
|
||||
# since it's in the outer vector list
|
||||
with suppress_warnings() as sup:
|
||||
sup.filter(DeprecationWarning, ".*called without specifying.*")
|
||||
xp, info = lgmres(A, b, outer_v=[(v0, None), (x, None)], maxiter=1)
|
||||
|
||||
assert_allclose(xp, x, atol=1e-12)
|
||||
|
||||
def test_breakdown_underdetermined(self):
|
||||
# Should find LSQ solution in the Krylov span in one inner
|
||||
# iteration, despite solver breakdown from nilpotent A.
|
||||
A = np.array([[0, 1, 1, 1],
|
||||
[0, 0, 1, 1],
|
||||
[0, 0, 0, 1],
|
||||
[0, 0, 0, 0]], dtype=float)
|
||||
|
||||
bs = [
|
||||
np.array([1, 1, 1, 1]),
|
||||
np.array([1, 1, 1, 0]),
|
||||
np.array([1, 1, 0, 0]),
|
||||
np.array([1, 0, 0, 0]),
|
||||
]
|
||||
|
||||
for b in bs:
|
||||
with suppress_warnings() as sup:
|
||||
sup.filter(DeprecationWarning, ".*called without specifying.*")
|
||||
xp, info = lgmres(A, b, maxiter=1)
|
||||
resp = np.linalg.norm(A.dot(xp) - b)
|
||||
|
||||
K = np.c_[b, A.dot(b), A.dot(A.dot(b)), A.dot(A.dot(A.dot(b)))]
|
||||
y, _, _, _ = np.linalg.lstsq(A.dot(K), b, rcond=-1)
|
||||
x = K.dot(y)
|
||||
res = np.linalg.norm(A.dot(x) - b)
|
||||
|
||||
assert_allclose(resp, res, err_msg=repr(b))
|
||||
|
||||
def test_denormals(self):
|
||||
# Check that no warnings are emitted if the matrix contains
|
||||
# numbers for which 1/x has no float representation, and that
|
||||
# the solver behaves properly.
|
||||
A = np.array([[1, 2], [3, 4]], dtype=float)
|
||||
A *= 100 * np.nextafter(0, 1)
|
||||
|
||||
b = np.array([1, 1])
|
||||
|
||||
with suppress_warnings() as sup:
|
||||
sup.filter(DeprecationWarning, ".*called without specifying.*")
|
||||
xp, info = lgmres(A, b)
|
||||
|
||||
if info == 0:
|
||||
assert_allclose(A.dot(xp), b)
|
||||
|
||||
@@ -0,0 +1,180 @@
|
||||
"""
|
||||
Copyright (C) 2010 David Fong and Michael Saunders
|
||||
Distributed under the same license as Scipy
|
||||
|
||||
Testing Code for LSMR.
|
||||
|
||||
03 Jun 2010: First version release with lsmr.py
|
||||
|
||||
David Chin-lung Fong clfong@stanford.edu
|
||||
Institute for Computational and Mathematical Engineering
|
||||
Stanford University
|
||||
|
||||
Michael Saunders saunders@stanford.edu
|
||||
Systems Optimization Laboratory
|
||||
Dept of MS&E, Stanford University.
|
||||
|
||||
"""
|
||||
|
||||
from __future__ import division, print_function, absolute_import
|
||||
|
||||
from numpy import array, arange, eye, zeros, ones, sqrt, transpose, hstack
|
||||
from numpy.linalg import norm
|
||||
from numpy.testing import (assert_almost_equal,
|
||||
assert_array_almost_equal)
|
||||
|
||||
from scipy.sparse import coo_matrix
|
||||
from scipy.sparse.linalg.interface import aslinearoperator
|
||||
from scipy.sparse.linalg import lsmr
|
||||
from .test_lsqr import G, b
|
||||
|
||||
|
||||
class TestLSMR:
|
||||
def setup_method(self):
|
||||
self.n = 10
|
||||
self.m = 10
|
||||
|
||||
def assertCompatibleSystem(self, A, xtrue):
|
||||
Afun = aslinearoperator(A)
|
||||
b = Afun.matvec(xtrue)
|
||||
x = lsmr(A, b)[0]
|
||||
assert_almost_equal(norm(x - xtrue), 0, decimal=5)
|
||||
|
||||
def testIdentityACase1(self):
|
||||
A = eye(self.n)
|
||||
xtrue = zeros((self.n, 1))
|
||||
self.assertCompatibleSystem(A, xtrue)
|
||||
|
||||
def testIdentityACase2(self):
|
||||
A = eye(self.n)
|
||||
xtrue = ones((self.n,1))
|
||||
self.assertCompatibleSystem(A, xtrue)
|
||||
|
||||
def testIdentityACase3(self):
|
||||
A = eye(self.n)
|
||||
xtrue = transpose(arange(self.n,0,-1))
|
||||
self.assertCompatibleSystem(A, xtrue)
|
||||
|
||||
def testBidiagonalA(self):
|
||||
A = lowerBidiagonalMatrix(20,self.n)
|
||||
xtrue = transpose(arange(self.n,0,-1))
|
||||
self.assertCompatibleSystem(A,xtrue)
|
||||
|
||||
def testScalarB(self):
|
||||
A = array([[1.0, 2.0]])
|
||||
b = 3.0
|
||||
x = lsmr(A, b)[0]
|
||||
assert_almost_equal(norm(A.dot(x) - b), 0)
|
||||
|
||||
def testColumnB(self):
|
||||
A = eye(self.n)
|
||||
b = ones((self.n, 1))
|
||||
x = lsmr(A, b)[0]
|
||||
assert_almost_equal(norm(A.dot(x) - b.ravel()), 0)
|
||||
|
||||
def testInitialization(self):
|
||||
# Test that the default setting is not modified
|
||||
x_ref = lsmr(G, b)[0]
|
||||
x0 = zeros(b.shape)
|
||||
x = lsmr(G, b, x0=x0)[0]
|
||||
assert_array_almost_equal(x_ref, x)
|
||||
|
||||
# Test warm-start with single iteration
|
||||
x0 = lsmr(G, b, maxiter=1)[0]
|
||||
x = lsmr(G, b, x0=x0)[0]
|
||||
assert_array_almost_equal(x_ref, x)
|
||||
|
||||
class TestLSMRReturns:
|
||||
def setup_method(self):
|
||||
self.n = 10
|
||||
self.A = lowerBidiagonalMatrix(20,self.n)
|
||||
self.xtrue = transpose(arange(self.n,0,-1))
|
||||
self.Afun = aslinearoperator(self.A)
|
||||
self.b = self.Afun.matvec(self.xtrue)
|
||||
self.returnValues = lsmr(self.A,self.b)
|
||||
|
||||
def testNormr(self):
|
||||
x, istop, itn, normr, normar, normA, condA, normx = self.returnValues
|
||||
assert_almost_equal(normr, norm(self.b - self.Afun.matvec(x)))
|
||||
|
||||
def testNormar(self):
|
||||
x, istop, itn, normr, normar, normA, condA, normx = self.returnValues
|
||||
assert_almost_equal(normar,
|
||||
norm(self.Afun.rmatvec(self.b - self.Afun.matvec(x))))
|
||||
|
||||
def testNormx(self):
|
||||
x, istop, itn, normr, normar, normA, condA, normx = self.returnValues
|
||||
assert_almost_equal(normx, norm(x))
|
||||
|
||||
|
||||
def lowerBidiagonalMatrix(m, n):
|
||||
# This is a simple example for testing LSMR.
|
||||
# It uses the leading m*n submatrix from
|
||||
# A = [ 1
|
||||
# 1 2
|
||||
# 2 3
|
||||
# 3 4
|
||||
# ...
|
||||
# n ]
|
||||
# suitably padded by zeros.
|
||||
#
|
||||
# 04 Jun 2010: First version for distribution with lsmr.py
|
||||
if m <= n:
|
||||
row = hstack((arange(m, dtype=int),
|
||||
arange(1, m, dtype=int)))
|
||||
col = hstack((arange(m, dtype=int),
|
||||
arange(m-1, dtype=int)))
|
||||
data = hstack((arange(1, m+1, dtype=float),
|
||||
arange(1,m, dtype=float)))
|
||||
return coo_matrix((data, (row, col)), shape=(m,n))
|
||||
else:
|
||||
row = hstack((arange(n, dtype=int),
|
||||
arange(1, n+1, dtype=int)))
|
||||
col = hstack((arange(n, dtype=int),
|
||||
arange(n, dtype=int)))
|
||||
data = hstack((arange(1, n+1, dtype=float),
|
||||
arange(1,n+1, dtype=float)))
|
||||
return coo_matrix((data,(row, col)), shape=(m,n))
|
||||
|
||||
|
||||
def lsmrtest(m, n, damp):
|
||||
"""Verbose testing of lsmr"""
|
||||
|
||||
A = lowerBidiagonalMatrix(m,n)
|
||||
xtrue = arange(n,0,-1, dtype=float)
|
||||
Afun = aslinearoperator(A)
|
||||
|
||||
b = Afun.matvec(xtrue)
|
||||
|
||||
atol = 1.0e-7
|
||||
btol = 1.0e-7
|
||||
conlim = 1.0e+10
|
||||
itnlim = 10*n
|
||||
show = 1
|
||||
|
||||
x, istop, itn, normr, normar, norma, conda, normx \
|
||||
= lsmr(A, b, damp, atol, btol, conlim, itnlim, show)
|
||||
|
||||
j1 = min(n,5)
|
||||
j2 = max(n-4,1)
|
||||
print(' ')
|
||||
print('First elements of x:')
|
||||
str = ['%10.4f' % (xi) for xi in x[0:j1]]
|
||||
print(''.join(str))
|
||||
print(' ')
|
||||
print('Last elements of x:')
|
||||
str = ['%10.4f' % (xi) for xi in x[j2-1:]]
|
||||
print(''.join(str))
|
||||
|
||||
r = b - Afun.matvec(x)
|
||||
r2 = sqrt(norm(r)**2 + (damp*norm(x))**2)
|
||||
print(' ')
|
||||
str = 'normr (est.) %17.10e' % (normr)
|
||||
str2 = 'normr (true) %17.10e' % (r2)
|
||||
print(str)
|
||||
print(str2)
|
||||
print(' ')
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
lsmrtest(20,10,0)
|
||||
@@ -0,0 +1,139 @@
|
||||
from __future__ import division, print_function, absolute_import
|
||||
|
||||
import numpy as np
|
||||
from numpy.testing import (assert_, assert_equal, assert_almost_equal,
|
||||
assert_array_almost_equal)
|
||||
from scipy._lib.six import xrange
|
||||
|
||||
import scipy.sparse
|
||||
import scipy.sparse.linalg
|
||||
from scipy.sparse.linalg import lsqr
|
||||
from time import time
|
||||
|
||||
# Set up a test problem
|
||||
n = 35
|
||||
G = np.eye(n)
|
||||
normal = np.random.normal
|
||||
norm = np.linalg.norm
|
||||
|
||||
for jj in xrange(5):
|
||||
gg = normal(size=n)
|
||||
hh = gg * gg.T
|
||||
G += (hh + hh.T) * 0.5
|
||||
G += normal(size=n) * normal(size=n)
|
||||
|
||||
b = normal(size=n)
|
||||
|
||||
tol = 1e-10
|
||||
show = False
|
||||
maxit = None
|
||||
|
||||
|
||||
def test_basic():
|
||||
b_copy = b.copy()
|
||||
X = lsqr(G, b, show=show, atol=tol, btol=tol, iter_lim=maxit)
|
||||
assert_(np.all(b_copy == b))
|
||||
|
||||
svx = np.linalg.solve(G, b)
|
||||
xo = X[0]
|
||||
assert_(norm(svx - xo) < 1e-5)
|
||||
|
||||
def test_gh_2466():
|
||||
row = np.array([0, 0])
|
||||
col = np.array([0, 1])
|
||||
val = np.array([1, -1])
|
||||
A = scipy.sparse.coo_matrix((val, (row, col)), shape=(1, 2))
|
||||
b = np.asarray([4])
|
||||
lsqr(A, b)
|
||||
|
||||
|
||||
def test_well_conditioned_problems():
|
||||
# Test that sparse the lsqr solver returns the right solution
|
||||
# on various problems with different random seeds.
|
||||
# This is a non-regression test for a potential ZeroDivisionError
|
||||
# raised when computing the `test2` & `test3` convergence conditions.
|
||||
n = 10
|
||||
A_sparse = scipy.sparse.eye(n, n)
|
||||
A_dense = A_sparse.toarray()
|
||||
|
||||
with np.errstate(invalid='raise'):
|
||||
for seed in range(30):
|
||||
rng = np.random.RandomState(seed + 10)
|
||||
beta = rng.rand(n)
|
||||
beta[beta == 0] = 0.00001 # ensure that all the betas are not null
|
||||
b = A_sparse * beta[:, np.newaxis]
|
||||
output = lsqr(A_sparse, b, show=show)
|
||||
|
||||
# Check that the termination condition corresponds to an approximate
|
||||
# solution to Ax = b
|
||||
assert_equal(output[1], 1)
|
||||
solution = output[0]
|
||||
|
||||
# Check that we recover the ground truth solution
|
||||
assert_array_almost_equal(solution, beta)
|
||||
|
||||
# Sanity check: compare to the dense array solver
|
||||
reference_solution = np.linalg.solve(A_dense, b).ravel()
|
||||
assert_array_almost_equal(solution, reference_solution)
|
||||
|
||||
|
||||
def test_b_shapes():
|
||||
# Test b being a scalar.
|
||||
A = np.array([[1.0, 2.0]])
|
||||
b = 3.0
|
||||
x = lsqr(A, b)[0]
|
||||
assert_almost_equal(norm(A.dot(x) - b), 0)
|
||||
|
||||
# Test b being a column vector.
|
||||
A = np.eye(10)
|
||||
b = np.ones((10, 1))
|
||||
x = lsqr(A, b)[0]
|
||||
assert_almost_equal(norm(A.dot(x) - b.ravel()), 0)
|
||||
|
||||
|
||||
def test_initialization():
|
||||
# Test the default setting is the same as zeros
|
||||
b_copy = b.copy()
|
||||
x_ref = lsqr(G, b, show=show, atol=tol, btol=tol, iter_lim=maxit)
|
||||
x0 = np.zeros(x_ref[0].shape)
|
||||
x = lsqr(G, b, show=show, atol=tol, btol=tol, iter_lim=maxit, x0=x0)
|
||||
assert_(np.all(b_copy == b))
|
||||
assert_array_almost_equal(x_ref[0], x[0])
|
||||
|
||||
# Test warm-start with single iteration
|
||||
x0 = lsqr(G, b, show=show, atol=tol, btol=tol, iter_lim=1)[0]
|
||||
x = lsqr(G, b, show=show, atol=tol, btol=tol, iter_lim=maxit, x0=x0)
|
||||
assert_array_almost_equal(x_ref[0], x[0])
|
||||
assert_(np.all(b_copy == b))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
svx = np.linalg.solve(G, b)
|
||||
|
||||
tic = time()
|
||||
X = lsqr(G, b, show=show, atol=tol, btol=tol, iter_lim=maxit)
|
||||
xo = X[0]
|
||||
phio = X[3]
|
||||
psio = X[7]
|
||||
k = X[2]
|
||||
chio = X[8]
|
||||
mg = np.amax(G - G.T)
|
||||
if mg > 1e-14:
|
||||
sym = 'No'
|
||||
else:
|
||||
sym = 'Yes'
|
||||
|
||||
print('LSQR')
|
||||
print("Is linear operator symmetric? " + sym)
|
||||
print("n: %3g iterations: %3g" % (n, k))
|
||||
print("Norms computed in %.2fs by LSQR" % (time() - tic))
|
||||
print(" ||x|| %9.4e ||r|| %9.4e ||Ar|| %9.4e " % (chio, phio, psio))
|
||||
print("Residual norms computed directly:")
|
||||
print(" ||x|| %9.4e ||r|| %9.4e ||Ar|| %9.4e" % (norm(xo),
|
||||
norm(G*xo - b),
|
||||
norm(G.T*(G*xo-b))))
|
||||
print("Direct solution norms:")
|
||||
print(" ||x|| %9.4e ||r|| %9.4e " % (norm(svx), norm(G*svx - b)))
|
||||
print("")
|
||||
print(" || x_{direct} - x_{LSQR}|| %9.4e " % norm(svx-xo))
|
||||
print("")
|
||||
+65
@@ -0,0 +1,65 @@
|
||||
from __future__ import division, print_function, absolute_import
|
||||
|
||||
import numpy as np
|
||||
from numpy.testing import assert_equal, assert_allclose, assert_
|
||||
from scipy.sparse.linalg.isolve import minres
|
||||
import pytest
|
||||
from pytest import raises as assert_raises
|
||||
from .test_iterative import assert_normclose
|
||||
|
||||
|
||||
def get_sample_problem():
|
||||
# A random 10 x 10 symmetric matrix
|
||||
np.random.seed(1234)
|
||||
matrix = np.random.rand(10, 10)
|
||||
matrix = matrix + matrix.T
|
||||
# A random vector of length 10
|
||||
vector = np.random.rand(10)
|
||||
return matrix, vector
|
||||
|
||||
|
||||
def test_singular():
|
||||
A, b = get_sample_problem()
|
||||
A[0, ] = 0
|
||||
b[0] = 0
|
||||
xp, info = minres(A, b)
|
||||
assert_equal(info, 0)
|
||||
assert_normclose(A.dot(xp), b, tol=1e-5)
|
||||
|
||||
|
||||
@pytest.mark.skip(reason="Skip Until gh #6843 is fixed")
|
||||
def test_gh_6843():
|
||||
"""check if x0 is being used by tracing iterates"""
|
||||
A, b = get_sample_problem()
|
||||
# Random x0 to feed minres
|
||||
np.random.seed(12345)
|
||||
x0 = np.random.rand(10)
|
||||
trace = []
|
||||
|
||||
def trace_iterates(xk):
|
||||
trace.append(xk)
|
||||
minres(A, b, x0=x0, callback=trace_iterates)
|
||||
trace_with_x0 = trace
|
||||
|
||||
trace = []
|
||||
minres(A, b, callback=trace_iterates)
|
||||
assert_(not np.array_equal(trace_with_x0[0], trace[0]))
|
||||
|
||||
|
||||
def test_shift():
|
||||
A, b = get_sample_problem()
|
||||
shift = 0.5
|
||||
shifted_A = A - shift * np.eye(10)
|
||||
x1, info1 = minres(A, b, shift=shift)
|
||||
x2, info2 = minres(shifted_A, b)
|
||||
assert_equal(info1, 0)
|
||||
assert_allclose(x1, x2, rtol=1e-5)
|
||||
|
||||
|
||||
def test_asymmetric_fail():
|
||||
"""Asymmetric matrix should raise `ValueError` when check=True"""
|
||||
A, b = get_sample_problem()
|
||||
A[1, 2] = 1
|
||||
A[2, 1] = 2
|
||||
with assert_raises(ValueError):
|
||||
xp, info = minres(A, b, check=True)
|
||||
@@ -0,0 +1,10 @@
|
||||
from __future__ import division, print_function, absolute_import
|
||||
|
||||
import numpy as np
|
||||
from pytest import raises as assert_raises
|
||||
|
||||
from scipy.sparse.linalg import utils
|
||||
|
||||
|
||||
def test_make_system_bad_shape():
|
||||
assert_raises(ValueError, utils.make_system, np.zeros((5,3)), None, np.zeros(4), np.zeros(4))
|
||||
@@ -0,0 +1,122 @@
|
||||
from __future__ import division, print_function, absolute_import
|
||||
|
||||
__docformat__ = "restructuredtext en"
|
||||
|
||||
__all__ = []
|
||||
|
||||
|
||||
from numpy import asanyarray, asarray, asmatrix, array, matrix, zeros
|
||||
|
||||
from scipy.sparse.linalg.interface import aslinearoperator, LinearOperator, \
|
||||
IdentityOperator
|
||||
|
||||
_coerce_rules = {('f','f'):'f', ('f','d'):'d', ('f','F'):'F',
|
||||
('f','D'):'D', ('d','f'):'d', ('d','d'):'d',
|
||||
('d','F'):'D', ('d','D'):'D', ('F','f'):'F',
|
||||
('F','d'):'D', ('F','F'):'F', ('F','D'):'D',
|
||||
('D','f'):'D', ('D','d'):'D', ('D','F'):'D',
|
||||
('D','D'):'D'}
|
||||
|
||||
|
||||
def coerce(x,y):
|
||||
if x not in 'fdFD':
|
||||
x = 'd'
|
||||
if y not in 'fdFD':
|
||||
y = 'd'
|
||||
return _coerce_rules[x,y]
|
||||
|
||||
|
||||
def id(x):
|
||||
return x
|
||||
|
||||
|
||||
def make_system(A, M, x0, b):
|
||||
"""Make a linear system Ax=b
|
||||
|
||||
Parameters
|
||||
----------
|
||||
A : LinearOperator
|
||||
sparse or dense matrix (or any valid input to aslinearoperator)
|
||||
M : {LinearOperator, Nones}
|
||||
preconditioner
|
||||
sparse or dense matrix (or any valid input to aslinearoperator)
|
||||
x0 : {array_like, None}
|
||||
initial guess to iterative method
|
||||
b : array_like
|
||||
right hand side
|
||||
|
||||
Returns
|
||||
-------
|
||||
(A, M, x, b, postprocess)
|
||||
A : LinearOperator
|
||||
matrix of the linear system
|
||||
M : LinearOperator
|
||||
preconditioner
|
||||
x : rank 1 ndarray
|
||||
initial guess
|
||||
b : rank 1 ndarray
|
||||
right hand side
|
||||
postprocess : function
|
||||
converts the solution vector to the appropriate
|
||||
type and dimensions (e.g. (N,1) matrix)
|
||||
|
||||
"""
|
||||
A_ = A
|
||||
A = aslinearoperator(A)
|
||||
|
||||
if A.shape[0] != A.shape[1]:
|
||||
raise ValueError('expected square matrix, but got shape=%s' % (A.shape,))
|
||||
|
||||
N = A.shape[0]
|
||||
|
||||
b = asanyarray(b)
|
||||
|
||||
if not (b.shape == (N,1) or b.shape == (N,)):
|
||||
raise ValueError('A and b have incompatible dimensions')
|
||||
|
||||
if b.dtype.char not in 'fdFD':
|
||||
b = b.astype('d') # upcast non-FP types to double
|
||||
|
||||
def postprocess(x):
|
||||
if isinstance(b,matrix):
|
||||
x = asmatrix(x)
|
||||
return x.reshape(b.shape)
|
||||
|
||||
if hasattr(A,'dtype'):
|
||||
xtype = A.dtype.char
|
||||
else:
|
||||
xtype = A.matvec(b).dtype.char
|
||||
xtype = coerce(xtype, b.dtype.char)
|
||||
|
||||
b = asarray(b,dtype=xtype) # make b the same type as x
|
||||
b = b.ravel()
|
||||
|
||||
if x0 is None:
|
||||
x = zeros(N, dtype=xtype)
|
||||
else:
|
||||
x = array(x0, dtype=xtype)
|
||||
if not (x.shape == (N,1) or x.shape == (N,)):
|
||||
raise ValueError('A and x have incompatible dimensions')
|
||||
x = x.ravel()
|
||||
|
||||
# process preconditioner
|
||||
if M is None:
|
||||
if hasattr(A_,'psolve'):
|
||||
psolve = A_.psolve
|
||||
else:
|
||||
psolve = id
|
||||
if hasattr(A_,'rpsolve'):
|
||||
rpsolve = A_.rpsolve
|
||||
else:
|
||||
rpsolve = id
|
||||
if psolve is id and rpsolve is id:
|
||||
M = IdentityOperator(shape=A.shape, dtype=A.dtype)
|
||||
else:
|
||||
M = LinearOperator(A.shape, matvec=psolve, rmatvec=rpsolve,
|
||||
dtype=A.dtype)
|
||||
else:
|
||||
M = aslinearoperator(M)
|
||||
if A.shape != M.shape:
|
||||
raise ValueError('matrix and preconditioner have different shapes')
|
||||
|
||||
return A, M, x, b, postprocess
|
||||
@@ -0,0 +1,868 @@
|
||||
"""
|
||||
Sparse matrix functions
|
||||
"""
|
||||
|
||||
#
|
||||
# Authors: Travis Oliphant, March 2002
|
||||
# Anthony Scopatz, August 2012 (Sparse Updates)
|
||||
# Jake Vanderplas, August 2012 (Sparse Updates)
|
||||
#
|
||||
|
||||
from __future__ import division, print_function, absolute_import
|
||||
|
||||
__all__ = ['expm', 'inv']
|
||||
|
||||
import math
|
||||
|
||||
import numpy as np
|
||||
|
||||
import scipy.special
|
||||
from scipy.linalg.basic import solve, solve_triangular
|
||||
|
||||
from scipy.sparse.base import isspmatrix
|
||||
from scipy.sparse.construct import eye as speye
|
||||
from scipy.sparse.linalg import spsolve
|
||||
|
||||
import scipy.sparse
|
||||
import scipy.sparse.linalg
|
||||
from scipy.sparse.linalg.interface import LinearOperator
|
||||
|
||||
|
||||
UPPER_TRIANGULAR = 'upper_triangular'
|
||||
|
||||
|
||||
def inv(A):
|
||||
"""
|
||||
Compute the inverse of a sparse matrix
|
||||
|
||||
Parameters
|
||||
----------
|
||||
A : (M,M) ndarray or sparse matrix
|
||||
square matrix to be inverted
|
||||
|
||||
Returns
|
||||
-------
|
||||
Ainv : (M,M) ndarray or sparse matrix
|
||||
inverse of `A`
|
||||
|
||||
Notes
|
||||
-----
|
||||
This computes the sparse inverse of `A`. If the inverse of `A` is expected
|
||||
to be non-sparse, it will likely be faster to convert `A` to dense and use
|
||||
scipy.linalg.inv.
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> from scipy.sparse import csc_matrix
|
||||
>>> from scipy.sparse.linalg import inv
|
||||
>>> A = csc_matrix([[1., 0.], [1., 2.]])
|
||||
>>> Ainv = inv(A)
|
||||
>>> Ainv
|
||||
<2x2 sparse matrix of type '<class 'numpy.float64'>'
|
||||
with 3 stored elements in Compressed Sparse Column format>
|
||||
>>> A.dot(Ainv)
|
||||
<2x2 sparse matrix of type '<class 'numpy.float64'>'
|
||||
with 2 stored elements in Compressed Sparse Column format>
|
||||
>>> A.dot(Ainv).todense()
|
||||
matrix([[ 1., 0.],
|
||||
[ 0., 1.]])
|
||||
|
||||
.. versionadded:: 0.12.0
|
||||
|
||||
"""
|
||||
#check input
|
||||
if not scipy.sparse.isspmatrix(A):
|
||||
raise TypeError('Input must be a sparse matrix')
|
||||
|
||||
I = speye(A.shape[0], A.shape[1], dtype=A.dtype, format=A.format)
|
||||
Ainv = spsolve(A, I)
|
||||
return Ainv
|
||||
|
||||
|
||||
def _onenorm_matrix_power_nnm(A, p):
|
||||
"""
|
||||
Compute the 1-norm of a non-negative integer power of a non-negative matrix.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
A : a square ndarray or matrix or sparse matrix
|
||||
Input matrix with non-negative entries.
|
||||
p : non-negative integer
|
||||
The power to which the matrix is to be raised.
|
||||
|
||||
Returns
|
||||
-------
|
||||
out : float
|
||||
The 1-norm of the matrix power p of A.
|
||||
|
||||
"""
|
||||
# check input
|
||||
if int(p) != p or p < 0:
|
||||
raise ValueError('expected non-negative integer p')
|
||||
p = int(p)
|
||||
if len(A.shape) != 2 or A.shape[0] != A.shape[1]:
|
||||
raise ValueError('expected A to be like a square matrix')
|
||||
|
||||
# Explicitly make a column vector so that this works when A is a
|
||||
# numpy matrix (in addition to ndarray and sparse matrix).
|
||||
v = np.ones((A.shape[0], 1), dtype=float)
|
||||
M = A.T
|
||||
for i in range(p):
|
||||
v = M.dot(v)
|
||||
return np.max(v)
|
||||
|
||||
|
||||
def _onenorm(A):
|
||||
# A compatibility function which should eventually disappear.
|
||||
# This is copypasted from expm_action.
|
||||
if scipy.sparse.isspmatrix(A):
|
||||
return max(abs(A).sum(axis=0).flat)
|
||||
else:
|
||||
return np.linalg.norm(A, 1)
|
||||
|
||||
|
||||
def _ident_like(A):
|
||||
# A compatibility function which should eventually disappear.
|
||||
# This is copypasted from expm_action.
|
||||
if scipy.sparse.isspmatrix(A):
|
||||
return scipy.sparse.construct.eye(A.shape[0], A.shape[1],
|
||||
dtype=A.dtype, format=A.format)
|
||||
else:
|
||||
return np.eye(A.shape[0], A.shape[1], dtype=A.dtype)
|
||||
|
||||
|
||||
def _is_upper_triangular(A):
|
||||
# This function could possibly be of wider interest.
|
||||
if isspmatrix(A):
|
||||
lower_part = scipy.sparse.tril(A, -1)
|
||||
# Check structural upper triangularity,
|
||||
# then coincidental upper triangularity if needed.
|
||||
return lower_part.nnz == 0 or lower_part.count_nonzero() == 0
|
||||
else:
|
||||
return not np.tril(A, -1).any()
|
||||
|
||||
|
||||
def _smart_matrix_product(A, B, alpha=None, structure=None):
|
||||
"""
|
||||
A matrix product that knows about sparse and structured matrices.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
A : 2d ndarray
|
||||
First matrix.
|
||||
B : 2d ndarray
|
||||
Second matrix.
|
||||
alpha : float
|
||||
The matrix product will be scaled by this constant.
|
||||
structure : str, optional
|
||||
A string describing the structure of both matrices `A` and `B`.
|
||||
Only `upper_triangular` is currently supported.
|
||||
|
||||
Returns
|
||||
-------
|
||||
M : 2d ndarray
|
||||
Matrix product of A and B.
|
||||
|
||||
"""
|
||||
if len(A.shape) != 2:
|
||||
raise ValueError('expected A to be a rectangular matrix')
|
||||
if len(B.shape) != 2:
|
||||
raise ValueError('expected B to be a rectangular matrix')
|
||||
f = None
|
||||
if structure == UPPER_TRIANGULAR:
|
||||
if not isspmatrix(A) and not isspmatrix(B):
|
||||
f, = scipy.linalg.get_blas_funcs(('trmm',), (A, B))
|
||||
if f is not None:
|
||||
if alpha is None:
|
||||
alpha = 1.
|
||||
out = f(alpha, A, B)
|
||||
else:
|
||||
if alpha is None:
|
||||
out = A.dot(B)
|
||||
else:
|
||||
out = alpha * A.dot(B)
|
||||
return out
|
||||
|
||||
|
||||
class MatrixPowerOperator(LinearOperator):
|
||||
|
||||
def __init__(self, A, p, structure=None):
|
||||
if A.ndim != 2 or A.shape[0] != A.shape[1]:
|
||||
raise ValueError('expected A to be like a square matrix')
|
||||
if p < 0:
|
||||
raise ValueError('expected p to be a non-negative integer')
|
||||
self._A = A
|
||||
self._p = p
|
||||
self._structure = structure
|
||||
self.dtype = A.dtype
|
||||
self.ndim = A.ndim
|
||||
self.shape = A.shape
|
||||
|
||||
def _matvec(self, x):
|
||||
for i in range(self._p):
|
||||
x = self._A.dot(x)
|
||||
return x
|
||||
|
||||
def _rmatvec(self, x):
|
||||
A_T = self._A.T
|
||||
x = x.ravel()
|
||||
for i in range(self._p):
|
||||
x = A_T.dot(x)
|
||||
return x
|
||||
|
||||
def _matmat(self, X):
|
||||
for i in range(self._p):
|
||||
X = _smart_matrix_product(self._A, X, structure=self._structure)
|
||||
return X
|
||||
|
||||
@property
|
||||
def T(self):
|
||||
return MatrixPowerOperator(self._A.T, self._p)
|
||||
|
||||
|
||||
class ProductOperator(LinearOperator):
|
||||
"""
|
||||
For now, this is limited to products of multiple square matrices.
|
||||
"""
|
||||
|
||||
def __init__(self, *args, **kwargs):
|
||||
self._structure = kwargs.get('structure', None)
|
||||
for A in args:
|
||||
if len(A.shape) != 2 or A.shape[0] != A.shape[1]:
|
||||
raise ValueError(
|
||||
'For now, the ProductOperator implementation is '
|
||||
'limited to the product of multiple square matrices.')
|
||||
if args:
|
||||
n = args[0].shape[0]
|
||||
for A in args:
|
||||
for d in A.shape:
|
||||
if d != n:
|
||||
raise ValueError(
|
||||
'The square matrices of the ProductOperator '
|
||||
'must all have the same shape.')
|
||||
self.shape = (n, n)
|
||||
self.ndim = len(self.shape)
|
||||
self.dtype = np.find_common_type([x.dtype for x in args], [])
|
||||
self._operator_sequence = args
|
||||
|
||||
def _matvec(self, x):
|
||||
for A in reversed(self._operator_sequence):
|
||||
x = A.dot(x)
|
||||
return x
|
||||
|
||||
def _rmatvec(self, x):
|
||||
x = x.ravel()
|
||||
for A in self._operator_sequence:
|
||||
x = A.T.dot(x)
|
||||
return x
|
||||
|
||||
def _matmat(self, X):
|
||||
for A in reversed(self._operator_sequence):
|
||||
X = _smart_matrix_product(A, X, structure=self._structure)
|
||||
return X
|
||||
|
||||
@property
|
||||
def T(self):
|
||||
T_args = [A.T for A in reversed(self._operator_sequence)]
|
||||
return ProductOperator(*T_args)
|
||||
|
||||
|
||||
def _onenormest_matrix_power(A, p,
|
||||
t=2, itmax=5, compute_v=False, compute_w=False, structure=None):
|
||||
"""
|
||||
Efficiently estimate the 1-norm of A^p.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
A : ndarray
|
||||
Matrix whose 1-norm of a power is to be computed.
|
||||
p : int
|
||||
Non-negative integer power.
|
||||
t : int, optional
|
||||
A positive parameter controlling the tradeoff between
|
||||
accuracy versus time and memory usage.
|
||||
Larger values take longer and use more memory
|
||||
but give more accurate output.
|
||||
itmax : int, optional
|
||||
Use at most this many iterations.
|
||||
compute_v : bool, optional
|
||||
Request a norm-maximizing linear operator input vector if True.
|
||||
compute_w : bool, optional
|
||||
Request a norm-maximizing linear operator output vector if True.
|
||||
|
||||
Returns
|
||||
-------
|
||||
est : float
|
||||
An underestimate of the 1-norm of the sparse matrix.
|
||||
v : ndarray, optional
|
||||
The vector such that ||Av||_1 == est*||v||_1.
|
||||
It can be thought of as an input to the linear operator
|
||||
that gives an output with particularly large norm.
|
||||
w : ndarray, optional
|
||||
The vector Av which has relatively large 1-norm.
|
||||
It can be thought of as an output of the linear operator
|
||||
that is relatively large in norm compared to the input.
|
||||
|
||||
"""
|
||||
return scipy.sparse.linalg.onenormest(
|
||||
MatrixPowerOperator(A, p, structure=structure))
|
||||
|
||||
|
||||
def _onenormest_product(operator_seq,
|
||||
t=2, itmax=5, compute_v=False, compute_w=False, structure=None):
|
||||
"""
|
||||
Efficiently estimate the 1-norm of the matrix product of the args.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
operator_seq : linear operator sequence
|
||||
Matrices whose 1-norm of product is to be computed.
|
||||
t : int, optional
|
||||
A positive parameter controlling the tradeoff between
|
||||
accuracy versus time and memory usage.
|
||||
Larger values take longer and use more memory
|
||||
but give more accurate output.
|
||||
itmax : int, optional
|
||||
Use at most this many iterations.
|
||||
compute_v : bool, optional
|
||||
Request a norm-maximizing linear operator input vector if True.
|
||||
compute_w : bool, optional
|
||||
Request a norm-maximizing linear operator output vector if True.
|
||||
structure : str, optional
|
||||
A string describing the structure of all operators.
|
||||
Only `upper_triangular` is currently supported.
|
||||
|
||||
Returns
|
||||
-------
|
||||
est : float
|
||||
An underestimate of the 1-norm of the sparse matrix.
|
||||
v : ndarray, optional
|
||||
The vector such that ||Av||_1 == est*||v||_1.
|
||||
It can be thought of as an input to the linear operator
|
||||
that gives an output with particularly large norm.
|
||||
w : ndarray, optional
|
||||
The vector Av which has relatively large 1-norm.
|
||||
It can be thought of as an output of the linear operator
|
||||
that is relatively large in norm compared to the input.
|
||||
|
||||
"""
|
||||
return scipy.sparse.linalg.onenormest(
|
||||
ProductOperator(*operator_seq, structure=structure))
|
||||
|
||||
|
||||
class _ExpmPadeHelper(object):
|
||||
"""
|
||||
Help lazily evaluate a matrix exponential.
|
||||
|
||||
The idea is to not do more work than we need for high expm precision,
|
||||
so we lazily compute matrix powers and store or precompute
|
||||
other properties of the matrix.
|
||||
|
||||
"""
|
||||
def __init__(self, A, structure=None, use_exact_onenorm=False):
|
||||
"""
|
||||
Initialize the object.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
A : a dense or sparse square numpy matrix or ndarray
|
||||
The matrix to be exponentiated.
|
||||
structure : str, optional
|
||||
A string describing the structure of matrix `A`.
|
||||
Only `upper_triangular` is currently supported.
|
||||
use_exact_onenorm : bool, optional
|
||||
If True then only the exact one-norm of matrix powers and products
|
||||
will be used. Otherwise, the one-norm of powers and products
|
||||
may initially be estimated.
|
||||
"""
|
||||
self.A = A
|
||||
self._A2 = None
|
||||
self._A4 = None
|
||||
self._A6 = None
|
||||
self._A8 = None
|
||||
self._A10 = None
|
||||
self._d4_exact = None
|
||||
self._d6_exact = None
|
||||
self._d8_exact = None
|
||||
self._d10_exact = None
|
||||
self._d4_approx = None
|
||||
self._d6_approx = None
|
||||
self._d8_approx = None
|
||||
self._d10_approx = None
|
||||
self.ident = _ident_like(A)
|
||||
self.structure = structure
|
||||
self.use_exact_onenorm = use_exact_onenorm
|
||||
|
||||
@property
|
||||
def A2(self):
|
||||
if self._A2 is None:
|
||||
self._A2 = _smart_matrix_product(
|
||||
self.A, self.A, structure=self.structure)
|
||||
return self._A2
|
||||
|
||||
@property
|
||||
def A4(self):
|
||||
if self._A4 is None:
|
||||
self._A4 = _smart_matrix_product(
|
||||
self.A2, self.A2, structure=self.structure)
|
||||
return self._A4
|
||||
|
||||
@property
|
||||
def A6(self):
|
||||
if self._A6 is None:
|
||||
self._A6 = _smart_matrix_product(
|
||||
self.A4, self.A2, structure=self.structure)
|
||||
return self._A6
|
||||
|
||||
@property
|
||||
def A8(self):
|
||||
if self._A8 is None:
|
||||
self._A8 = _smart_matrix_product(
|
||||
self.A6, self.A2, structure=self.structure)
|
||||
return self._A8
|
||||
|
||||
@property
|
||||
def A10(self):
|
||||
if self._A10 is None:
|
||||
self._A10 = _smart_matrix_product(
|
||||
self.A4, self.A6, structure=self.structure)
|
||||
return self._A10
|
||||
|
||||
@property
|
||||
def d4_tight(self):
|
||||
if self._d4_exact is None:
|
||||
self._d4_exact = _onenorm(self.A4)**(1/4.)
|
||||
return self._d4_exact
|
||||
|
||||
@property
|
||||
def d6_tight(self):
|
||||
if self._d6_exact is None:
|
||||
self._d6_exact = _onenorm(self.A6)**(1/6.)
|
||||
return self._d6_exact
|
||||
|
||||
@property
|
||||
def d8_tight(self):
|
||||
if self._d8_exact is None:
|
||||
self._d8_exact = _onenorm(self.A8)**(1/8.)
|
||||
return self._d8_exact
|
||||
|
||||
@property
|
||||
def d10_tight(self):
|
||||
if self._d10_exact is None:
|
||||
self._d10_exact = _onenorm(self.A10)**(1/10.)
|
||||
return self._d10_exact
|
||||
|
||||
@property
|
||||
def d4_loose(self):
|
||||
if self.use_exact_onenorm:
|
||||
return self.d4_tight
|
||||
if self._d4_exact is not None:
|
||||
return self._d4_exact
|
||||
else:
|
||||
if self._d4_approx is None:
|
||||
self._d4_approx = _onenormest_matrix_power(self.A2, 2,
|
||||
structure=self.structure)**(1/4.)
|
||||
return self._d4_approx
|
||||
|
||||
@property
|
||||
def d6_loose(self):
|
||||
if self.use_exact_onenorm:
|
||||
return self.d6_tight
|
||||
if self._d6_exact is not None:
|
||||
return self._d6_exact
|
||||
else:
|
||||
if self._d6_approx is None:
|
||||
self._d6_approx = _onenormest_matrix_power(self.A2, 3,
|
||||
structure=self.structure)**(1/6.)
|
||||
return self._d6_approx
|
||||
|
||||
@property
|
||||
def d8_loose(self):
|
||||
if self.use_exact_onenorm:
|
||||
return self.d8_tight
|
||||
if self._d8_exact is not None:
|
||||
return self._d8_exact
|
||||
else:
|
||||
if self._d8_approx is None:
|
||||
self._d8_approx = _onenormest_matrix_power(self.A4, 2,
|
||||
structure=self.structure)**(1/8.)
|
||||
return self._d8_approx
|
||||
|
||||
@property
|
||||
def d10_loose(self):
|
||||
if self.use_exact_onenorm:
|
||||
return self.d10_tight
|
||||
if self._d10_exact is not None:
|
||||
return self._d10_exact
|
||||
else:
|
||||
if self._d10_approx is None:
|
||||
self._d10_approx = _onenormest_product((self.A4, self.A6),
|
||||
structure=self.structure)**(1/10.)
|
||||
return self._d10_approx
|
||||
|
||||
def pade3(self):
|
||||
b = (120., 60., 12., 1.)
|
||||
U = _smart_matrix_product(self.A,
|
||||
b[3]*self.A2 + b[1]*self.ident,
|
||||
structure=self.structure)
|
||||
V = b[2]*self.A2 + b[0]*self.ident
|
||||
return U, V
|
||||
|
||||
def pade5(self):
|
||||
b = (30240., 15120., 3360., 420., 30., 1.)
|
||||
U = _smart_matrix_product(self.A,
|
||||
b[5]*self.A4 + b[3]*self.A2 + b[1]*self.ident,
|
||||
structure=self.structure)
|
||||
V = b[4]*self.A4 + b[2]*self.A2 + b[0]*self.ident
|
||||
return U, V
|
||||
|
||||
def pade7(self):
|
||||
b = (17297280., 8648640., 1995840., 277200., 25200., 1512., 56., 1.)
|
||||
U = _smart_matrix_product(self.A,
|
||||
b[7]*self.A6 + b[5]*self.A4 + b[3]*self.A2 + b[1]*self.ident,
|
||||
structure=self.structure)
|
||||
V = b[6]*self.A6 + b[4]*self.A4 + b[2]*self.A2 + b[0]*self.ident
|
||||
return U, V
|
||||
|
||||
def pade9(self):
|
||||
b = (17643225600., 8821612800., 2075673600., 302702400., 30270240.,
|
||||
2162160., 110880., 3960., 90., 1.)
|
||||
U = _smart_matrix_product(self.A,
|
||||
(b[9]*self.A8 + b[7]*self.A6 + b[5]*self.A4 +
|
||||
b[3]*self.A2 + b[1]*self.ident),
|
||||
structure=self.structure)
|
||||
V = (b[8]*self.A8 + b[6]*self.A6 + b[4]*self.A4 +
|
||||
b[2]*self.A2 + b[0]*self.ident)
|
||||
return U, V
|
||||
|
||||
def pade13_scaled(self, s):
|
||||
b = (64764752532480000., 32382376266240000., 7771770303897600.,
|
||||
1187353796428800., 129060195264000., 10559470521600.,
|
||||
670442572800., 33522128640., 1323241920., 40840800., 960960.,
|
||||
16380., 182., 1.)
|
||||
B = self.A * 2**-s
|
||||
B2 = self.A2 * 2**(-2*s)
|
||||
B4 = self.A4 * 2**(-4*s)
|
||||
B6 = self.A6 * 2**(-6*s)
|
||||
U2 = _smart_matrix_product(B6,
|
||||
b[13]*B6 + b[11]*B4 + b[9]*B2,
|
||||
structure=self.structure)
|
||||
U = _smart_matrix_product(B,
|
||||
(U2 + b[7]*B6 + b[5]*B4 +
|
||||
b[3]*B2 + b[1]*self.ident),
|
||||
structure=self.structure)
|
||||
V2 = _smart_matrix_product(B6,
|
||||
b[12]*B6 + b[10]*B4 + b[8]*B2,
|
||||
structure=self.structure)
|
||||
V = V2 + b[6]*B6 + b[4]*B4 + b[2]*B2 + b[0]*self.ident
|
||||
return U, V
|
||||
|
||||
|
||||
def expm(A):
|
||||
"""
|
||||
Compute the matrix exponential using Pade approximation.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
A : (M,M) array_like or sparse matrix
|
||||
2D Array or Matrix (sparse or dense) to be exponentiated
|
||||
|
||||
Returns
|
||||
-------
|
||||
expA : (M,M) ndarray
|
||||
Matrix exponential of `A`
|
||||
|
||||
Notes
|
||||
-----
|
||||
This is algorithm (6.1) which is a simplification of algorithm (5.1).
|
||||
|
||||
.. versionadded:: 0.12.0
|
||||
|
||||
References
|
||||
----------
|
||||
.. [1] Awad H. Al-Mohy and Nicholas J. Higham (2009)
|
||||
"A New Scaling and Squaring Algorithm for the Matrix Exponential."
|
||||
SIAM Journal on Matrix Analysis and Applications.
|
||||
31 (3). pp. 970-989. ISSN 1095-7162
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> from scipy.sparse import csc_matrix
|
||||
>>> from scipy.sparse.linalg import expm
|
||||
>>> A = csc_matrix([[1, 0, 0], [0, 2, 0], [0, 0, 3]])
|
||||
>>> A.todense()
|
||||
matrix([[1, 0, 0],
|
||||
[0, 2, 0],
|
||||
[0, 0, 3]], dtype=int64)
|
||||
>>> Aexp = expm(A)
|
||||
>>> Aexp
|
||||
<3x3 sparse matrix of type '<class 'numpy.float64'>'
|
||||
with 3 stored elements in Compressed Sparse Column format>
|
||||
>>> Aexp.todense()
|
||||
matrix([[ 2.71828183, 0. , 0. ],
|
||||
[ 0. , 7.3890561 , 0. ],
|
||||
[ 0. , 0. , 20.08553692]])
|
||||
"""
|
||||
return _expm(A, use_exact_onenorm='auto')
|
||||
|
||||
|
||||
def _expm(A, use_exact_onenorm):
|
||||
# Core of expm, separated to allow testing exact and approximate
|
||||
# algorithms.
|
||||
|
||||
# Avoid indiscriminate asarray() to allow sparse or other strange arrays.
|
||||
if isinstance(A, (list, tuple)):
|
||||
A = np.asarray(A)
|
||||
if len(A.shape) != 2 or A.shape[0] != A.shape[1]:
|
||||
raise ValueError('expected a square matrix')
|
||||
|
||||
# Trivial case
|
||||
if A.shape == (1, 1):
|
||||
out = [[np.exp(A[0, 0])]]
|
||||
|
||||
# Avoid indiscriminate casting to ndarray to
|
||||
# allow for sparse or other strange arrays
|
||||
if isspmatrix(A):
|
||||
return A.__class__(out)
|
||||
|
||||
return np.array(out)
|
||||
|
||||
# Ensure input is of float type, to avoid integer overflows etc.
|
||||
if ((isinstance(A, np.ndarray) or isspmatrix(A))
|
||||
and not np.issubdtype(A.dtype, np.inexact)):
|
||||
A = A.astype(float)
|
||||
|
||||
# Detect upper triangularity.
|
||||
structure = UPPER_TRIANGULAR if _is_upper_triangular(A) else None
|
||||
|
||||
if use_exact_onenorm == "auto":
|
||||
# Hardcode a matrix order threshold for exact vs. estimated one-norms.
|
||||
use_exact_onenorm = A.shape[0] < 200
|
||||
|
||||
# Track functions of A to help compute the matrix exponential.
|
||||
h = _ExpmPadeHelper(
|
||||
A, structure=structure, use_exact_onenorm=use_exact_onenorm)
|
||||
|
||||
# Try Pade order 3.
|
||||
eta_1 = max(h.d4_loose, h.d6_loose)
|
||||
if eta_1 < 1.495585217958292e-002 and _ell(h.A, 3) == 0:
|
||||
U, V = h.pade3()
|
||||
return _solve_P_Q(U, V, structure=structure)
|
||||
|
||||
# Try Pade order 5.
|
||||
eta_2 = max(h.d4_tight, h.d6_loose)
|
||||
if eta_2 < 2.539398330063230e-001 and _ell(h.A, 5) == 0:
|
||||
U, V = h.pade5()
|
||||
return _solve_P_Q(U, V, structure=structure)
|
||||
|
||||
# Try Pade orders 7 and 9.
|
||||
eta_3 = max(h.d6_tight, h.d8_loose)
|
||||
if eta_3 < 9.504178996162932e-001 and _ell(h.A, 7) == 0:
|
||||
U, V = h.pade7()
|
||||
return _solve_P_Q(U, V, structure=structure)
|
||||
if eta_3 < 2.097847961257068e+000 and _ell(h.A, 9) == 0:
|
||||
U, V = h.pade9()
|
||||
return _solve_P_Q(U, V, structure=structure)
|
||||
|
||||
# Use Pade order 13.
|
||||
eta_4 = max(h.d8_loose, h.d10_loose)
|
||||
eta_5 = min(eta_3, eta_4)
|
||||
theta_13 = 4.25
|
||||
|
||||
# Choose smallest s>=0 such that 2**(-s) eta_5 <= theta_13
|
||||
if eta_5 == 0:
|
||||
# Nilpotent special case
|
||||
s = 0
|
||||
else:
|
||||
s = max(int(np.ceil(np.log2(eta_5 / theta_13))), 0)
|
||||
s = s + _ell(2**-s * h.A, 13)
|
||||
U, V = h.pade13_scaled(s)
|
||||
X = _solve_P_Q(U, V, structure=structure)
|
||||
if structure == UPPER_TRIANGULAR:
|
||||
# Invoke Code Fragment 2.1.
|
||||
X = _fragment_2_1(X, h.A, s)
|
||||
else:
|
||||
# X = r_13(A)^(2^s) by repeated squaring.
|
||||
for i in range(s):
|
||||
X = X.dot(X)
|
||||
return X
|
||||
|
||||
|
||||
def _solve_P_Q(U, V, structure=None):
|
||||
"""
|
||||
A helper function for expm_2009.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
U : ndarray
|
||||
Pade numerator.
|
||||
V : ndarray
|
||||
Pade denominator.
|
||||
structure : str, optional
|
||||
A string describing the structure of both matrices `U` and `V`.
|
||||
Only `upper_triangular` is currently supported.
|
||||
|
||||
Notes
|
||||
-----
|
||||
The `structure` argument is inspired by similar args
|
||||
for theano and cvxopt functions.
|
||||
|
||||
"""
|
||||
P = U + V
|
||||
Q = -U + V
|
||||
if isspmatrix(U):
|
||||
return spsolve(Q, P)
|
||||
elif structure is None:
|
||||
return solve(Q, P)
|
||||
elif structure == UPPER_TRIANGULAR:
|
||||
return solve_triangular(Q, P)
|
||||
else:
|
||||
raise ValueError('unsupported matrix structure: ' + str(structure))
|
||||
|
||||
|
||||
def _sinch(x):
|
||||
"""
|
||||
Stably evaluate sinch.
|
||||
|
||||
Notes
|
||||
-----
|
||||
The strategy of falling back to a sixth order Taylor expansion
|
||||
was suggested by the Spallation Neutron Source docs
|
||||
which was found on the internet by google search.
|
||||
http://www.ornl.gov/~t6p/resources/xal/javadoc/gov/sns/tools/math/ElementaryFunction.html
|
||||
The details of the cutoff point and the Horner-like evaluation
|
||||
was picked without reference to anything in particular.
|
||||
|
||||
Note that sinch is not currently implemented in scipy.special,
|
||||
whereas the "engineer's" definition of sinc is implemented.
|
||||
The implementation of sinc involves a scaling factor of pi
|
||||
that distinguishes it from the "mathematician's" version of sinc.
|
||||
|
||||
"""
|
||||
|
||||
# If x is small then use sixth order Taylor expansion.
|
||||
# How small is small? I am using the point where the relative error
|
||||
# of the approximation is less than 1e-14.
|
||||
# If x is large then directly evaluate sinh(x) / x.
|
||||
x2 = x*x
|
||||
if abs(x) < 0.0135:
|
||||
return 1 + (x2/6.)*(1 + (x2/20.)*(1 + (x2/42.)))
|
||||
else:
|
||||
return np.sinh(x) / x
|
||||
|
||||
|
||||
def _eq_10_42(lam_1, lam_2, t_12):
|
||||
"""
|
||||
Equation (10.42) of Functions of Matrices: Theory and Computation.
|
||||
|
||||
Notes
|
||||
-----
|
||||
This is a helper function for _fragment_2_1 of expm_2009.
|
||||
Equation (10.42) is on page 251 in the section on Schur algorithms.
|
||||
In particular, section 10.4.3 explains the Schur-Parlett algorithm.
|
||||
expm([[lam_1, t_12], [0, lam_1])
|
||||
=
|
||||
[[exp(lam_1), t_12*exp((lam_1 + lam_2)/2)*sinch((lam_1 - lam_2)/2)],
|
||||
[0, exp(lam_2)]
|
||||
"""
|
||||
|
||||
# The plain formula t_12 * (exp(lam_2) - exp(lam_2)) / (lam_2 - lam_1)
|
||||
# apparently suffers from cancellation, according to Higham's textbook.
|
||||
# A nice implementation of sinch, defined as sinh(x)/x,
|
||||
# will apparently work around the cancellation.
|
||||
a = 0.5 * (lam_1 + lam_2)
|
||||
b = 0.5 * (lam_1 - lam_2)
|
||||
return t_12 * np.exp(a) * _sinch(b)
|
||||
|
||||
|
||||
def _fragment_2_1(X, T, s):
|
||||
"""
|
||||
A helper function for expm_2009.
|
||||
|
||||
Notes
|
||||
-----
|
||||
The argument X is modified in-place, but this modification is not the same
|
||||
as the returned value of the function.
|
||||
This function also takes pains to do things in ways that are compatible
|
||||
with sparse matrices, for example by avoiding fancy indexing
|
||||
and by using methods of the matrices whenever possible instead of
|
||||
using functions of the numpy or scipy libraries themselves.
|
||||
|
||||
"""
|
||||
# Form X = r_m(2^-s T)
|
||||
# Replace diag(X) by exp(2^-s diag(T)).
|
||||
n = X.shape[0]
|
||||
diag_T = np.ravel(T.diagonal().copy())
|
||||
|
||||
# Replace diag(X) by exp(2^-s diag(T)).
|
||||
scale = 2 ** -s
|
||||
exp_diag = np.exp(scale * diag_T)
|
||||
for k in range(n):
|
||||
X[k, k] = exp_diag[k]
|
||||
|
||||
for i in range(s-1, -1, -1):
|
||||
X = X.dot(X)
|
||||
|
||||
# Replace diag(X) by exp(2^-i diag(T)).
|
||||
scale = 2 ** -i
|
||||
exp_diag = np.exp(scale * diag_T)
|
||||
for k in range(n):
|
||||
X[k, k] = exp_diag[k]
|
||||
|
||||
# Replace (first) superdiagonal of X by explicit formula
|
||||
# for superdiagonal of exp(2^-i T) from Eq (10.42) of
|
||||
# the author's 2008 textbook
|
||||
# Functions of Matrices: Theory and Computation.
|
||||
for k in range(n-1):
|
||||
lam_1 = scale * diag_T[k]
|
||||
lam_2 = scale * diag_T[k+1]
|
||||
t_12 = scale * T[k, k+1]
|
||||
value = _eq_10_42(lam_1, lam_2, t_12)
|
||||
X[k, k+1] = value
|
||||
|
||||
# Return the updated X matrix.
|
||||
return X
|
||||
|
||||
|
||||
def _ell(A, m):
|
||||
"""
|
||||
A helper function for expm_2009.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
A : linear operator
|
||||
A linear operator whose norm of power we care about.
|
||||
m : int
|
||||
The power of the linear operator
|
||||
|
||||
Returns
|
||||
-------
|
||||
value : int
|
||||
A value related to a bound.
|
||||
|
||||
"""
|
||||
if len(A.shape) != 2 or A.shape[0] != A.shape[1]:
|
||||
raise ValueError('expected A to be like a square matrix')
|
||||
|
||||
p = 2*m + 1
|
||||
|
||||
# The c_i are explained in (2.2) and (2.6) of the 2005 expm paper.
|
||||
# They are coefficients of terms of a generating function series expansion.
|
||||
choose_2p_p = scipy.special.comb(2*p, p, exact=True)
|
||||
abs_c_recip = float(choose_2p_p * math.factorial(2*p + 1))
|
||||
|
||||
# This is explained after Eq. (1.2) of the 2009 expm paper.
|
||||
# It is the "unit roundoff" of IEEE double precision arithmetic.
|
||||
u = 2**-53
|
||||
|
||||
# Compute the one-norm of matrix power p of abs(A).
|
||||
A_abs_onenorm = _onenorm_matrix_power_nnm(abs(A), p)
|
||||
|
||||
# Treat zero norm as a special case.
|
||||
if not A_abs_onenorm:
|
||||
return 0
|
||||
|
||||
alpha = A_abs_onenorm / (_onenorm(A) * abs_c_recip)
|
||||
log2_alpha_div_u = np.log2(alpha/u)
|
||||
value = int(np.ceil(log2_alpha_div_u / (2 * m)))
|
||||
return max(value, 0)
|
||||
@@ -0,0 +1,20 @@
|
||||
from __future__ import division, print_function, absolute_import
|
||||
|
||||
|
||||
def configuration(parent_package='',top_path=None):
|
||||
from numpy.distutils.misc_util import Configuration
|
||||
|
||||
config = Configuration('linalg',parent_package,top_path)
|
||||
|
||||
config.add_subpackage(('isolve'))
|
||||
config.add_subpackage(('dsolve'))
|
||||
config.add_subpackage(('eigen'))
|
||||
|
||||
config.add_data_dir('tests')
|
||||
|
||||
return config
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
from numpy.distutils.core import setup
|
||||
setup(**configuration(top_path='').todict())
|
||||
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
+254
@@ -0,0 +1,254 @@
|
||||
"""Test functions for the sparse.linalg._expm_multiply module
|
||||
"""
|
||||
|
||||
from __future__ import division, print_function, absolute_import
|
||||
|
||||
import numpy as np
|
||||
from numpy.testing import assert_allclose, assert_, assert_equal
|
||||
from scipy._lib._numpy_compat import suppress_warnings
|
||||
|
||||
from scipy.sparse import SparseEfficiencyWarning
|
||||
import scipy.linalg
|
||||
from scipy.sparse.linalg._expm_multiply import (_theta, _compute_p_max,
|
||||
_onenormest_matrix_power, expm_multiply, _expm_multiply_simple,
|
||||
_expm_multiply_interval)
|
||||
|
||||
|
||||
def less_than_or_close(a, b):
|
||||
return np.allclose(a, b) or (a < b)
|
||||
|
||||
|
||||
class TestExpmActionSimple(object):
|
||||
"""
|
||||
These tests do not consider the case of multiple time steps in one call.
|
||||
"""
|
||||
|
||||
def test_theta_monotonicity(self):
|
||||
pairs = sorted(_theta.items())
|
||||
for (m_a, theta_a), (m_b, theta_b) in zip(pairs[:-1], pairs[1:]):
|
||||
assert_(theta_a < theta_b)
|
||||
|
||||
def test_p_max_default(self):
|
||||
m_max = 55
|
||||
expected_p_max = 8
|
||||
observed_p_max = _compute_p_max(m_max)
|
||||
assert_equal(observed_p_max, expected_p_max)
|
||||
|
||||
def test_p_max_range(self):
|
||||
for m_max in range(1, 55+1):
|
||||
p_max = _compute_p_max(m_max)
|
||||
assert_(p_max*(p_max - 1) <= m_max + 1)
|
||||
p_too_big = p_max + 1
|
||||
assert_(p_too_big*(p_too_big - 1) > m_max + 1)
|
||||
|
||||
def test_onenormest_matrix_power(self):
|
||||
np.random.seed(1234)
|
||||
n = 40
|
||||
nsamples = 10
|
||||
for i in range(nsamples):
|
||||
A = scipy.linalg.inv(np.random.randn(n, n))
|
||||
for p in range(4):
|
||||
if not p:
|
||||
M = np.identity(n)
|
||||
else:
|
||||
M = np.dot(M, A)
|
||||
estimated = _onenormest_matrix_power(A, p)
|
||||
exact = np.linalg.norm(M, 1)
|
||||
assert_(less_than_or_close(estimated, exact))
|
||||
assert_(less_than_or_close(exact, 3*estimated))
|
||||
|
||||
def test_expm_multiply(self):
|
||||
np.random.seed(1234)
|
||||
n = 40
|
||||
k = 3
|
||||
nsamples = 10
|
||||
for i in range(nsamples):
|
||||
A = scipy.linalg.inv(np.random.randn(n, n))
|
||||
B = np.random.randn(n, k)
|
||||
observed = expm_multiply(A, B)
|
||||
expected = np.dot(scipy.linalg.expm(A), B)
|
||||
assert_allclose(observed, expected)
|
||||
|
||||
def test_matrix_vector_multiply(self):
|
||||
np.random.seed(1234)
|
||||
n = 40
|
||||
nsamples = 10
|
||||
for i in range(nsamples):
|
||||
A = scipy.linalg.inv(np.random.randn(n, n))
|
||||
v = np.random.randn(n)
|
||||
observed = expm_multiply(A, v)
|
||||
expected = np.dot(scipy.linalg.expm(A), v)
|
||||
assert_allclose(observed, expected)
|
||||
|
||||
def test_scaled_expm_multiply(self):
|
||||
np.random.seed(1234)
|
||||
n = 40
|
||||
k = 3
|
||||
nsamples = 10
|
||||
for i in range(nsamples):
|
||||
for t in (0.2, 1.0, 1.5):
|
||||
with np.errstate(invalid='ignore'):
|
||||
A = scipy.linalg.inv(np.random.randn(n, n))
|
||||
B = np.random.randn(n, k)
|
||||
observed = _expm_multiply_simple(A, B, t=t)
|
||||
expected = np.dot(scipy.linalg.expm(t*A), B)
|
||||
assert_allclose(observed, expected)
|
||||
|
||||
def test_scaled_expm_multiply_single_timepoint(self):
|
||||
np.random.seed(1234)
|
||||
t = 0.1
|
||||
n = 5
|
||||
k = 2
|
||||
A = np.random.randn(n, n)
|
||||
B = np.random.randn(n, k)
|
||||
observed = _expm_multiply_simple(A, B, t=t)
|
||||
expected = scipy.linalg.expm(t*A).dot(B)
|
||||
assert_allclose(observed, expected)
|
||||
|
||||
def test_sparse_expm_multiply(self):
|
||||
np.random.seed(1234)
|
||||
n = 40
|
||||
k = 3
|
||||
nsamples = 10
|
||||
for i in range(nsamples):
|
||||
A = scipy.sparse.rand(n, n, density=0.05)
|
||||
B = np.random.randn(n, k)
|
||||
observed = expm_multiply(A, B)
|
||||
with suppress_warnings() as sup:
|
||||
sup.filter(SparseEfficiencyWarning,
|
||||
"splu requires CSC matrix format")
|
||||
sup.filter(SparseEfficiencyWarning,
|
||||
"spsolve is more efficient when sparse b is in the CSC matrix format")
|
||||
expected = scipy.linalg.expm(A).dot(B)
|
||||
assert_allclose(observed, expected)
|
||||
|
||||
def test_complex(self):
|
||||
A = np.array([
|
||||
[1j, 1j],
|
||||
[0, 1j]], dtype=complex)
|
||||
B = np.array([1j, 1j])
|
||||
observed = expm_multiply(A, B)
|
||||
expected = np.array([
|
||||
1j * np.exp(1j) + 1j * (1j*np.cos(1) - np.sin(1)),
|
||||
1j * np.exp(1j)], dtype=complex)
|
||||
assert_allclose(observed, expected)
|
||||
|
||||
|
||||
class TestExpmActionInterval(object):
|
||||
|
||||
def test_sparse_expm_multiply_interval(self):
|
||||
np.random.seed(1234)
|
||||
start = 0.1
|
||||
stop = 3.2
|
||||
n = 40
|
||||
k = 3
|
||||
endpoint = True
|
||||
for num in (14, 13, 2):
|
||||
A = scipy.sparse.rand(n, n, density=0.05)
|
||||
B = np.random.randn(n, k)
|
||||
v = np.random.randn(n)
|
||||
for target in (B, v):
|
||||
X = expm_multiply(A, target,
|
||||
start=start, stop=stop, num=num, endpoint=endpoint)
|
||||
samples = np.linspace(start=start, stop=stop,
|
||||
num=num, endpoint=endpoint)
|
||||
with suppress_warnings() as sup:
|
||||
sup.filter(SparseEfficiencyWarning,
|
||||
"splu requires CSC matrix format")
|
||||
sup.filter(SparseEfficiencyWarning,
|
||||
"spsolve is more efficient when sparse b is in the CSC matrix format")
|
||||
for solution, t in zip(X, samples):
|
||||
assert_allclose(solution,
|
||||
scipy.linalg.expm(t*A).dot(target))
|
||||
|
||||
def test_expm_multiply_interval_vector(self):
|
||||
np.random.seed(1234)
|
||||
start = 0.1
|
||||
stop = 3.2
|
||||
endpoint = True
|
||||
for num in (14, 13, 2):
|
||||
for n in (1, 2, 5, 20, 40):
|
||||
A = scipy.linalg.inv(np.random.randn(n, n))
|
||||
v = np.random.randn(n)
|
||||
X = expm_multiply(A, v,
|
||||
start=start, stop=stop, num=num, endpoint=endpoint)
|
||||
samples = np.linspace(start=start, stop=stop,
|
||||
num=num, endpoint=endpoint)
|
||||
for solution, t in zip(X, samples):
|
||||
assert_allclose(solution, scipy.linalg.expm(t*A).dot(v))
|
||||
|
||||
def test_expm_multiply_interval_matrix(self):
|
||||
np.random.seed(1234)
|
||||
start = 0.1
|
||||
stop = 3.2
|
||||
endpoint = True
|
||||
for num in (14, 13, 2):
|
||||
for n in (1, 2, 5, 20, 40):
|
||||
for k in (1, 2):
|
||||
A = scipy.linalg.inv(np.random.randn(n, n))
|
||||
B = np.random.randn(n, k)
|
||||
X = expm_multiply(A, B,
|
||||
start=start, stop=stop, num=num, endpoint=endpoint)
|
||||
samples = np.linspace(start=start, stop=stop,
|
||||
num=num, endpoint=endpoint)
|
||||
for solution, t in zip(X, samples):
|
||||
assert_allclose(solution, scipy.linalg.expm(t*A).dot(B))
|
||||
|
||||
def test_sparse_expm_multiply_interval_dtypes(self):
|
||||
# Test A & B int
|
||||
A = scipy.sparse.diags(np.arange(5),format='csr', dtype=int)
|
||||
B = np.ones(5, dtype=int)
|
||||
Aexpm = scipy.sparse.diags(np.exp(np.arange(5)),format='csr')
|
||||
assert_allclose(expm_multiply(A,B,0,1)[-1], Aexpm.dot(B))
|
||||
|
||||
# Test A complex, B int
|
||||
A = scipy.sparse.diags(-1j*np.arange(5),format='csr', dtype=complex)
|
||||
B = np.ones(5, dtype=int)
|
||||
Aexpm = scipy.sparse.diags(np.exp(-1j*np.arange(5)),format='csr')
|
||||
assert_allclose(expm_multiply(A,B,0,1)[-1], Aexpm.dot(B))
|
||||
|
||||
# Test A int, B complex
|
||||
A = scipy.sparse.diags(np.arange(5),format='csr', dtype=int)
|
||||
B = 1j*np.ones(5, dtype=complex)
|
||||
Aexpm = scipy.sparse.diags(np.exp(np.arange(5)),format='csr')
|
||||
assert_allclose(expm_multiply(A,B,0,1)[-1], Aexpm.dot(B))
|
||||
|
||||
def test_expm_multiply_interval_status_0(self):
|
||||
self._help_test_specific_expm_interval_status(0)
|
||||
|
||||
def test_expm_multiply_interval_status_1(self):
|
||||
self._help_test_specific_expm_interval_status(1)
|
||||
|
||||
def test_expm_multiply_interval_status_2(self):
|
||||
self._help_test_specific_expm_interval_status(2)
|
||||
|
||||
def _help_test_specific_expm_interval_status(self, target_status):
|
||||
np.random.seed(1234)
|
||||
start = 0.1
|
||||
stop = 3.2
|
||||
num = 13
|
||||
endpoint = True
|
||||
n = 5
|
||||
k = 2
|
||||
nrepeats = 10
|
||||
nsuccesses = 0
|
||||
for num in [14, 13, 2] * nrepeats:
|
||||
A = np.random.randn(n, n)
|
||||
B = np.random.randn(n, k)
|
||||
status = _expm_multiply_interval(A, B,
|
||||
start=start, stop=stop, num=num, endpoint=endpoint,
|
||||
status_only=True)
|
||||
if status == target_status:
|
||||
X, status = _expm_multiply_interval(A, B,
|
||||
start=start, stop=stop, num=num, endpoint=endpoint,
|
||||
status_only=False)
|
||||
assert_equal(X.shape, (num, n, k))
|
||||
samples = np.linspace(start=start, stop=stop,
|
||||
num=num, endpoint=endpoint)
|
||||
for solution, t in zip(X, samples):
|
||||
assert_allclose(solution, scipy.linalg.expm(t*A).dot(B))
|
||||
nsuccesses += 1
|
||||
if not nsuccesses:
|
||||
msg = 'failed to find a status-' + str(target_status) + ' interval'
|
||||
raise Exception(msg)
|
||||
|
||||
@@ -0,0 +1,367 @@
|
||||
"""Test functions for the sparse.linalg.interface module
|
||||
"""
|
||||
|
||||
from __future__ import division, print_function, absolute_import
|
||||
|
||||
from functools import partial
|
||||
from itertools import product
|
||||
import operator
|
||||
import pytest
|
||||
from pytest import raises as assert_raises, warns
|
||||
from numpy.testing import assert_, assert_equal
|
||||
|
||||
import numpy as np
|
||||
import scipy.sparse as sparse
|
||||
|
||||
from scipy.sparse.linalg import interface
|
||||
|
||||
|
||||
# Only test matmul operator (A @ B) when available (Python 3.5+)
|
||||
TEST_MATMUL = hasattr(operator, 'matmul')
|
||||
|
||||
|
||||
class TestLinearOperator(object):
|
||||
def setup_method(self):
|
||||
self.A = np.array([[1,2,3],
|
||||
[4,5,6]])
|
||||
self.B = np.array([[1,2],
|
||||
[3,4],
|
||||
[5,6]])
|
||||
self.C = np.array([[1,2],
|
||||
[3,4]])
|
||||
|
||||
def test_matvec(self):
|
||||
def get_matvecs(A):
|
||||
return [{
|
||||
'shape': A.shape,
|
||||
'matvec': lambda x: np.dot(A, x).reshape(A.shape[0]),
|
||||
'rmatvec': lambda x: np.dot(A.T.conj(),
|
||||
x).reshape(A.shape[1])
|
||||
},
|
||||
{
|
||||
'shape': A.shape,
|
||||
'matvec': lambda x: np.dot(A, x),
|
||||
'rmatvec': lambda x: np.dot(A.T.conj(), x),
|
||||
'matmat': lambda x: np.dot(A, x)
|
||||
}]
|
||||
|
||||
for matvecs in get_matvecs(self.A):
|
||||
A = interface.LinearOperator(**matvecs)
|
||||
|
||||
assert_(A.args == ())
|
||||
|
||||
assert_equal(A.matvec(np.array([1,2,3])), [14,32])
|
||||
assert_equal(A.matvec(np.array([[1],[2],[3]])), [[14],[32]])
|
||||
assert_equal(A * np.array([1,2,3]), [14,32])
|
||||
assert_equal(A * np.array([[1],[2],[3]]), [[14],[32]])
|
||||
assert_equal(A.dot(np.array([1,2,3])), [14,32])
|
||||
assert_equal(A.dot(np.array([[1],[2],[3]])), [[14],[32]])
|
||||
|
||||
assert_equal(A.matvec(np.matrix([[1],[2],[3]])), [[14],[32]])
|
||||
assert_equal(A * np.matrix([[1],[2],[3]]), [[14],[32]])
|
||||
assert_equal(A.dot(np.matrix([[1],[2],[3]])), [[14],[32]])
|
||||
|
||||
assert_equal((2*A)*[1,1,1], [12,30])
|
||||
assert_equal((2*A).rmatvec([1,1]), [10, 14, 18])
|
||||
assert_equal((2*A).H.matvec([1,1]), [10, 14, 18])
|
||||
assert_equal((2*A)*[[1],[1],[1]], [[12],[30]])
|
||||
assert_equal((2*A).matmat([[1],[1],[1]]), [[12],[30]])
|
||||
assert_equal((A*2)*[1,1,1], [12,30])
|
||||
assert_equal((A*2)*[[1],[1],[1]], [[12],[30]])
|
||||
assert_equal((2j*A)*[1,1,1], [12j,30j])
|
||||
assert_equal((A+A)*[1,1,1], [12, 30])
|
||||
assert_equal((A+A).rmatvec([1,1]), [10, 14, 18])
|
||||
assert_equal((A+A).H.matvec([1,1]), [10, 14, 18])
|
||||
assert_equal((A+A)*[[1],[1],[1]], [[12], [30]])
|
||||
assert_equal((A+A).matmat([[1],[1],[1]]), [[12], [30]])
|
||||
assert_equal((-A)*[1,1,1], [-6,-15])
|
||||
assert_equal((-A)*[[1],[1],[1]], [[-6],[-15]])
|
||||
assert_equal((A-A)*[1,1,1], [0,0])
|
||||
assert_equal((A-A)*[[1],[1],[1]], [[0],[0]])
|
||||
|
||||
z = A+A
|
||||
assert_(len(z.args) == 2 and z.args[0] is A and z.args[1] is A)
|
||||
z = 2*A
|
||||
assert_(len(z.args) == 2 and z.args[0] is A and z.args[1] == 2)
|
||||
|
||||
assert_(isinstance(A.matvec([1, 2, 3]), np.ndarray))
|
||||
assert_(isinstance(A.matvec(np.array([[1],[2],[3]])), np.ndarray))
|
||||
assert_(isinstance(A * np.array([1,2,3]), np.ndarray))
|
||||
assert_(isinstance(A * np.array([[1],[2],[3]]), np.ndarray))
|
||||
assert_(isinstance(A.dot(np.array([1,2,3])), np.ndarray))
|
||||
assert_(isinstance(A.dot(np.array([[1],[2],[3]])), np.ndarray))
|
||||
|
||||
assert_(isinstance(A.matvec(np.matrix([[1],[2],[3]])), np.ndarray))
|
||||
assert_(isinstance(A * np.matrix([[1],[2],[3]]), np.ndarray))
|
||||
assert_(isinstance(A.dot(np.matrix([[1],[2],[3]])), np.ndarray))
|
||||
|
||||
assert_(isinstance(2*A, interface._ScaledLinearOperator))
|
||||
assert_(isinstance(2j*A, interface._ScaledLinearOperator))
|
||||
assert_(isinstance(A+A, interface._SumLinearOperator))
|
||||
assert_(isinstance(-A, interface._ScaledLinearOperator))
|
||||
assert_(isinstance(A-A, interface._SumLinearOperator))
|
||||
|
||||
assert_((2j*A).dtype == np.complex_)
|
||||
|
||||
assert_raises(ValueError, A.matvec, np.array([1,2]))
|
||||
assert_raises(ValueError, A.matvec, np.array([1,2,3,4]))
|
||||
assert_raises(ValueError, A.matvec, np.array([[1],[2]]))
|
||||
assert_raises(ValueError, A.matvec, np.array([[1],[2],[3],[4]]))
|
||||
|
||||
assert_raises(ValueError, lambda: A*A)
|
||||
assert_raises(ValueError, lambda: A**2)
|
||||
|
||||
for matvecsA, matvecsB in product(get_matvecs(self.A),
|
||||
get_matvecs(self.B)):
|
||||
A = interface.LinearOperator(**matvecsA)
|
||||
B = interface.LinearOperator(**matvecsB)
|
||||
|
||||
assert_equal((A*B)*[1,1], [50,113])
|
||||
assert_equal((A*B)*[[1],[1]], [[50],[113]])
|
||||
assert_equal((A*B).matmat([[1],[1]]), [[50],[113]])
|
||||
|
||||
assert_equal((A*B).rmatvec([1,1]), [71,92])
|
||||
assert_equal((A*B).H.matvec([1,1]), [71,92])
|
||||
|
||||
assert_(isinstance(A*B, interface._ProductLinearOperator))
|
||||
|
||||
assert_raises(ValueError, lambda: A+B)
|
||||
assert_raises(ValueError, lambda: A**2)
|
||||
|
||||
z = A*B
|
||||
assert_(len(z.args) == 2 and z.args[0] is A and z.args[1] is B)
|
||||
|
||||
for matvecsC in get_matvecs(self.C):
|
||||
C = interface.LinearOperator(**matvecsC)
|
||||
|
||||
assert_equal((C**2)*[1,1], [17,37])
|
||||
assert_equal((C**2).rmatvec([1,1]), [22,32])
|
||||
assert_equal((C**2).H.matvec([1,1]), [22,32])
|
||||
assert_equal((C**2).matmat([[1],[1]]), [[17],[37]])
|
||||
|
||||
assert_(isinstance(C**2, interface._PowerLinearOperator))
|
||||
|
||||
def test_matmul(self):
|
||||
if not TEST_MATMUL:
|
||||
pytest.skip("matmul is only tested in Python 3.5+")
|
||||
|
||||
D = {'shape': self.A.shape,
|
||||
'matvec': lambda x: np.dot(self.A, x).reshape(self.A.shape[0]),
|
||||
'rmatvec': lambda x: np.dot(self.A.T.conj(),
|
||||
x).reshape(self.A.shape[1]),
|
||||
'matmat': lambda x: np.dot(self.A, x)}
|
||||
A = interface.LinearOperator(**D)
|
||||
B = np.array([[1, 2, 3],
|
||||
[4, 5, 6],
|
||||
[7, 8, 9]])
|
||||
b = B[0]
|
||||
|
||||
assert_equal(operator.matmul(A, b), A * b)
|
||||
assert_equal(operator.matmul(A, B), A * B)
|
||||
assert_raises(ValueError, operator.matmul, A, 2)
|
||||
assert_raises(ValueError, operator.matmul, 2, A)
|
||||
|
||||
|
||||
class TestAsLinearOperator(object):
|
||||
def setup_method(self):
|
||||
self.cases = []
|
||||
|
||||
def make_cases(dtype):
|
||||
self.cases.append(np.matrix([[1,2,3],[4,5,6]], dtype=dtype))
|
||||
self.cases.append(np.array([[1,2,3],[4,5,6]], dtype=dtype))
|
||||
self.cases.append(sparse.csr_matrix([[1,2,3],[4,5,6]], dtype=dtype))
|
||||
|
||||
# Test default implementations of _adjoint and _rmatvec, which
|
||||
# refer to each other.
|
||||
def mv(x, dtype):
|
||||
y = np.array([1 * x[0] + 2 * x[1] + 3 * x[2],
|
||||
4 * x[0] + 5 * x[1] + 6 * x[2]], dtype=dtype)
|
||||
if len(x.shape) == 2:
|
||||
y = y.reshape(-1, 1)
|
||||
return y
|
||||
|
||||
def rmv(x, dtype):
|
||||
return np.array([1 * x[0] + 4 * x[1],
|
||||
2 * x[0] + 5 * x[1],
|
||||
3 * x[0] + 6 * x[1]], dtype=dtype)
|
||||
|
||||
class BaseMatlike(interface.LinearOperator):
|
||||
def __init__(self, dtype):
|
||||
self.dtype = np.dtype(dtype)
|
||||
self.shape = (2,3)
|
||||
|
||||
def _matvec(self, x):
|
||||
return mv(x, self.dtype)
|
||||
|
||||
class HasRmatvec(BaseMatlike):
|
||||
def _rmatvec(self,x):
|
||||
return rmv(x, self.dtype)
|
||||
|
||||
class HasAdjoint(BaseMatlike):
|
||||
def _adjoint(self):
|
||||
shape = self.shape[1], self.shape[0]
|
||||
matvec = partial(rmv, dtype=self.dtype)
|
||||
rmatvec = partial(mv, dtype=self.dtype)
|
||||
return interface.LinearOperator(matvec=matvec,
|
||||
rmatvec=rmatvec,
|
||||
dtype=self.dtype,
|
||||
shape=shape)
|
||||
|
||||
self.cases.append(HasRmatvec(dtype))
|
||||
self.cases.append(HasAdjoint(dtype))
|
||||
|
||||
make_cases('int32')
|
||||
make_cases('float32')
|
||||
make_cases('float64')
|
||||
|
||||
def test_basic(self):
|
||||
|
||||
for M in self.cases:
|
||||
A = interface.aslinearoperator(M)
|
||||
M,N = A.shape
|
||||
|
||||
assert_equal(A.matvec(np.array([1,2,3])), [14,32])
|
||||
assert_equal(A.matvec(np.array([[1],[2],[3]])), [[14],[32]])
|
||||
|
||||
assert_equal(A * np.array([1,2,3]), [14,32])
|
||||
assert_equal(A * np.array([[1],[2],[3]]), [[14],[32]])
|
||||
|
||||
assert_equal(A.rmatvec(np.array([1,2])), [9,12,15])
|
||||
assert_equal(A.rmatvec(np.array([[1],[2]])), [[9],[12],[15]])
|
||||
assert_equal(A.H.matvec(np.array([1,2])), [9,12,15])
|
||||
assert_equal(A.H.matvec(np.array([[1],[2]])), [[9],[12],[15]])
|
||||
|
||||
assert_equal(
|
||||
A.matmat(np.array([[1,4],[2,5],[3,6]])),
|
||||
[[14,32],[32,77]])
|
||||
|
||||
assert_equal(A * np.array([[1,4],[2,5],[3,6]]), [[14,32],[32,77]])
|
||||
|
||||
if hasattr(M,'dtype'):
|
||||
assert_equal(A.dtype, M.dtype)
|
||||
|
||||
def test_dot(self):
|
||||
|
||||
for M in self.cases:
|
||||
A = interface.aslinearoperator(M)
|
||||
M,N = A.shape
|
||||
|
||||
assert_equal(A.dot(np.array([1,2,3])), [14,32])
|
||||
assert_equal(A.dot(np.array([[1],[2],[3]])), [[14],[32]])
|
||||
|
||||
assert_equal(
|
||||
A.dot(np.array([[1,4],[2,5],[3,6]])),
|
||||
[[14,32],[32,77]])
|
||||
|
||||
|
||||
def test_repr():
|
||||
A = interface.LinearOperator(shape=(1, 1), matvec=lambda x: 1)
|
||||
repr_A = repr(A)
|
||||
assert_('unspecified dtype' not in repr_A, repr_A)
|
||||
|
||||
|
||||
def test_identity():
|
||||
ident = interface.IdentityOperator((3, 3))
|
||||
assert_equal(ident * [1, 2, 3], [1, 2, 3])
|
||||
assert_equal(ident.dot(np.arange(9).reshape(3, 3)).ravel(), np.arange(9))
|
||||
|
||||
assert_raises(ValueError, ident.matvec, [1, 2, 3, 4])
|
||||
|
||||
|
||||
def test_attributes():
|
||||
A = interface.aslinearoperator(np.arange(16).reshape(4, 4))
|
||||
|
||||
def always_four_ones(x):
|
||||
x = np.asarray(x)
|
||||
assert_(x.shape == (3,) or x.shape == (3, 1))
|
||||
return np.ones(4)
|
||||
|
||||
B = interface.LinearOperator(shape=(4, 3), matvec=always_four_ones)
|
||||
|
||||
for op in [A, B, A * B, A.H, A + A, B + B, A ** 4]:
|
||||
assert_(hasattr(op, "dtype"))
|
||||
assert_(hasattr(op, "shape"))
|
||||
assert_(hasattr(op, "_matvec"))
|
||||
|
||||
def matvec(x):
|
||||
""" Needed for test_pickle as local functions are not pickleable """
|
||||
return np.zeros(3)
|
||||
|
||||
def test_pickle():
|
||||
import pickle
|
||||
|
||||
for protocol in range(pickle.HIGHEST_PROTOCOL + 1):
|
||||
A = interface.LinearOperator((3, 3), matvec)
|
||||
s = pickle.dumps(A, protocol=protocol)
|
||||
B = pickle.loads(s)
|
||||
|
||||
for k in A.__dict__:
|
||||
assert_equal(getattr(A, k), getattr(B, k))
|
||||
|
||||
def test_inheritance():
|
||||
class Empty(interface.LinearOperator):
|
||||
pass
|
||||
|
||||
with warns(RuntimeWarning, match="should implement at least"):
|
||||
assert_raises(TypeError, Empty)
|
||||
|
||||
class Identity(interface.LinearOperator):
|
||||
def __init__(self, n):
|
||||
super(Identity, self).__init__(dtype=None, shape=(n, n))
|
||||
|
||||
def _matvec(self, x):
|
||||
return x
|
||||
|
||||
id3 = Identity(3)
|
||||
assert_equal(id3.matvec([1, 2, 3]), [1, 2, 3])
|
||||
assert_raises(NotImplementedError, id3.rmatvec, [4, 5, 6])
|
||||
|
||||
class MatmatOnly(interface.LinearOperator):
|
||||
def __init__(self, A):
|
||||
super(MatmatOnly, self).__init__(A.dtype, A.shape)
|
||||
self.A = A
|
||||
|
||||
def _matmat(self, x):
|
||||
return self.A.dot(x)
|
||||
|
||||
mm = MatmatOnly(np.random.randn(5, 3))
|
||||
assert_equal(mm.matvec(np.random.randn(3)).shape, (5,))
|
||||
|
||||
def test_dtypes_of_operator_sum():
|
||||
# gh-6078
|
||||
|
||||
mat_complex = np.random.rand(2,2) + 1j * np.random.rand(2,2)
|
||||
mat_real = np.random.rand(2,2)
|
||||
|
||||
complex_operator = interface.aslinearoperator(mat_complex)
|
||||
real_operator = interface.aslinearoperator(mat_real)
|
||||
|
||||
sum_complex = complex_operator + complex_operator
|
||||
sum_real = real_operator + real_operator
|
||||
|
||||
assert_equal(sum_real.dtype, np.float64)
|
||||
assert_equal(sum_complex.dtype, np.complex128)
|
||||
|
||||
def test_no_double_init():
|
||||
call_count = [0]
|
||||
|
||||
def matvec(v):
|
||||
call_count[0] += 1
|
||||
return v
|
||||
|
||||
# It should call matvec exactly once (in order to determine the
|
||||
# operator dtype)
|
||||
A = interface.LinearOperator((2, 2), matvec=matvec)
|
||||
assert_equal(call_count[0], 1)
|
||||
|
||||
def test_adjoint_conjugate():
|
||||
X = np.array([[1j]])
|
||||
A = interface.aslinearoperator(X)
|
||||
|
||||
B = 1j * A
|
||||
Y = 1j * X
|
||||
|
||||
v = np.array([1])
|
||||
|
||||
assert_equal(B.dot(v), Y.dot(v))
|
||||
assert_equal(B.H.dot(v), Y.T.conj().dot(v))
|
||||
@@ -0,0 +1,556 @@
|
||||
#
|
||||
# Created by: Pearu Peterson, March 2002
|
||||
#
|
||||
""" Test functions for scipy.linalg.matfuncs module
|
||||
|
||||
"""
|
||||
from __future__ import division, print_function, absolute_import
|
||||
|
||||
import math
|
||||
|
||||
import numpy as np
|
||||
from numpy import array, eye, exp, random
|
||||
from numpy.linalg import matrix_power
|
||||
from numpy.testing import (
|
||||
assert_allclose, assert_, assert_array_almost_equal, assert_equal,
|
||||
assert_array_almost_equal_nulp)
|
||||
from scipy._lib._numpy_compat import suppress_warnings
|
||||
|
||||
from scipy.sparse import csc_matrix, SparseEfficiencyWarning
|
||||
from scipy.sparse.construct import eye as speye
|
||||
from scipy.sparse.linalg.matfuncs import (expm, _expm,
|
||||
ProductOperator, MatrixPowerOperator,
|
||||
_onenorm_matrix_power_nnm)
|
||||
from scipy.linalg import logm
|
||||
from scipy.special import factorial, binom
|
||||
import scipy.sparse
|
||||
import scipy.sparse.linalg
|
||||
|
||||
|
||||
def _burkardt_13_power(n, p):
|
||||
"""
|
||||
A helper function for testing matrix functions.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
n : integer greater than 1
|
||||
Order of the square matrix to be returned.
|
||||
p : non-negative integer
|
||||
Power of the matrix.
|
||||
|
||||
Returns
|
||||
-------
|
||||
out : ndarray representing a square matrix
|
||||
A Forsythe matrix of order n, raised to the power p.
|
||||
|
||||
"""
|
||||
# Input validation.
|
||||
if n != int(n) or n < 2:
|
||||
raise ValueError('n must be an integer greater than 1')
|
||||
n = int(n)
|
||||
if p != int(p) or p < 0:
|
||||
raise ValueError('p must be a non-negative integer')
|
||||
p = int(p)
|
||||
|
||||
# Construct the matrix explicitly.
|
||||
a, b = divmod(p, n)
|
||||
large = np.power(10.0, -n*a)
|
||||
small = large * np.power(10.0, -n)
|
||||
return np.diag([large]*(n-b), b) + np.diag([small]*b, b-n)
|
||||
|
||||
|
||||
def test_onenorm_matrix_power_nnm():
|
||||
np.random.seed(1234)
|
||||
for n in range(1, 5):
|
||||
for p in range(5):
|
||||
M = np.random.random((n, n))
|
||||
Mp = np.linalg.matrix_power(M, p)
|
||||
observed = _onenorm_matrix_power_nnm(M, p)
|
||||
expected = np.linalg.norm(Mp, 1)
|
||||
assert_allclose(observed, expected)
|
||||
|
||||
|
||||
class TestExpM(object):
|
||||
def test_zero_ndarray(self):
|
||||
a = array([[0.,0],[0,0]])
|
||||
assert_array_almost_equal(expm(a),[[1,0],[0,1]])
|
||||
|
||||
def test_zero_sparse(self):
|
||||
a = csc_matrix([[0.,0],[0,0]])
|
||||
assert_array_almost_equal(expm(a).toarray(),[[1,0],[0,1]])
|
||||
|
||||
def test_zero_matrix(self):
|
||||
a = np.matrix([[0.,0],[0,0]])
|
||||
assert_array_almost_equal(expm(a),[[1,0],[0,1]])
|
||||
|
||||
def test_misc_types(self):
|
||||
A = expm(np.array([[1]]))
|
||||
assert_allclose(expm(((1,),)), A)
|
||||
assert_allclose(expm([[1]]), A)
|
||||
assert_allclose(expm(np.matrix([[1]])), A)
|
||||
assert_allclose(expm(np.array([[1]])), A)
|
||||
assert_allclose(expm(csc_matrix([[1]])).A, A)
|
||||
B = expm(np.array([[1j]]))
|
||||
assert_allclose(expm(((1j,),)), B)
|
||||
assert_allclose(expm([[1j]]), B)
|
||||
assert_allclose(expm(np.matrix([[1j]])), B)
|
||||
assert_allclose(expm(csc_matrix([[1j]])).A, B)
|
||||
|
||||
def test_bidiagonal_sparse(self):
|
||||
A = csc_matrix([
|
||||
[1, 3, 0],
|
||||
[0, 1, 5],
|
||||
[0, 0, 2]], dtype=float)
|
||||
e1 = math.exp(1)
|
||||
e2 = math.exp(2)
|
||||
expected = np.array([
|
||||
[e1, 3*e1, 15*(e2 - 2*e1)],
|
||||
[0, e1, 5*(e2 - e1)],
|
||||
[0, 0, e2]], dtype=float)
|
||||
observed = expm(A).toarray()
|
||||
assert_array_almost_equal(observed, expected)
|
||||
|
||||
def test_padecases_dtype_float(self):
|
||||
for dtype in [np.float32, np.float64]:
|
||||
for scale in [1e-2, 1e-1, 5e-1, 1, 10]:
|
||||
A = scale * eye(3, dtype=dtype)
|
||||
observed = expm(A)
|
||||
expected = exp(scale) * eye(3, dtype=dtype)
|
||||
assert_array_almost_equal_nulp(observed, expected, nulp=100)
|
||||
|
||||
def test_padecases_dtype_complex(self):
|
||||
for dtype in [np.complex64, np.complex128]:
|
||||
for scale in [1e-2, 1e-1, 5e-1, 1, 10]:
|
||||
A = scale * eye(3, dtype=dtype)
|
||||
observed = expm(A)
|
||||
expected = exp(scale) * eye(3, dtype=dtype)
|
||||
assert_array_almost_equal_nulp(observed, expected, nulp=100)
|
||||
|
||||
def test_padecases_dtype_sparse_float(self):
|
||||
# float32 and complex64 lead to errors in spsolve/UMFpack
|
||||
dtype = np.float64
|
||||
for scale in [1e-2, 1e-1, 5e-1, 1, 10]:
|
||||
a = scale * speye(3, 3, dtype=dtype, format='csc')
|
||||
e = exp(scale) * eye(3, dtype=dtype)
|
||||
with suppress_warnings() as sup:
|
||||
sup.filter(SparseEfficiencyWarning,
|
||||
"Changing the sparsity structure of a csc_matrix is expensive.")
|
||||
exact_onenorm = _expm(a, use_exact_onenorm=True).toarray()
|
||||
inexact_onenorm = _expm(a, use_exact_onenorm=False).toarray()
|
||||
assert_array_almost_equal_nulp(exact_onenorm, e, nulp=100)
|
||||
assert_array_almost_equal_nulp(inexact_onenorm, e, nulp=100)
|
||||
|
||||
def test_padecases_dtype_sparse_complex(self):
|
||||
# float32 and complex64 lead to errors in spsolve/UMFpack
|
||||
dtype = np.complex128
|
||||
for scale in [1e-2, 1e-1, 5e-1, 1, 10]:
|
||||
a = scale * speye(3, 3, dtype=dtype, format='csc')
|
||||
e = exp(scale) * eye(3, dtype=dtype)
|
||||
with suppress_warnings() as sup:
|
||||
sup.filter(SparseEfficiencyWarning,
|
||||
"Changing the sparsity structure of a csc_matrix is expensive.")
|
||||
assert_array_almost_equal_nulp(expm(a).toarray(), e, nulp=100)
|
||||
|
||||
def test_logm_consistency(self):
|
||||
random.seed(1234)
|
||||
for dtype in [np.float64, np.complex128]:
|
||||
for n in range(1, 10):
|
||||
for scale in [1e-4, 1e-3, 1e-2, 1e-1, 1, 1e1, 1e2]:
|
||||
# make logm(A) be of a given scale
|
||||
A = (eye(n) + random.rand(n, n) * scale).astype(dtype)
|
||||
if np.iscomplexobj(A):
|
||||
A = A + 1j * random.rand(n, n) * scale
|
||||
assert_array_almost_equal(expm(logm(A)), A)
|
||||
|
||||
def test_integer_matrix(self):
|
||||
Q = np.array([
|
||||
[-3, 1, 1, 1],
|
||||
[1, -3, 1, 1],
|
||||
[1, 1, -3, 1],
|
||||
[1, 1, 1, -3]])
|
||||
assert_allclose(expm(Q), expm(1.0 * Q))
|
||||
|
||||
def test_integer_matrix_2(self):
|
||||
# Check for integer overflows
|
||||
Q = np.array([[-500, 500, 0, 0],
|
||||
[0, -550, 360, 190],
|
||||
[0, 630, -630, 0],
|
||||
[0, 0, 0, 0]], dtype=np.int16)
|
||||
assert_allclose(expm(Q), expm(1.0 * Q))
|
||||
|
||||
Q = csc_matrix(Q)
|
||||
assert_allclose(expm(Q).A, expm(1.0 * Q).A)
|
||||
|
||||
def test_triangularity_perturbation(self):
|
||||
# Experiment (1) of
|
||||
# Awad H. Al-Mohy and Nicholas J. Higham (2012)
|
||||
# Improved Inverse Scaling and Squaring Algorithms
|
||||
# for the Matrix Logarithm.
|
||||
A = np.array([
|
||||
[3.2346e-1, 3e4, 3e4, 3e4],
|
||||
[0, 3.0089e-1, 3e4, 3e4],
|
||||
[0, 0, 3.221e-1, 3e4],
|
||||
[0, 0, 0, 3.0744e-1]],
|
||||
dtype=float)
|
||||
A_logm = np.array([
|
||||
[-1.12867982029050462e+00, 9.61418377142025565e+04,
|
||||
-4.52485573953179264e+09, 2.92496941103871812e+14],
|
||||
[0.00000000000000000e+00, -1.20101052953082288e+00,
|
||||
9.63469687211303099e+04, -4.68104828911105442e+09],
|
||||
[0.00000000000000000e+00, 0.00000000000000000e+00,
|
||||
-1.13289322264498393e+00, 9.53249183094775653e+04],
|
||||
[0.00000000000000000e+00, 0.00000000000000000e+00,
|
||||
0.00000000000000000e+00, -1.17947533272554850e+00]],
|
||||
dtype=float)
|
||||
assert_allclose(expm(A_logm), A, rtol=1e-4)
|
||||
|
||||
# Perturb the upper triangular matrix by tiny amounts,
|
||||
# so that it becomes technically not upper triangular.
|
||||
random.seed(1234)
|
||||
tiny = 1e-17
|
||||
A_logm_perturbed = A_logm.copy()
|
||||
A_logm_perturbed[1, 0] = tiny
|
||||
with suppress_warnings() as sup:
|
||||
sup.filter(RuntimeWarning, "Ill-conditioned.*")
|
||||
A_expm_logm_perturbed = expm(A_logm_perturbed)
|
||||
rtol = 1e-4
|
||||
atol = 100 * tiny
|
||||
assert_(not np.allclose(A_expm_logm_perturbed, A, rtol=rtol, atol=atol))
|
||||
|
||||
def test_burkardt_1(self):
|
||||
# This matrix is diagonal.
|
||||
# The calculation of the matrix exponential is simple.
|
||||
#
|
||||
# This is the first of a series of matrix exponential tests
|
||||
# collected by John Burkardt from the following sources.
|
||||
#
|
||||
# Alan Laub,
|
||||
# Review of "Linear System Theory" by Joao Hespanha,
|
||||
# SIAM Review,
|
||||
# Volume 52, Number 4, December 2010, pages 779--781.
|
||||
#
|
||||
# Cleve Moler and Charles Van Loan,
|
||||
# Nineteen Dubious Ways to Compute the Exponential of a Matrix,
|
||||
# Twenty-Five Years Later,
|
||||
# SIAM Review,
|
||||
# Volume 45, Number 1, March 2003, pages 3--49.
|
||||
#
|
||||
# Cleve Moler,
|
||||
# Cleve's Corner: A Balancing Act for the Matrix Exponential,
|
||||
# 23 July 2012.
|
||||
#
|
||||
# Robert Ward,
|
||||
# Numerical computation of the matrix exponential
|
||||
# with accuracy estimate,
|
||||
# SIAM Journal on Numerical Analysis,
|
||||
# Volume 14, Number 4, September 1977, pages 600--610.
|
||||
exp1 = np.exp(1)
|
||||
exp2 = np.exp(2)
|
||||
A = np.array([
|
||||
[1, 0],
|
||||
[0, 2],
|
||||
], dtype=float)
|
||||
desired = np.array([
|
||||
[exp1, 0],
|
||||
[0, exp2],
|
||||
], dtype=float)
|
||||
actual = expm(A)
|
||||
assert_allclose(actual, desired)
|
||||
|
||||
def test_burkardt_2(self):
|
||||
# This matrix is symmetric.
|
||||
# The calculation of the matrix exponential is straightforward.
|
||||
A = np.array([
|
||||
[1, 3],
|
||||
[3, 2],
|
||||
], dtype=float)
|
||||
desired = np.array([
|
||||
[39.322809708033859, 46.166301438885753],
|
||||
[46.166301438885768, 54.711576854329110],
|
||||
], dtype=float)
|
||||
actual = expm(A)
|
||||
assert_allclose(actual, desired)
|
||||
|
||||
def test_burkardt_3(self):
|
||||
# This example is due to Laub.
|
||||
# This matrix is ill-suited for the Taylor series approach.
|
||||
# As powers of A are computed, the entries blow up too quickly.
|
||||
exp1 = np.exp(1)
|
||||
exp39 = np.exp(39)
|
||||
A = np.array([
|
||||
[0, 1],
|
||||
[-39, -40],
|
||||
], dtype=float)
|
||||
desired = np.array([
|
||||
[
|
||||
39/(38*exp1) - 1/(38*exp39),
|
||||
-np.expm1(-38) / (38*exp1)],
|
||||
[
|
||||
39*np.expm1(-38) / (38*exp1),
|
||||
-1/(38*exp1) + 39/(38*exp39)],
|
||||
], dtype=float)
|
||||
actual = expm(A)
|
||||
assert_allclose(actual, desired)
|
||||
|
||||
def test_burkardt_4(self):
|
||||
# This example is due to Moler and Van Loan.
|
||||
# The example will cause problems for the series summation approach,
|
||||
# as well as for diagonal Pade approximations.
|
||||
A = np.array([
|
||||
[-49, 24],
|
||||
[-64, 31],
|
||||
], dtype=float)
|
||||
U = np.array([[3, 1], [4, 2]], dtype=float)
|
||||
V = np.array([[1, -1/2], [-2, 3/2]], dtype=float)
|
||||
w = np.array([-17, -1], dtype=float)
|
||||
desired = np.dot(U * np.exp(w), V)
|
||||
actual = expm(A)
|
||||
assert_allclose(actual, desired)
|
||||
|
||||
def test_burkardt_5(self):
|
||||
# This example is due to Moler and Van Loan.
|
||||
# This matrix is strictly upper triangular
|
||||
# All powers of A are zero beyond some (low) limit.
|
||||
# This example will cause problems for Pade approximations.
|
||||
A = np.array([
|
||||
[0, 6, 0, 0],
|
||||
[0, 0, 6, 0],
|
||||
[0, 0, 0, 6],
|
||||
[0, 0, 0, 0],
|
||||
], dtype=float)
|
||||
desired = np.array([
|
||||
[1, 6, 18, 36],
|
||||
[0, 1, 6, 18],
|
||||
[0, 0, 1, 6],
|
||||
[0, 0, 0, 1],
|
||||
], dtype=float)
|
||||
actual = expm(A)
|
||||
assert_allclose(actual, desired)
|
||||
|
||||
def test_burkardt_6(self):
|
||||
# This example is due to Moler and Van Loan.
|
||||
# This matrix does not have a complete set of eigenvectors.
|
||||
# That means the eigenvector approach will fail.
|
||||
exp1 = np.exp(1)
|
||||
A = np.array([
|
||||
[1, 1],
|
||||
[0, 1],
|
||||
], dtype=float)
|
||||
desired = np.array([
|
||||
[exp1, exp1],
|
||||
[0, exp1],
|
||||
], dtype=float)
|
||||
actual = expm(A)
|
||||
assert_allclose(actual, desired)
|
||||
|
||||
def test_burkardt_7(self):
|
||||
# This example is due to Moler and Van Loan.
|
||||
# This matrix is very close to example 5.
|
||||
# Mathematically, it has a complete set of eigenvectors.
|
||||
# Numerically, however, the calculation will be suspect.
|
||||
exp1 = np.exp(1)
|
||||
eps = np.spacing(1)
|
||||
A = np.array([
|
||||
[1 + eps, 1],
|
||||
[0, 1 - eps],
|
||||
], dtype=float)
|
||||
desired = np.array([
|
||||
[exp1, exp1],
|
||||
[0, exp1],
|
||||
], dtype=float)
|
||||
actual = expm(A)
|
||||
assert_allclose(actual, desired)
|
||||
|
||||
def test_burkardt_8(self):
|
||||
# This matrix was an example in Wikipedia.
|
||||
exp4 = np.exp(4)
|
||||
exp16 = np.exp(16)
|
||||
A = np.array([
|
||||
[21, 17, 6],
|
||||
[-5, -1, -6],
|
||||
[4, 4, 16],
|
||||
], dtype=float)
|
||||
desired = np.array([
|
||||
[13*exp16 - exp4, 13*exp16 - 5*exp4, 2*exp16 - 2*exp4],
|
||||
[-9*exp16 + exp4, -9*exp16 + 5*exp4, -2*exp16 + 2*exp4],
|
||||
[16*exp16, 16*exp16, 4*exp16],
|
||||
], dtype=float) * 0.25
|
||||
actual = expm(A)
|
||||
assert_allclose(actual, desired)
|
||||
|
||||
def test_burkardt_9(self):
|
||||
# This matrix is due to the NAG Library.
|
||||
# It is an example for function F01ECF.
|
||||
A = np.array([
|
||||
[1, 2, 2, 2],
|
||||
[3, 1, 1, 2],
|
||||
[3, 2, 1, 2],
|
||||
[3, 3, 3, 1],
|
||||
], dtype=float)
|
||||
desired = np.array([
|
||||
[740.7038, 610.8500, 542.2743, 549.1753],
|
||||
[731.2510, 603.5524, 535.0884, 542.2743],
|
||||
[823.7630, 679.4257, 603.5524, 610.8500],
|
||||
[998.4355, 823.7630, 731.2510, 740.7038],
|
||||
], dtype=float)
|
||||
actual = expm(A)
|
||||
assert_allclose(actual, desired)
|
||||
|
||||
def test_burkardt_10(self):
|
||||
# This is Ward's example #1.
|
||||
# It is defective and nonderogatory.
|
||||
A = np.array([
|
||||
[4, 2, 0],
|
||||
[1, 4, 1],
|
||||
[1, 1, 4],
|
||||
], dtype=float)
|
||||
assert_allclose(sorted(scipy.linalg.eigvals(A)), (3, 3, 6))
|
||||
desired = np.array([
|
||||
[147.8666224463699, 183.7651386463682, 71.79703239999647],
|
||||
[127.7810855231823, 183.7651386463682, 91.88256932318415],
|
||||
[127.7810855231824, 163.6796017231806, 111.9681062463718],
|
||||
], dtype=float)
|
||||
actual = expm(A)
|
||||
assert_allclose(actual, desired)
|
||||
|
||||
def test_burkardt_11(self):
|
||||
# This is Ward's example #2.
|
||||
# It is a symmetric matrix.
|
||||
A = np.array([
|
||||
[29.87942128909879, 0.7815750847907159, -2.289519314033932],
|
||||
[0.7815750847907159, 25.72656945571064, 8.680737820540137],
|
||||
[-2.289519314033932, 8.680737820540137, 34.39400925519054],
|
||||
], dtype=float)
|
||||
assert_allclose(scipy.linalg.eigvalsh(A), (20, 30, 40))
|
||||
desired = np.array([
|
||||
[
|
||||
5.496313853692378E+15,
|
||||
-1.823188097200898E+16,
|
||||
-3.047577080858001E+16],
|
||||
[
|
||||
-1.823188097200899E+16,
|
||||
6.060522870222108E+16,
|
||||
1.012918429302482E+17],
|
||||
[
|
||||
-3.047577080858001E+16,
|
||||
1.012918429302482E+17,
|
||||
1.692944112408493E+17],
|
||||
], dtype=float)
|
||||
actual = expm(A)
|
||||
assert_allclose(actual, desired)
|
||||
|
||||
def test_burkardt_12(self):
|
||||
# This is Ward's example #3.
|
||||
# Ward's algorithm has difficulty estimating the accuracy
|
||||
# of its results.
|
||||
A = np.array([
|
||||
[-131, 19, 18],
|
||||
[-390, 56, 54],
|
||||
[-387, 57, 52],
|
||||
], dtype=float)
|
||||
assert_allclose(sorted(scipy.linalg.eigvals(A)), (-20, -2, -1))
|
||||
desired = np.array([
|
||||
[-1.509644158793135, 0.3678794391096522, 0.1353352811751005],
|
||||
[-5.632570799891469, 1.471517758499875, 0.4060058435250609],
|
||||
[-4.934938326088363, 1.103638317328798, 0.5413411267617766],
|
||||
], dtype=float)
|
||||
actual = expm(A)
|
||||
assert_allclose(actual, desired)
|
||||
|
||||
def test_burkardt_13(self):
|
||||
# This is Ward's example #4.
|
||||
# This is a version of the Forsythe matrix.
|
||||
# The eigenvector problem is badly conditioned.
|
||||
# Ward's algorithm has difficulty esimating the accuracy
|
||||
# of its results for this problem.
|
||||
#
|
||||
# Check the construction of one instance of this family of matrices.
|
||||
A4_actual = _burkardt_13_power(4, 1)
|
||||
A4_desired = [[0, 1, 0, 0],
|
||||
[0, 0, 1, 0],
|
||||
[0, 0, 0, 1],
|
||||
[1e-4, 0, 0, 0]]
|
||||
assert_allclose(A4_actual, A4_desired)
|
||||
# Check the expm for a few instances.
|
||||
for n in (2, 3, 4, 10):
|
||||
# Approximate expm using Taylor series.
|
||||
# This works well for this matrix family
|
||||
# because each matrix in the summation,
|
||||
# even before dividing by the factorial,
|
||||
# is entrywise positive with max entry 10**(-floor(p/n)*n).
|
||||
k = max(1, int(np.ceil(16/n)))
|
||||
desired = np.zeros((n, n), dtype=float)
|
||||
for p in range(n*k):
|
||||
Ap = _burkardt_13_power(n, p)
|
||||
assert_equal(np.min(Ap), 0)
|
||||
assert_allclose(np.max(Ap), np.power(10, -np.floor(p/n)*n))
|
||||
desired += Ap / factorial(p)
|
||||
actual = expm(_burkardt_13_power(n, 1))
|
||||
assert_allclose(actual, desired)
|
||||
|
||||
def test_burkardt_14(self):
|
||||
# This is Moler's example.
|
||||
# This badly scaled matrix caused problems for MATLAB's expm().
|
||||
A = np.array([
|
||||
[0, 1e-8, 0],
|
||||
[-(2e10 + 4e8/6.), -3, 2e10],
|
||||
[200./3., 0, -200./3.],
|
||||
], dtype=float)
|
||||
desired = np.array([
|
||||
[0.446849468283175, 1.54044157383952e-09, 0.462811453558774],
|
||||
[-5743067.77947947, -0.0152830038686819, -4526542.71278401],
|
||||
[0.447722977849494, 1.54270484519591e-09, 0.463480648837651],
|
||||
], dtype=float)
|
||||
actual = expm(A)
|
||||
assert_allclose(actual, desired)
|
||||
|
||||
def test_pascal(self):
|
||||
# Test pascal triangle.
|
||||
# Nilpotent exponential, used to trigger a failure (gh-8029)
|
||||
|
||||
for scale in [1.0, 1e-3, 1e-6]:
|
||||
for n in range(120):
|
||||
A = np.diag(np.arange(1, n + 1), -1) * scale
|
||||
B = expm(A)
|
||||
|
||||
sc = scale**np.arange(n, -1, -1)
|
||||
if np.any(sc < 1e-300):
|
||||
continue
|
||||
|
||||
got = B
|
||||
expected = binom(np.arange(n + 1)[:,None],
|
||||
np.arange(n + 1)[None,:]) * sc[None,:] / sc[:,None]
|
||||
err = abs(expected - got).max()
|
||||
atol = 1e-13 * abs(expected).max()
|
||||
assert_allclose(got, expected, atol=atol)
|
||||
|
||||
|
||||
class TestOperators(object):
|
||||
|
||||
def test_product_operator(self):
|
||||
random.seed(1234)
|
||||
n = 5
|
||||
k = 2
|
||||
nsamples = 10
|
||||
for i in range(nsamples):
|
||||
A = np.random.randn(n, n)
|
||||
B = np.random.randn(n, n)
|
||||
C = np.random.randn(n, n)
|
||||
D = np.random.randn(n, k)
|
||||
op = ProductOperator(A, B, C)
|
||||
assert_allclose(op.matmat(D), A.dot(B).dot(C).dot(D))
|
||||
assert_allclose(op.T.matmat(D), (A.dot(B).dot(C)).T.dot(D))
|
||||
|
||||
def test_matrix_power_operator(self):
|
||||
random.seed(1234)
|
||||
n = 5
|
||||
k = 2
|
||||
p = 3
|
||||
nsamples = 10
|
||||
for i in range(nsamples):
|
||||
A = np.random.randn(n, n)
|
||||
B = np.random.randn(n, k)
|
||||
op = MatrixPowerOperator(A, p)
|
||||
assert_allclose(op.matmat(B), matrix_power(A, p).dot(B))
|
||||
assert_allclose(op.T.matmat(B), matrix_power(A, p).T.dot(B))
|
||||
|
||||
@@ -0,0 +1,127 @@
|
||||
"""Test functions for the sparse.linalg.norm module
|
||||
"""
|
||||
|
||||
from __future__ import division, print_function, absolute_import
|
||||
|
||||
import numpy as np
|
||||
from numpy.linalg import norm as npnorm
|
||||
from numpy.testing import assert_equal, assert_allclose
|
||||
from pytest import raises as assert_raises
|
||||
|
||||
from scipy._lib._version import NumpyVersion
|
||||
import scipy.sparse
|
||||
from scipy.sparse.linalg import norm as spnorm
|
||||
|
||||
|
||||
class TestNorm(object):
|
||||
def setup_method(self):
|
||||
a = np.arange(9) - 4
|
||||
b = a.reshape((3, 3))
|
||||
self.b = scipy.sparse.csr_matrix(b)
|
||||
|
||||
def test_matrix_norm(self):
|
||||
|
||||
# Frobenius norm is the default
|
||||
assert_allclose(spnorm(self.b), 7.745966692414834)
|
||||
assert_allclose(spnorm(self.b, 'fro'), 7.745966692414834)
|
||||
|
||||
assert_allclose(spnorm(self.b, np.inf), 9)
|
||||
assert_allclose(spnorm(self.b, -np.inf), 2)
|
||||
assert_allclose(spnorm(self.b, 1), 7)
|
||||
assert_allclose(spnorm(self.b, -1), 6)
|
||||
|
||||
# _multi_svd_norm is not implemented for sparse matrix
|
||||
assert_raises(NotImplementedError, spnorm, self.b, 2)
|
||||
assert_raises(NotImplementedError, spnorm, self.b, -2)
|
||||
|
||||
def test_matrix_norm_axis(self):
|
||||
for m, axis in ((self.b, None), (self.b, (0, 1)), (self.b.T, (1, 0))):
|
||||
assert_allclose(spnorm(m, axis=axis), 7.745966692414834)
|
||||
assert_allclose(spnorm(m, 'fro', axis=axis), 7.745966692414834)
|
||||
assert_allclose(spnorm(m, np.inf, axis=axis), 9)
|
||||
assert_allclose(spnorm(m, -np.inf, axis=axis), 2)
|
||||
assert_allclose(spnorm(m, 1, axis=axis), 7)
|
||||
assert_allclose(spnorm(m, -1, axis=axis), 6)
|
||||
|
||||
def test_vector_norm(self):
|
||||
v = [4.5825756949558398, 4.2426406871192848, 4.5825756949558398]
|
||||
for m, a in (self.b, 0), (self.b.T, 1):
|
||||
for axis in a, (a, ), a-2, (a-2, ):
|
||||
assert_allclose(spnorm(m, 1, axis=axis), [7, 6, 7])
|
||||
assert_allclose(spnorm(m, np.inf, axis=axis), [4, 3, 4])
|
||||
assert_allclose(spnorm(m, axis=axis), v)
|
||||
assert_allclose(spnorm(m, ord=2, axis=axis), v)
|
||||
assert_allclose(spnorm(m, ord=None, axis=axis), v)
|
||||
|
||||
def test_norm_exceptions(self):
|
||||
m = self.b
|
||||
assert_raises(TypeError, spnorm, m, None, 1.5)
|
||||
assert_raises(TypeError, spnorm, m, None, [2])
|
||||
assert_raises(ValueError, spnorm, m, None, ())
|
||||
assert_raises(ValueError, spnorm, m, None, (0, 1, 2))
|
||||
assert_raises(ValueError, spnorm, m, None, (0, 0))
|
||||
assert_raises(ValueError, spnorm, m, None, (0, 2))
|
||||
assert_raises(ValueError, spnorm, m, None, (-3, 0))
|
||||
assert_raises(ValueError, spnorm, m, None, 2)
|
||||
assert_raises(ValueError, spnorm, m, None, -3)
|
||||
assert_raises(ValueError, spnorm, m, 'plate_of_shrimp', 0)
|
||||
assert_raises(ValueError, spnorm, m, 'plate_of_shrimp', (0, 1))
|
||||
|
||||
|
||||
class TestVsNumpyNorm(object):
|
||||
_sparse_types = (
|
||||
scipy.sparse.bsr_matrix,
|
||||
scipy.sparse.coo_matrix,
|
||||
scipy.sparse.csc_matrix,
|
||||
scipy.sparse.csr_matrix,
|
||||
scipy.sparse.dia_matrix,
|
||||
scipy.sparse.dok_matrix,
|
||||
scipy.sparse.lil_matrix,
|
||||
)
|
||||
_test_matrices = (
|
||||
(np.arange(9) - 4).reshape((3, 3)),
|
||||
[
|
||||
[1, 2, 3],
|
||||
[-1, 1, 4]],
|
||||
[
|
||||
[1, 0, 3],
|
||||
[-1, 1, 4j]],
|
||||
)
|
||||
|
||||
def test_sparse_matrix_norms(self):
|
||||
for sparse_type in self._sparse_types:
|
||||
for M in self._test_matrices:
|
||||
S = sparse_type(M)
|
||||
assert_allclose(spnorm(S), npnorm(M))
|
||||
assert_allclose(spnorm(S, 'fro'), npnorm(M, 'fro'))
|
||||
assert_allclose(spnorm(S, np.inf), npnorm(M, np.inf))
|
||||
assert_allclose(spnorm(S, -np.inf), npnorm(M, -np.inf))
|
||||
assert_allclose(spnorm(S, 1), npnorm(M, 1))
|
||||
assert_allclose(spnorm(S, -1), npnorm(M, -1))
|
||||
|
||||
def test_sparse_matrix_norms_with_axis(self):
|
||||
for sparse_type in self._sparse_types:
|
||||
for M in self._test_matrices:
|
||||
S = sparse_type(M)
|
||||
for axis in None, (0, 1), (1, 0):
|
||||
assert_allclose(spnorm(S, axis=axis), npnorm(M, axis=axis))
|
||||
for ord in 'fro', np.inf, -np.inf, 1, -1:
|
||||
assert_allclose(spnorm(S, ord, axis=axis),
|
||||
npnorm(M, ord, axis=axis))
|
||||
# Some numpy matrix norms are allergic to negative axes.
|
||||
for axis in (-2, -1), (-1, -2), (1, -2):
|
||||
assert_allclose(spnorm(S, axis=axis), npnorm(M, axis=axis))
|
||||
assert_allclose(spnorm(S, 'f', axis=axis),
|
||||
npnorm(M, 'f', axis=axis))
|
||||
assert_allclose(spnorm(S, 'fro', axis=axis),
|
||||
npnorm(M, 'fro', axis=axis))
|
||||
|
||||
def test_sparse_vector_norms(self):
|
||||
for sparse_type in self._sparse_types:
|
||||
for M in self._test_matrices:
|
||||
S = sparse_type(M)
|
||||
for axis in (0, 1, -1, -2, (0, ), (1, ), (-1, ), (-2, )):
|
||||
assert_allclose(spnorm(S, axis=axis), npnorm(M, axis=axis))
|
||||
for ord in None, 2, np.inf, -np.inf, 1, 0.5, 0.42:
|
||||
assert_allclose(spnorm(S, ord, axis=axis),
|
||||
npnorm(M, ord, axis=axis))
|
||||
@@ -0,0 +1,254 @@
|
||||
"""Test functions for the sparse.linalg._onenormest module
|
||||
"""
|
||||
|
||||
from __future__ import division, print_function, absolute_import
|
||||
|
||||
import numpy as np
|
||||
from numpy.testing import assert_allclose, assert_equal, assert_
|
||||
import pytest
|
||||
import scipy.linalg
|
||||
import scipy.sparse.linalg
|
||||
from scipy.sparse.linalg._onenormest import _onenormest_core, _algorithm_2_2
|
||||
|
||||
|
||||
class MatrixProductOperator(scipy.sparse.linalg.LinearOperator):
|
||||
"""
|
||||
This is purely for onenormest testing.
|
||||
"""
|
||||
|
||||
def __init__(self, A, B):
|
||||
if A.ndim != 2 or B.ndim != 2:
|
||||
raise ValueError('expected ndarrays representing matrices')
|
||||
if A.shape[1] != B.shape[0]:
|
||||
raise ValueError('incompatible shapes')
|
||||
self.A = A
|
||||
self.B = B
|
||||
self.ndim = 2
|
||||
self.shape = (A.shape[0], B.shape[1])
|
||||
|
||||
def _matvec(self, x):
|
||||
return np.dot(self.A, np.dot(self.B, x))
|
||||
|
||||
def _rmatvec(self, x):
|
||||
return np.dot(np.dot(x, self.A), self.B)
|
||||
|
||||
def _matmat(self, X):
|
||||
return np.dot(self.A, np.dot(self.B, X))
|
||||
|
||||
@property
|
||||
def T(self):
|
||||
return MatrixProductOperator(self.B.T, self.A.T)
|
||||
|
||||
|
||||
class TestOnenormest(object):
|
||||
|
||||
@pytest.mark.xslow
|
||||
def test_onenormest_table_3_t_2(self):
|
||||
# This will take multiple seconds if your computer is slow like mine.
|
||||
# It is stochastic, so the tolerance could be too strict.
|
||||
np.random.seed(1234)
|
||||
t = 2
|
||||
n = 100
|
||||
itmax = 5
|
||||
nsamples = 5000
|
||||
observed = []
|
||||
expected = []
|
||||
nmult_list = []
|
||||
nresample_list = []
|
||||
for i in range(nsamples):
|
||||
A = scipy.linalg.inv(np.random.randn(n, n))
|
||||
est, v, w, nmults, nresamples = _onenormest_core(A, A.T, t, itmax)
|
||||
observed.append(est)
|
||||
expected.append(scipy.linalg.norm(A, 1))
|
||||
nmult_list.append(nmults)
|
||||
nresample_list.append(nresamples)
|
||||
observed = np.array(observed, dtype=float)
|
||||
expected = np.array(expected, dtype=float)
|
||||
relative_errors = np.abs(observed - expected) / expected
|
||||
|
||||
# check the mean underestimation ratio
|
||||
underestimation_ratio = observed / expected
|
||||
assert_(0.99 < np.mean(underestimation_ratio) < 1.0)
|
||||
|
||||
# check the max and mean required column resamples
|
||||
assert_equal(np.max(nresample_list), 2)
|
||||
assert_(0.05 < np.mean(nresample_list) < 0.2)
|
||||
|
||||
# check the proportion of norms computed exactly correctly
|
||||
nexact = np.count_nonzero(relative_errors < 1e-14)
|
||||
proportion_exact = nexact / float(nsamples)
|
||||
assert_(0.9 < proportion_exact < 0.95)
|
||||
|
||||
# check the average number of matrix*vector multiplications
|
||||
assert_(3.5 < np.mean(nmult_list) < 4.5)
|
||||
|
||||
@pytest.mark.xslow
|
||||
def test_onenormest_table_4_t_7(self):
|
||||
# This will take multiple seconds if your computer is slow like mine.
|
||||
# It is stochastic, so the tolerance could be too strict.
|
||||
np.random.seed(1234)
|
||||
t = 7
|
||||
n = 100
|
||||
itmax = 5
|
||||
nsamples = 5000
|
||||
observed = []
|
||||
expected = []
|
||||
nmult_list = []
|
||||
nresample_list = []
|
||||
for i in range(nsamples):
|
||||
A = np.random.randint(-1, 2, size=(n, n))
|
||||
est, v, w, nmults, nresamples = _onenormest_core(A, A.T, t, itmax)
|
||||
observed.append(est)
|
||||
expected.append(scipy.linalg.norm(A, 1))
|
||||
nmult_list.append(nmults)
|
||||
nresample_list.append(nresamples)
|
||||
observed = np.array(observed, dtype=float)
|
||||
expected = np.array(expected, dtype=float)
|
||||
relative_errors = np.abs(observed - expected) / expected
|
||||
|
||||
# check the mean underestimation ratio
|
||||
underestimation_ratio = observed / expected
|
||||
assert_(0.90 < np.mean(underestimation_ratio) < 0.99)
|
||||
|
||||
# check the required column resamples
|
||||
assert_equal(np.max(nresample_list), 0)
|
||||
|
||||
# check the proportion of norms computed exactly correctly
|
||||
nexact = np.count_nonzero(relative_errors < 1e-14)
|
||||
proportion_exact = nexact / float(nsamples)
|
||||
assert_(0.15 < proportion_exact < 0.25)
|
||||
|
||||
# check the average number of matrix*vector multiplications
|
||||
assert_(3.5 < np.mean(nmult_list) < 4.5)
|
||||
|
||||
def test_onenormest_table_5_t_1(self):
|
||||
# "note that there is no randomness and hence only one estimate for t=1"
|
||||
t = 1
|
||||
n = 100
|
||||
itmax = 5
|
||||
alpha = 1 - 1e-6
|
||||
A = -scipy.linalg.inv(np.identity(n) + alpha*np.eye(n, k=1))
|
||||
first_col = np.array([1] + [0]*(n-1))
|
||||
first_row = np.array([(-alpha)**i for i in range(n)])
|
||||
B = -scipy.linalg.toeplitz(first_col, first_row)
|
||||
assert_allclose(A, B)
|
||||
est, v, w, nmults, nresamples = _onenormest_core(B, B.T, t, itmax)
|
||||
exact_value = scipy.linalg.norm(B, 1)
|
||||
underest_ratio = est / exact_value
|
||||
assert_allclose(underest_ratio, 0.05, rtol=1e-4)
|
||||
assert_equal(nmults, 11)
|
||||
assert_equal(nresamples, 0)
|
||||
# check the non-underscored version of onenormest
|
||||
est_plain = scipy.sparse.linalg.onenormest(B, t=t, itmax=itmax)
|
||||
assert_allclose(est, est_plain)
|
||||
|
||||
@pytest.mark.xslow
|
||||
def test_onenormest_table_6_t_1(self):
|
||||
#TODO this test seems to give estimates that match the table,
|
||||
#TODO even though no attempt has been made to deal with
|
||||
#TODO complex numbers in the one-norm estimation.
|
||||
# This will take multiple seconds if your computer is slow like mine.
|
||||
# It is stochastic, so the tolerance could be too strict.
|
||||
np.random.seed(1234)
|
||||
t = 1
|
||||
n = 100
|
||||
itmax = 5
|
||||
nsamples = 5000
|
||||
observed = []
|
||||
expected = []
|
||||
nmult_list = []
|
||||
nresample_list = []
|
||||
for i in range(nsamples):
|
||||
A_inv = np.random.rand(n, n) + 1j * np.random.rand(n, n)
|
||||
A = scipy.linalg.inv(A_inv)
|
||||
est, v, w, nmults, nresamples = _onenormest_core(A, A.T, t, itmax)
|
||||
observed.append(est)
|
||||
expected.append(scipy.linalg.norm(A, 1))
|
||||
nmult_list.append(nmults)
|
||||
nresample_list.append(nresamples)
|
||||
observed = np.array(observed, dtype=float)
|
||||
expected = np.array(expected, dtype=float)
|
||||
relative_errors = np.abs(observed - expected) / expected
|
||||
|
||||
# check the mean underestimation ratio
|
||||
underestimation_ratio = observed / expected
|
||||
underestimation_ratio_mean = np.mean(underestimation_ratio)
|
||||
assert_(0.90 < underestimation_ratio_mean < 0.99)
|
||||
|
||||
# check the required column resamples
|
||||
max_nresamples = np.max(nresample_list)
|
||||
assert_equal(max_nresamples, 0)
|
||||
|
||||
# check the proportion of norms computed exactly correctly
|
||||
nexact = np.count_nonzero(relative_errors < 1e-14)
|
||||
proportion_exact = nexact / float(nsamples)
|
||||
assert_(0.7 < proportion_exact < 0.8)
|
||||
|
||||
# check the average number of matrix*vector multiplications
|
||||
mean_nmult = np.mean(nmult_list)
|
||||
assert_(4 < mean_nmult < 5)
|
||||
|
||||
def _help_product_norm_slow(self, A, B):
|
||||
# for profiling
|
||||
C = np.dot(A, B)
|
||||
return scipy.linalg.norm(C, 1)
|
||||
|
||||
def _help_product_norm_fast(self, A, B):
|
||||
# for profiling
|
||||
t = 2
|
||||
itmax = 5
|
||||
D = MatrixProductOperator(A, B)
|
||||
est, v, w, nmults, nresamples = _onenormest_core(D, D.T, t, itmax)
|
||||
return est
|
||||
|
||||
@pytest.mark.slow
|
||||
def test_onenormest_linear_operator(self):
|
||||
# Define a matrix through its product A B.
|
||||
# Depending on the shapes of A and B,
|
||||
# it could be easy to multiply this product by a small matrix,
|
||||
# but it could be annoying to look at all of
|
||||
# the entries of the product explicitly.
|
||||
np.random.seed(1234)
|
||||
n = 6000
|
||||
k = 3
|
||||
A = np.random.randn(n, k)
|
||||
B = np.random.randn(k, n)
|
||||
fast_estimate = self._help_product_norm_fast(A, B)
|
||||
exact_value = self._help_product_norm_slow(A, B)
|
||||
assert_(fast_estimate <= exact_value <= 3*fast_estimate,
|
||||
'fast: %g\nexact:%g' % (fast_estimate, exact_value))
|
||||
|
||||
def test_returns(self):
|
||||
np.random.seed(1234)
|
||||
A = scipy.sparse.rand(50, 50, 0.1)
|
||||
|
||||
s0 = scipy.linalg.norm(A.todense(), 1)
|
||||
s1, v = scipy.sparse.linalg.onenormest(A, compute_v=True)
|
||||
s2, w = scipy.sparse.linalg.onenormest(A, compute_w=True)
|
||||
s3, v2, w2 = scipy.sparse.linalg.onenormest(A, compute_w=True, compute_v=True)
|
||||
|
||||
assert_allclose(s1, s0, rtol=1e-9)
|
||||
assert_allclose(np.linalg.norm(A.dot(v), 1), s0*np.linalg.norm(v, 1), rtol=1e-9)
|
||||
assert_allclose(A.dot(v), w, rtol=1e-9)
|
||||
|
||||
|
||||
class TestAlgorithm_2_2(object):
|
||||
|
||||
def test_randn_inv(self):
|
||||
np.random.seed(1234)
|
||||
n = 20
|
||||
nsamples = 100
|
||||
for i in range(nsamples):
|
||||
|
||||
# Choose integer t uniformly between 1 and 3 inclusive.
|
||||
t = np.random.randint(1, 4)
|
||||
|
||||
# Choose n uniformly between 10 and 40 inclusive.
|
||||
n = np.random.randint(10, 41)
|
||||
|
||||
# Sample the inverse of a matrix with random normal entries.
|
||||
A = scipy.linalg.inv(np.random.randn(n, n))
|
||||
|
||||
# Compute the 1-norm bounds.
|
||||
g, ind = _algorithm_2_2(A, A.T, t)
|
||||
|
||||
@@ -0,0 +1,64 @@
|
||||
from __future__ import division, print_function, absolute_import
|
||||
|
||||
import os
|
||||
import sys
|
||||
import subprocess
|
||||
|
||||
|
||||
def configuration(parent_package='',top_path=None):
|
||||
from numpy.distutils.misc_util import Configuration
|
||||
|
||||
config = Configuration('sparse',parent_package,top_path)
|
||||
|
||||
config.add_data_dir('tests')
|
||||
|
||||
config.add_subpackage('linalg')
|
||||
config.add_subpackage('csgraph')
|
||||
|
||||
config.add_extension('_csparsetools',
|
||||
sources=['_csparsetools.c'])
|
||||
|
||||
def get_sparsetools_sources(ext, build_dir):
|
||||
# Defer generation of source files
|
||||
subprocess.check_call([sys.executable,
|
||||
os.path.join(os.path.dirname(__file__),
|
||||
'generate_sparsetools.py'),
|
||||
'--no-force'])
|
||||
return []
|
||||
|
||||
depends = ['sparsetools_impl.h',
|
||||
'bsr_impl.h',
|
||||
'csc_impl.h',
|
||||
'csr_impl.h',
|
||||
'other_impl.h',
|
||||
'bool_ops.h',
|
||||
'bsr.h',
|
||||
'complex_ops.h',
|
||||
'coo.h',
|
||||
'csc.h',
|
||||
'csgraph.h',
|
||||
'csr.h',
|
||||
'dense.h',
|
||||
'dia.h',
|
||||
'py3k.h',
|
||||
'sparsetools.h',
|
||||
'util.h']
|
||||
depends = [os.path.join('sparsetools', hdr) for hdr in depends],
|
||||
config.add_extension('_sparsetools',
|
||||
define_macros=[('__STDC_FORMAT_MACROS', 1)],
|
||||
depends=depends,
|
||||
include_dirs=['sparsetools'],
|
||||
sources=[os.path.join('sparsetools', 'sparsetools.cxx'),
|
||||
os.path.join('sparsetools', 'csr.cxx'),
|
||||
os.path.join('sparsetools', 'csc.cxx'),
|
||||
os.path.join('sparsetools', 'bsr.cxx'),
|
||||
os.path.join('sparsetools', 'other.cxx'),
|
||||
get_sparsetools_sources]
|
||||
)
|
||||
|
||||
return config
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
from numpy.distutils.core import setup
|
||||
setup(**configuration(top_path='').todict())
|
||||
@@ -0,0 +1,27 @@
|
||||
"""
|
||||
sparsetools is not a public module in scipy.sparse, but this file is
|
||||
for backward compatibility if someone happens to use it.
|
||||
"""
|
||||
from numpy import deprecate
|
||||
|
||||
# This file shouldn't be imported by scipy --- Scipy code should use
|
||||
# internally scipy.sparse._sparsetools
|
||||
|
||||
|
||||
@deprecate(old_name="scipy.sparse.sparsetools",
|
||||
message=("scipy.sparse.sparsetools is a private module for scipy.sparse, "
|
||||
"and should not be used."))
|
||||
def _deprecated():
|
||||
pass
|
||||
|
||||
|
||||
del deprecate
|
||||
|
||||
try:
|
||||
_deprecated()
|
||||
except DeprecationWarning as e:
|
||||
# don't fail import if DeprecationWarnings raise error -- works around
|
||||
# the situation with Numpy's test framework
|
||||
pass
|
||||
|
||||
from ._sparsetools import *
|
||||
@@ -0,0 +1,100 @@
|
||||
""" Functions that operate on sparse matrices
|
||||
"""
|
||||
|
||||
from __future__ import division, print_function, absolute_import
|
||||
|
||||
__all__ = ['count_blocks','estimate_blocksize']
|
||||
|
||||
from .csr import isspmatrix_csr, csr_matrix
|
||||
from .csc import isspmatrix_csc
|
||||
from ._sparsetools import csr_count_blocks
|
||||
|
||||
|
||||
def extract_diagonal(A):
|
||||
raise NotImplementedError('use .diagonal() instead')
|
||||
|
||||
#def extract_diagonal(A):
|
||||
# """extract_diagonal(A) returns the main diagonal of A."""
|
||||
# #TODO extract k-th diagonal
|
||||
# if isspmatrix_csr(A) or isspmatrix_csc(A):
|
||||
# fn = getattr(sparsetools, A.format + "_diagonal")
|
||||
# y = empty( min(A.shape), dtype=upcast(A.dtype) )
|
||||
# fn(A.shape[0],A.shape[1],A.indptr,A.indices,A.data,y)
|
||||
# return y
|
||||
# elif isspmatrix_bsr(A):
|
||||
# M,N = A.shape
|
||||
# R,C = A.blocksize
|
||||
# y = empty( min(M,N), dtype=upcast(A.dtype) )
|
||||
# fn = sparsetools.bsr_diagonal(M//R, N//C, R, C, \
|
||||
# A.indptr, A.indices, ravel(A.data), y)
|
||||
# return y
|
||||
# else:
|
||||
# return extract_diagonal(csr_matrix(A))
|
||||
|
||||
|
||||
def estimate_blocksize(A,efficiency=0.7):
|
||||
"""Attempt to determine the blocksize of a sparse matrix
|
||||
|
||||
Returns a blocksize=(r,c) such that
|
||||
- A.nnz / A.tobsr( (r,c) ).nnz > efficiency
|
||||
"""
|
||||
if not (isspmatrix_csr(A) or isspmatrix_csc(A)):
|
||||
A = csr_matrix(A)
|
||||
|
||||
if A.nnz == 0:
|
||||
return (1,1)
|
||||
|
||||
if not 0 < efficiency < 1.0:
|
||||
raise ValueError('efficiency must satisfy 0.0 < efficiency < 1.0')
|
||||
|
||||
high_efficiency = (1.0 + efficiency) / 2.0
|
||||
nnz = float(A.nnz)
|
||||
M,N = A.shape
|
||||
|
||||
if M % 2 == 0 and N % 2 == 0:
|
||||
e22 = nnz / (4 * count_blocks(A,(2,2)))
|
||||
else:
|
||||
e22 = 0.0
|
||||
|
||||
if M % 3 == 0 and N % 3 == 0:
|
||||
e33 = nnz / (9 * count_blocks(A,(3,3)))
|
||||
else:
|
||||
e33 = 0.0
|
||||
|
||||
if e22 > high_efficiency and e33 > high_efficiency:
|
||||
e66 = nnz / (36 * count_blocks(A,(6,6)))
|
||||
if e66 > efficiency:
|
||||
return (6,6)
|
||||
else:
|
||||
return (3,3)
|
||||
else:
|
||||
if M % 4 == 0 and N % 4 == 0:
|
||||
e44 = nnz / (16 * count_blocks(A,(4,4)))
|
||||
else:
|
||||
e44 = 0.0
|
||||
|
||||
if e44 > efficiency:
|
||||
return (4,4)
|
||||
elif e33 > efficiency:
|
||||
return (3,3)
|
||||
elif e22 > efficiency:
|
||||
return (2,2)
|
||||
else:
|
||||
return (1,1)
|
||||
|
||||
|
||||
def count_blocks(A,blocksize):
|
||||
"""For a given blocksize=(r,c) count the number of occupied
|
||||
blocks in a sparse matrix A
|
||||
"""
|
||||
r,c = blocksize
|
||||
if r < 1 or c < 1:
|
||||
raise ValueError('r and c must be positive')
|
||||
|
||||
if isspmatrix_csr(A):
|
||||
M,N = A.shape
|
||||
return csr_count_blocks(M,N,r,c,A.indptr,A.indices)
|
||||
elif isspmatrix_csc(A):
|
||||
return count_blocks(A.T,(c,r))
|
||||
else:
|
||||
return count_blocks(csr_matrix(A),blocksize)
|
||||
@@ -0,0 +1,476 @@
|
||||
""" Utility functions for sparse matrix module
|
||||
"""
|
||||
|
||||
from __future__ import division, print_function, absolute_import
|
||||
|
||||
import operator
|
||||
import warnings
|
||||
import numpy as np
|
||||
|
||||
__all__ = ['upcast', 'getdtype', 'isscalarlike', 'isintlike',
|
||||
'isshape', 'issequence', 'isdense', 'ismatrix', 'get_sum_dtype']
|
||||
|
||||
supported_dtypes = ['bool', 'int8', 'uint8', 'short', 'ushort', 'intc',
|
||||
'uintc', 'longlong', 'ulonglong', 'single', 'double',
|
||||
'longdouble', 'csingle', 'cdouble', 'clongdouble']
|
||||
supported_dtypes = [np.typeDict[x] for x in supported_dtypes]
|
||||
|
||||
_upcast_memo = {}
|
||||
|
||||
|
||||
def upcast(*args):
|
||||
"""Returns the nearest supported sparse dtype for the
|
||||
combination of one or more types.
|
||||
|
||||
upcast(t0, t1, ..., tn) -> T where T is a supported dtype
|
||||
|
||||
Examples
|
||||
--------
|
||||
|
||||
>>> upcast('int32')
|
||||
<type 'numpy.int32'>
|
||||
>>> upcast('bool')
|
||||
<type 'numpy.bool_'>
|
||||
>>> upcast('int32','float32')
|
||||
<type 'numpy.float64'>
|
||||
>>> upcast('bool',complex,float)
|
||||
<type 'numpy.complex128'>
|
||||
|
||||
"""
|
||||
|
||||
t = _upcast_memo.get(hash(args))
|
||||
if t is not None:
|
||||
return t
|
||||
|
||||
upcast = np.find_common_type(args, [])
|
||||
|
||||
for t in supported_dtypes:
|
||||
if np.can_cast(upcast, t):
|
||||
_upcast_memo[hash(args)] = t
|
||||
return t
|
||||
|
||||
raise TypeError('no supported conversion for types: %r' % (args,))
|
||||
|
||||
|
||||
def upcast_char(*args):
|
||||
"""Same as `upcast` but taking dtype.char as input (faster)."""
|
||||
t = _upcast_memo.get(args)
|
||||
if t is not None:
|
||||
return t
|
||||
t = upcast(*map(np.dtype, args))
|
||||
_upcast_memo[args] = t
|
||||
return t
|
||||
|
||||
|
||||
def upcast_scalar(dtype, scalar):
|
||||
"""Determine data type for binary operation between an array of
|
||||
type `dtype` and a scalar.
|
||||
"""
|
||||
return (np.array([0], dtype=dtype) * scalar).dtype
|
||||
|
||||
|
||||
def downcast_intp_index(arr):
|
||||
"""
|
||||
Down-cast index array to np.intp dtype if it is of a larger dtype.
|
||||
|
||||
Raise an error if the array contains a value that is too large for
|
||||
intp.
|
||||
"""
|
||||
if arr.dtype.itemsize > np.dtype(np.intp).itemsize:
|
||||
if arr.size == 0:
|
||||
return arr.astype(np.intp)
|
||||
maxval = arr.max()
|
||||
minval = arr.min()
|
||||
if maxval > np.iinfo(np.intp).max or minval < np.iinfo(np.intp).min:
|
||||
raise ValueError("Cannot deal with arrays with indices larger "
|
||||
"than the machine maximum address size "
|
||||
"(e.g. 64-bit indices on 32-bit machine).")
|
||||
return arr.astype(np.intp)
|
||||
return arr
|
||||
|
||||
|
||||
def to_native(A):
|
||||
return np.asarray(A, dtype=A.dtype.newbyteorder('native'))
|
||||
|
||||
|
||||
def getdtype(dtype, a=None, default=None):
|
||||
"""Function used to simplify argument processing. If 'dtype' is not
|
||||
specified (is None), returns a.dtype; otherwise returns a np.dtype
|
||||
object created from the specified dtype argument. If 'dtype' and 'a'
|
||||
are both None, construct a data type out of the 'default' parameter.
|
||||
Furthermore, 'dtype' must be in 'allowed' set.
|
||||
"""
|
||||
# TODO is this really what we want?
|
||||
if dtype is None:
|
||||
try:
|
||||
newdtype = a.dtype
|
||||
except AttributeError:
|
||||
if default is not None:
|
||||
newdtype = np.dtype(default)
|
||||
else:
|
||||
raise TypeError("could not interpret data type")
|
||||
else:
|
||||
newdtype = np.dtype(dtype)
|
||||
if newdtype == np.object_:
|
||||
warnings.warn("object dtype is not supported by sparse matrices")
|
||||
|
||||
return newdtype
|
||||
|
||||
|
||||
def get_index_dtype(arrays=(), maxval=None, check_contents=False):
|
||||
"""
|
||||
Based on input (integer) arrays `a`, determine a suitable index data
|
||||
type that can hold the data in the arrays.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
arrays : tuple of array_like
|
||||
Input arrays whose types/contents to check
|
||||
maxval : float, optional
|
||||
Maximum value needed
|
||||
check_contents : bool, optional
|
||||
Whether to check the values in the arrays and not just their types.
|
||||
Default: False (check only the types)
|
||||
|
||||
Returns
|
||||
-------
|
||||
dtype : dtype
|
||||
Suitable index data type (int32 or int64)
|
||||
|
||||
"""
|
||||
|
||||
int32min = np.iinfo(np.int32).min
|
||||
int32max = np.iinfo(np.int32).max
|
||||
|
||||
dtype = np.intc
|
||||
if maxval is not None:
|
||||
if maxval > int32max:
|
||||
dtype = np.int64
|
||||
|
||||
if isinstance(arrays, np.ndarray):
|
||||
arrays = (arrays,)
|
||||
|
||||
for arr in arrays:
|
||||
arr = np.asarray(arr)
|
||||
if not np.can_cast(arr.dtype, np.int32):
|
||||
if check_contents:
|
||||
if arr.size == 0:
|
||||
# a bigger type not needed
|
||||
continue
|
||||
elif np.issubdtype(arr.dtype, np.integer):
|
||||
maxval = arr.max()
|
||||
minval = arr.min()
|
||||
if minval >= int32min and maxval <= int32max:
|
||||
# a bigger type not needed
|
||||
continue
|
||||
|
||||
dtype = np.int64
|
||||
break
|
||||
|
||||
return dtype
|
||||
|
||||
|
||||
def get_sum_dtype(dtype):
|
||||
"""Mimic numpy's casting for np.sum"""
|
||||
if dtype.kind == 'u' and np.can_cast(dtype, np.uint):
|
||||
return np.uint
|
||||
if np.can_cast(dtype, np.int_):
|
||||
return np.int_
|
||||
return dtype
|
||||
|
||||
|
||||
def isscalarlike(x):
|
||||
"""Is x either a scalar, an array scalar, or a 0-dim array?"""
|
||||
return np.isscalar(x) or (isdense(x) and x.ndim == 0)
|
||||
|
||||
|
||||
def isintlike(x):
|
||||
"""Is x appropriate as an index into a sparse matrix? Returns True
|
||||
if it can be cast safely to a machine int.
|
||||
"""
|
||||
# Fast-path check to eliminate non-scalar values. operator.index would
|
||||
# catch this case too, but the exception catching is slow.
|
||||
if np.ndim(x) != 0:
|
||||
return False
|
||||
try:
|
||||
operator.index(x)
|
||||
except (TypeError, ValueError):
|
||||
try:
|
||||
loose_int = bool(int(x) == x)
|
||||
except (TypeError, ValueError):
|
||||
return False
|
||||
if loose_int:
|
||||
warnings.warn("Inexact indices into sparse matrices are deprecated",
|
||||
DeprecationWarning)
|
||||
return loose_int
|
||||
return True
|
||||
|
||||
|
||||
def isshape(x, nonneg=False):
|
||||
"""Is x a valid 2-tuple of dimensions?
|
||||
|
||||
If nonneg, also checks that the dimensions are non-negative.
|
||||
"""
|
||||
try:
|
||||
# Assume it's a tuple of matrix dimensions (M, N)
|
||||
(M, N) = x
|
||||
except Exception:
|
||||
return False
|
||||
else:
|
||||
if isintlike(M) and isintlike(N):
|
||||
if np.ndim(M) == 0 and np.ndim(N) == 0:
|
||||
if not nonneg or (M >= 0 and N >= 0):
|
||||
return True
|
||||
return False
|
||||
|
||||
|
||||
def issequence(t):
|
||||
return ((isinstance(t, (list, tuple)) and
|
||||
(len(t) == 0 or np.isscalar(t[0]))) or
|
||||
(isinstance(t, np.ndarray) and (t.ndim == 1)))
|
||||
|
||||
|
||||
def ismatrix(t):
|
||||
return ((isinstance(t, (list, tuple)) and
|
||||
len(t) > 0 and issequence(t[0])) or
|
||||
(isinstance(t, np.ndarray) and t.ndim == 2))
|
||||
|
||||
|
||||
def isdense(x):
|
||||
return isinstance(x, np.ndarray)
|
||||
|
||||
|
||||
def validateaxis(axis):
|
||||
if axis is not None:
|
||||
axis_type = type(axis)
|
||||
|
||||
# In NumPy, you can pass in tuples for 'axis', but they are
|
||||
# not very useful for sparse matrices given their limited
|
||||
# dimensions, so let's make it explicit that they are not
|
||||
# allowed to be passed in
|
||||
if axis_type == tuple:
|
||||
raise TypeError(("Tuples are not accepted for the 'axis' "
|
||||
"parameter. Please pass in one of the "
|
||||
"following: {-2, -1, 0, 1, None}."))
|
||||
|
||||
# If not a tuple, check that the provided axis is actually
|
||||
# an integer and raise a TypeError similar to NumPy's
|
||||
if not np.issubdtype(np.dtype(axis_type), np.integer):
|
||||
raise TypeError("axis must be an integer, not {name}"
|
||||
.format(name=axis_type.__name__))
|
||||
|
||||
if not (-2 <= axis <= 1):
|
||||
raise ValueError("axis out of range")
|
||||
|
||||
|
||||
def check_shape(args, current_shape=None):
|
||||
"""Imitate numpy.matrix handling of shape arguments"""
|
||||
if len(args) == 0:
|
||||
raise TypeError("function missing 1 required positional argument: "
|
||||
"'shape'")
|
||||
elif len(args) == 1:
|
||||
try:
|
||||
shape_iter = iter(args[0])
|
||||
except TypeError:
|
||||
new_shape = (operator.index(args[0]), )
|
||||
else:
|
||||
new_shape = tuple(operator.index(arg) for arg in shape_iter)
|
||||
else:
|
||||
new_shape = tuple(operator.index(arg) for arg in args)
|
||||
|
||||
if current_shape is None:
|
||||
if len(new_shape) != 2:
|
||||
raise ValueError('shape must be a 2-tuple of positive integers')
|
||||
elif new_shape[0] < 0 or new_shape[1] < 0:
|
||||
raise ValueError("'shape' elements cannot be negative")
|
||||
|
||||
else:
|
||||
# Check the current size only if needed
|
||||
current_size = np.prod(current_shape, dtype=int)
|
||||
|
||||
# Check for negatives
|
||||
negative_indexes = [i for i, x in enumerate(new_shape) if x < 0]
|
||||
if len(negative_indexes) == 0:
|
||||
new_size = np.prod(new_shape, dtype=int)
|
||||
if new_size != current_size:
|
||||
raise ValueError('cannot reshape array of size {} into shape {}'
|
||||
.format(new_size, new_shape))
|
||||
elif len(negative_indexes) == 1:
|
||||
skip = negative_indexes[0]
|
||||
specified = np.prod(new_shape[0:skip] + new_shape[skip+1:])
|
||||
unspecified, remainder = divmod(current_size, specified)
|
||||
if remainder != 0:
|
||||
err_shape = tuple('newshape' if x < 0 else x for x in new_shape)
|
||||
raise ValueError('cannot reshape array of size {} into shape {}'
|
||||
''.format(current_size, err_shape))
|
||||
new_shape = new_shape[0:skip] + (unspecified,) + new_shape[skip+1:]
|
||||
else:
|
||||
raise ValueError('can only specify one unknown dimension')
|
||||
|
||||
# Add and remove ones like numpy.matrix.reshape
|
||||
if len(new_shape) != 2:
|
||||
new_shape = tuple(arg for arg in new_shape if arg != 1)
|
||||
|
||||
if len(new_shape) == 0:
|
||||
new_shape = (1, 1)
|
||||
elif len(new_shape) == 1:
|
||||
new_shape = (1, new_shape[0])
|
||||
|
||||
if len(new_shape) > 2:
|
||||
raise ValueError('shape too large to be a matrix')
|
||||
|
||||
return new_shape
|
||||
|
||||
|
||||
def check_reshape_kwargs(kwargs):
|
||||
"""Unpack keyword arguments for reshape function.
|
||||
|
||||
This is useful because keyword arguments after star arguments are not
|
||||
allowed in Python 2, but star keyword arguments are. This function unpacks
|
||||
'order' and 'copy' from the star keyword arguments (with defaults) and
|
||||
throws an error for any remaining.
|
||||
"""
|
||||
|
||||
order = kwargs.pop('order', 'C')
|
||||
copy = kwargs.pop('copy', False)
|
||||
if kwargs: # Some unused kwargs remain
|
||||
raise TypeError('reshape() got unexpected keywords arguments: {}'
|
||||
.format(', '.join(kwargs.keys())))
|
||||
return order, copy
|
||||
|
||||
|
||||
class IndexMixin(object):
|
||||
"""
|
||||
This class simply exists to hold the methods necessary for fancy indexing.
|
||||
"""
|
||||
def _slicetoarange(self, j, shape):
|
||||
""" Given a slice object, use numpy arange to change it to a 1D
|
||||
array.
|
||||
"""
|
||||
start, stop, step = j.indices(shape)
|
||||
return np.arange(start, stop, step)
|
||||
|
||||
def _unpack_index(self, index):
|
||||
""" Parse index. Always return a tuple of the form (row, col).
|
||||
Where row/col is a integer, slice, or array of integers.
|
||||
"""
|
||||
# First, check if indexing with single boolean matrix.
|
||||
from .base import spmatrix # This feels dirty but...
|
||||
if (isinstance(index, (spmatrix, np.ndarray)) and
|
||||
(index.ndim == 2) and index.dtype.kind == 'b'):
|
||||
return index.nonzero()
|
||||
|
||||
# Parse any ellipses.
|
||||
index = self._check_ellipsis(index)
|
||||
|
||||
# Next, parse the tuple or object
|
||||
if isinstance(index, tuple):
|
||||
if len(index) == 2:
|
||||
row, col = index
|
||||
elif len(index) == 1:
|
||||
row, col = index[0], slice(None)
|
||||
else:
|
||||
raise IndexError('invalid number of indices')
|
||||
else:
|
||||
row, col = index, slice(None)
|
||||
|
||||
# Next, check for validity, or transform the index as needed.
|
||||
row, col = self._check_boolean(row, col)
|
||||
return row, col
|
||||
|
||||
def _check_ellipsis(self, index):
|
||||
"""Process indices with Ellipsis. Returns modified index."""
|
||||
if index is Ellipsis:
|
||||
return (slice(None), slice(None))
|
||||
elif isinstance(index, tuple):
|
||||
# Find first ellipsis
|
||||
for j, v in enumerate(index):
|
||||
if v is Ellipsis:
|
||||
first_ellipsis = j
|
||||
break
|
||||
else:
|
||||
first_ellipsis = None
|
||||
|
||||
# Expand the first one
|
||||
if first_ellipsis is not None:
|
||||
# Shortcuts
|
||||
if len(index) == 1:
|
||||
return (slice(None), slice(None))
|
||||
elif len(index) == 2:
|
||||
if first_ellipsis == 0:
|
||||
if index[1] is Ellipsis:
|
||||
return (slice(None), slice(None))
|
||||
else:
|
||||
return (slice(None), index[1])
|
||||
else:
|
||||
return (index[0], slice(None))
|
||||
|
||||
# General case
|
||||
tail = ()
|
||||
for v in index[first_ellipsis+1:]:
|
||||
if v is not Ellipsis:
|
||||
tail = tail + (v,)
|
||||
nd = first_ellipsis + len(tail)
|
||||
nslice = max(0, 2 - nd)
|
||||
return index[:first_ellipsis] + (slice(None),)*nslice + tail
|
||||
|
||||
return index
|
||||
|
||||
def _check_boolean(self, row, col):
|
||||
from .base import isspmatrix # ew...
|
||||
# Supporting sparse boolean indexing with both row and col does
|
||||
# not work because spmatrix.ndim is always 2.
|
||||
if isspmatrix(row) or isspmatrix(col):
|
||||
raise IndexError(
|
||||
"Indexing with sparse matrices is not supported "
|
||||
"except boolean indexing where matrix and index "
|
||||
"are equal shapes.")
|
||||
if isinstance(row, np.ndarray) and row.dtype.kind == 'b':
|
||||
row = self._boolean_index_to_array(row)
|
||||
if isinstance(col, np.ndarray) and col.dtype.kind == 'b':
|
||||
col = self._boolean_index_to_array(col)
|
||||
return row, col
|
||||
|
||||
def _boolean_index_to_array(self, i):
|
||||
if i.ndim > 1:
|
||||
raise IndexError('invalid index shape')
|
||||
return i.nonzero()[0]
|
||||
|
||||
def _index_to_arrays(self, i, j):
|
||||
i, j = self._check_boolean(i, j)
|
||||
|
||||
i_slice = isinstance(i, slice)
|
||||
if i_slice:
|
||||
i = self._slicetoarange(i, self.shape[0])[:, None]
|
||||
else:
|
||||
i = np.atleast_1d(i)
|
||||
|
||||
if isinstance(j, slice):
|
||||
j = self._slicetoarange(j, self.shape[1])[None, :]
|
||||
if i.ndim == 1:
|
||||
i = i[:, None]
|
||||
elif not i_slice:
|
||||
raise IndexError('index returns 3-dim structure')
|
||||
elif isscalarlike(j):
|
||||
# row vector special case
|
||||
j = np.atleast_1d(j)
|
||||
if i.ndim == 1:
|
||||
i, j = np.broadcast_arrays(i, j)
|
||||
i = i[:, None]
|
||||
j = j[:, None]
|
||||
return i, j
|
||||
else:
|
||||
j = np.atleast_1d(j)
|
||||
if i_slice and j.ndim > 1:
|
||||
raise IndexError('index returns 3-dim structure')
|
||||
|
||||
i, j = np.broadcast_arrays(i, j)
|
||||
|
||||
if i.ndim == 1:
|
||||
# return column vectors for 1-D indexing
|
||||
i = i[None, :]
|
||||
j = j[None, :]
|
||||
elif i.ndim > 2:
|
||||
raise IndexError("Index dimension must be <= 2")
|
||||
|
||||
return i, j
|
||||
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
Binary file not shown.
Binary file not shown.
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,476 @@
|
||||
"""test sparse matrix construction functions"""
|
||||
|
||||
from __future__ import division, print_function, absolute_import
|
||||
|
||||
import numpy as np
|
||||
from numpy import array, matrix
|
||||
from numpy.testing import (assert_equal, assert_,
|
||||
assert_array_equal, assert_array_almost_equal_nulp)
|
||||
import pytest
|
||||
from pytest import raises as assert_raises
|
||||
from scipy._lib._testutils import check_free_memory
|
||||
|
||||
from scipy.sparse import csr_matrix, coo_matrix
|
||||
|
||||
from scipy.sparse import construct
|
||||
from scipy.sparse.construct import rand as sprand
|
||||
|
||||
sparse_formats = ['csr','csc','coo','bsr','dia','lil','dok']
|
||||
|
||||
#TODO check whether format=XXX is respected
|
||||
|
||||
|
||||
def _sprandn(m, n, density=0.01, format="coo", dtype=None, random_state=None):
|
||||
# Helper function for testing.
|
||||
if random_state is None:
|
||||
random_state = np.random
|
||||
elif isinstance(random_state, (int, np.integer)):
|
||||
random_state = np.random.RandomState(random_state)
|
||||
data_rvs = random_state.randn
|
||||
return construct.random(m, n, density, format, dtype,
|
||||
random_state, data_rvs)
|
||||
|
||||
|
||||
class TestConstructUtils(object):
|
||||
def test_spdiags(self):
|
||||
diags1 = array([[1, 2, 3, 4, 5]])
|
||||
diags2 = array([[1, 2, 3, 4, 5],
|
||||
[6, 7, 8, 9,10]])
|
||||
diags3 = array([[1, 2, 3, 4, 5],
|
||||
[6, 7, 8, 9,10],
|
||||
[11,12,13,14,15]])
|
||||
|
||||
cases = []
|
||||
cases.append((diags1, 0, 1, 1, [[1]]))
|
||||
cases.append((diags1, [0], 1, 1, [[1]]))
|
||||
cases.append((diags1, [0], 2, 1, [[1],[0]]))
|
||||
cases.append((diags1, [0], 1, 2, [[1,0]]))
|
||||
cases.append((diags1, [1], 1, 2, [[0,2]]))
|
||||
cases.append((diags1,[-1], 1, 2, [[0,0]]))
|
||||
cases.append((diags1, [0], 2, 2, [[1,0],[0,2]]))
|
||||
cases.append((diags1,[-1], 2, 2, [[0,0],[1,0]]))
|
||||
cases.append((diags1, [3], 2, 2, [[0,0],[0,0]]))
|
||||
cases.append((diags1, [0], 3, 4, [[1,0,0,0],[0,2,0,0],[0,0,3,0]]))
|
||||
cases.append((diags1, [1], 3, 4, [[0,2,0,0],[0,0,3,0],[0,0,0,4]]))
|
||||
cases.append((diags1, [2], 3, 5, [[0,0,3,0,0],[0,0,0,4,0],[0,0,0,0,5]]))
|
||||
|
||||
cases.append((diags2, [0,2], 3, 3, [[1,0,8],[0,2,0],[0,0,3]]))
|
||||
cases.append((diags2, [-1,0], 3, 4, [[6,0,0,0],[1,7,0,0],[0,2,8,0]]))
|
||||
cases.append((diags2, [2,-3], 6, 6, [[0,0,3,0,0,0],
|
||||
[0,0,0,4,0,0],
|
||||
[0,0,0,0,5,0],
|
||||
[6,0,0,0,0,0],
|
||||
[0,7,0,0,0,0],
|
||||
[0,0,8,0,0,0]]))
|
||||
|
||||
cases.append((diags3, [-1,0,1], 6, 6, [[6,12, 0, 0, 0, 0],
|
||||
[1, 7,13, 0, 0, 0],
|
||||
[0, 2, 8,14, 0, 0],
|
||||
[0, 0, 3, 9,15, 0],
|
||||
[0, 0, 0, 4,10, 0],
|
||||
[0, 0, 0, 0, 5, 0]]))
|
||||
cases.append((diags3, [-4,2,-1], 6, 5, [[0, 0, 8, 0, 0],
|
||||
[11, 0, 0, 9, 0],
|
||||
[0,12, 0, 0,10],
|
||||
[0, 0,13, 0, 0],
|
||||
[1, 0, 0,14, 0],
|
||||
[0, 2, 0, 0,15]]))
|
||||
|
||||
for d,o,m,n,result in cases:
|
||||
assert_equal(construct.spdiags(d,o,m,n).todense(), result)
|
||||
|
||||
def test_diags(self):
|
||||
a = array([1, 2, 3, 4, 5])
|
||||
b = array([6, 7, 8, 9, 10])
|
||||
c = array([11, 12, 13, 14, 15])
|
||||
|
||||
cases = []
|
||||
cases.append((a[:1], 0, (1, 1), [[1]]))
|
||||
cases.append(([a[:1]], [0], (1, 1), [[1]]))
|
||||
cases.append(([a[:1]], [0], (2, 1), [[1],[0]]))
|
||||
cases.append(([a[:1]], [0], (1, 2), [[1,0]]))
|
||||
cases.append(([a[:1]], [1], (1, 2), [[0,1]]))
|
||||
cases.append(([a[:2]], [0], (2, 2), [[1,0],[0,2]]))
|
||||
cases.append(([a[:1]],[-1], (2, 2), [[0,0],[1,0]]))
|
||||
cases.append(([a[:3]], [0], (3, 4), [[1,0,0,0],[0,2,0,0],[0,0,3,0]]))
|
||||
cases.append(([a[:3]], [1], (3, 4), [[0,1,0,0],[0,0,2,0],[0,0,0,3]]))
|
||||
cases.append(([a[:1]], [-2], (3, 5), [[0,0,0,0,0],[0,0,0,0,0],[1,0,0,0,0]]))
|
||||
cases.append(([a[:2]], [-1], (3, 5), [[0,0,0,0,0],[1,0,0,0,0],[0,2,0,0,0]]))
|
||||
cases.append(([a[:3]], [0], (3, 5), [[1,0,0,0,0],[0,2,0,0,0],[0,0,3,0,0]]))
|
||||
cases.append(([a[:3]], [1], (3, 5), [[0,1,0,0,0],[0,0,2,0,0],[0,0,0,3,0]]))
|
||||
cases.append(([a[:3]], [2], (3, 5), [[0,0,1,0,0],[0,0,0,2,0],[0,0,0,0,3]]))
|
||||
cases.append(([a[:2]], [3], (3, 5), [[0,0,0,1,0],[0,0,0,0,2],[0,0,0,0,0]]))
|
||||
cases.append(([a[:1]], [4], (3, 5), [[0,0,0,0,1],[0,0,0,0,0],[0,0,0,0,0]]))
|
||||
cases.append(([a[:1]], [-4], (5, 3), [[0,0,0],[0,0,0],[0,0,0],[0,0,0],[1,0,0]]))
|
||||
cases.append(([a[:2]], [-3], (5, 3), [[0,0,0],[0,0,0],[0,0,0],[1,0,0],[0,2,0]]))
|
||||
cases.append(([a[:3]], [-2], (5, 3), [[0,0,0],[0,0,0],[1,0,0],[0,2,0],[0,0,3]]))
|
||||
cases.append(([a[:3]], [-1], (5, 3), [[0,0,0],[1,0,0],[0,2,0],[0,0,3],[0,0,0]]))
|
||||
cases.append(([a[:3]], [0], (5, 3), [[1,0,0],[0,2,0],[0,0,3],[0,0,0],[0,0,0]]))
|
||||
cases.append(([a[:2]], [1], (5, 3), [[0,1,0],[0,0,2],[0,0,0],[0,0,0],[0,0,0]]))
|
||||
cases.append(([a[:1]], [2], (5, 3), [[0,0,1],[0,0,0],[0,0,0],[0,0,0],[0,0,0]]))
|
||||
|
||||
cases.append(([a[:3],b[:1]], [0,2], (3, 3), [[1,0,6],[0,2,0],[0,0,3]]))
|
||||
cases.append(([a[:2],b[:3]], [-1,0], (3, 4), [[6,0,0,0],[1,7,0,0],[0,2,8,0]]))
|
||||
cases.append(([a[:4],b[:3]], [2,-3], (6, 6), [[0,0,1,0,0,0],
|
||||
[0,0,0,2,0,0],
|
||||
[0,0,0,0,3,0],
|
||||
[6,0,0,0,0,4],
|
||||
[0,7,0,0,0,0],
|
||||
[0,0,8,0,0,0]]))
|
||||
|
||||
cases.append(([a[:4],b,c[:4]], [-1,0,1], (5, 5), [[6,11, 0, 0, 0],
|
||||
[1, 7,12, 0, 0],
|
||||
[0, 2, 8,13, 0],
|
||||
[0, 0, 3, 9,14],
|
||||
[0, 0, 0, 4,10]]))
|
||||
cases.append(([a[:2],b[:3],c], [-4,2,-1], (6, 5), [[0, 0, 6, 0, 0],
|
||||
[11, 0, 0, 7, 0],
|
||||
[0,12, 0, 0, 8],
|
||||
[0, 0,13, 0, 0],
|
||||
[1, 0, 0,14, 0],
|
||||
[0, 2, 0, 0,15]]))
|
||||
|
||||
# too long arrays are OK
|
||||
cases.append(([a], [0], (1, 1), [[1]]))
|
||||
cases.append(([a[:3],b], [0,2], (3, 3), [[1, 0, 6], [0, 2, 0], [0, 0, 3]]))
|
||||
cases.append((np.array([[1, 2, 3], [4, 5, 6]]), [0,-1], (3, 3), [[1, 0, 0], [4, 2, 0], [0, 5, 3]]))
|
||||
|
||||
# scalar case: broadcasting
|
||||
cases.append(([1,-2,1], [1,0,-1], (3, 3), [[-2, 1, 0],
|
||||
[1, -2, 1],
|
||||
[0, 1, -2]]))
|
||||
|
||||
for d, o, shape, result in cases:
|
||||
err_msg = "%r %r %r %r" % (d, o, shape, result)
|
||||
assert_equal(construct.diags(d, o, shape=shape).todense(),
|
||||
result, err_msg=err_msg)
|
||||
|
||||
if shape[0] == shape[1] and hasattr(d[0], '__len__') and len(d[0]) <= max(shape):
|
||||
# should be able to find the shape automatically
|
||||
assert_equal(construct.diags(d, o).todense(), result,
|
||||
err_msg=err_msg)
|
||||
|
||||
def test_diags_default(self):
|
||||
a = array([1, 2, 3, 4, 5])
|
||||
assert_equal(construct.diags(a).todense(), np.diag(a))
|
||||
|
||||
def test_diags_default_bad(self):
|
||||
a = array([[1, 2, 3, 4, 5], [2, 3, 4, 5, 6]])
|
||||
assert_raises(ValueError, construct.diags, a)
|
||||
|
||||
def test_diags_bad(self):
|
||||
a = array([1, 2, 3, 4, 5])
|
||||
b = array([6, 7, 8, 9, 10])
|
||||
c = array([11, 12, 13, 14, 15])
|
||||
|
||||
cases = []
|
||||
cases.append(([a[:0]], 0, (1, 1)))
|
||||
cases.append(([a[:4],b,c[:3]], [-1,0,1], (5, 5)))
|
||||
cases.append(([a[:2],c,b[:3]], [-4,2,-1], (6, 5)))
|
||||
cases.append(([a[:2],c,b[:3]], [-4,2,-1], None))
|
||||
cases.append(([], [-4,2,-1], None))
|
||||
cases.append(([1], [-5], (4, 4)))
|
||||
cases.append(([a], 0, None))
|
||||
|
||||
for d, o, shape in cases:
|
||||
assert_raises(ValueError, construct.diags, d, o, shape)
|
||||
|
||||
assert_raises(TypeError, construct.diags, [[None]], [0])
|
||||
|
||||
def test_diags_vs_diag(self):
|
||||
# Check that
|
||||
#
|
||||
# diags([a, b, ...], [i, j, ...]) == diag(a, i) + diag(b, j) + ...
|
||||
#
|
||||
|
||||
np.random.seed(1234)
|
||||
|
||||
for n_diags in [1, 2, 3, 4, 5, 10]:
|
||||
n = 1 + n_diags//2 + np.random.randint(0, 10)
|
||||
|
||||
offsets = np.arange(-n+1, n-1)
|
||||
np.random.shuffle(offsets)
|
||||
offsets = offsets[:n_diags]
|
||||
|
||||
diagonals = [np.random.rand(n - abs(q)) for q in offsets]
|
||||
|
||||
mat = construct.diags(diagonals, offsets)
|
||||
dense_mat = sum([np.diag(x, j) for x, j in zip(diagonals, offsets)])
|
||||
|
||||
assert_array_almost_equal_nulp(mat.todense(), dense_mat)
|
||||
|
||||
if len(offsets) == 1:
|
||||
mat = construct.diags(diagonals[0], offsets[0])
|
||||
dense_mat = np.diag(diagonals[0], offsets[0])
|
||||
assert_array_almost_equal_nulp(mat.todense(), dense_mat)
|
||||
|
||||
def test_diags_dtype(self):
|
||||
x = construct.diags([2.2], [0], shape=(2, 2), dtype=int)
|
||||
assert_equal(x.dtype, int)
|
||||
assert_equal(x.todense(), [[2, 0], [0, 2]])
|
||||
|
||||
def test_diags_one_diagonal(self):
|
||||
d = list(range(5))
|
||||
for k in range(-5, 6):
|
||||
assert_equal(construct.diags(d, k).toarray(),
|
||||
construct.diags([d], [k]).toarray())
|
||||
|
||||
def test_diags_empty(self):
|
||||
x = construct.diags([])
|
||||
assert_equal(x.shape, (0, 0))
|
||||
|
||||
def test_identity(self):
|
||||
assert_equal(construct.identity(1).toarray(), [[1]])
|
||||
assert_equal(construct.identity(2).toarray(), [[1,0],[0,1]])
|
||||
|
||||
I = construct.identity(3, dtype='int8', format='dia')
|
||||
assert_equal(I.dtype, np.dtype('int8'))
|
||||
assert_equal(I.format, 'dia')
|
||||
|
||||
for fmt in sparse_formats:
|
||||
I = construct.identity(3, format=fmt)
|
||||
assert_equal(I.format, fmt)
|
||||
assert_equal(I.toarray(), [[1,0,0],[0,1,0],[0,0,1]])
|
||||
|
||||
def test_eye(self):
|
||||
assert_equal(construct.eye(1,1).toarray(), [[1]])
|
||||
assert_equal(construct.eye(2,3).toarray(), [[1,0,0],[0,1,0]])
|
||||
assert_equal(construct.eye(3,2).toarray(), [[1,0],[0,1],[0,0]])
|
||||
assert_equal(construct.eye(3,3).toarray(), [[1,0,0],[0,1,0],[0,0,1]])
|
||||
|
||||
assert_equal(construct.eye(3,3,dtype='int16').dtype, np.dtype('int16'))
|
||||
|
||||
for m in [3, 5]:
|
||||
for n in [3, 5]:
|
||||
for k in range(-5,6):
|
||||
assert_equal(construct.eye(m, n, k=k).toarray(), np.eye(m, n, k=k))
|
||||
if m == n:
|
||||
assert_equal(construct.eye(m, k=k).toarray(), np.eye(m, n, k=k))
|
||||
|
||||
def test_eye_one(self):
|
||||
assert_equal(construct.eye(1).toarray(), [[1]])
|
||||
assert_equal(construct.eye(2).toarray(), [[1,0],[0,1]])
|
||||
|
||||
I = construct.eye(3, dtype='int8', format='dia')
|
||||
assert_equal(I.dtype, np.dtype('int8'))
|
||||
assert_equal(I.format, 'dia')
|
||||
|
||||
for fmt in sparse_formats:
|
||||
I = construct.eye(3, format=fmt)
|
||||
assert_equal(I.format, fmt)
|
||||
assert_equal(I.toarray(), [[1,0,0],[0,1,0],[0,0,1]])
|
||||
|
||||
def test_kron(self):
|
||||
cases = []
|
||||
|
||||
cases.append(array([[0]]))
|
||||
cases.append(array([[-1]]))
|
||||
cases.append(array([[4]]))
|
||||
cases.append(array([[10]]))
|
||||
cases.append(array([[0],[0]]))
|
||||
cases.append(array([[0,0]]))
|
||||
cases.append(array([[1,2],[3,4]]))
|
||||
cases.append(array([[0,2],[5,0]]))
|
||||
cases.append(array([[0,2,-6],[8,0,14]]))
|
||||
cases.append(array([[5,4],[0,0],[6,0]]))
|
||||
cases.append(array([[5,4,4],[1,0,0],[6,0,8]]))
|
||||
cases.append(array([[0,1,0,2,0,5,8]]))
|
||||
cases.append(array([[0.5,0.125,0,3.25],[0,2.5,0,0]]))
|
||||
|
||||
for a in cases:
|
||||
for b in cases:
|
||||
result = construct.kron(csr_matrix(a),csr_matrix(b)).todense()
|
||||
expected = np.kron(a,b)
|
||||
assert_array_equal(result,expected)
|
||||
|
||||
def test_kronsum(self):
|
||||
cases = []
|
||||
|
||||
cases.append(array([[0]]))
|
||||
cases.append(array([[-1]]))
|
||||
cases.append(array([[4]]))
|
||||
cases.append(array([[10]]))
|
||||
cases.append(array([[1,2],[3,4]]))
|
||||
cases.append(array([[0,2],[5,0]]))
|
||||
cases.append(array([[0,2,-6],[8,0,14],[0,3,0]]))
|
||||
cases.append(array([[1,0,0],[0,5,-1],[4,-2,8]]))
|
||||
|
||||
for a in cases:
|
||||
for b in cases:
|
||||
result = construct.kronsum(csr_matrix(a),csr_matrix(b)).todense()
|
||||
expected = np.kron(np.eye(len(b)), a) + \
|
||||
np.kron(b, np.eye(len(a)))
|
||||
assert_array_equal(result,expected)
|
||||
|
||||
def test_vstack(self):
|
||||
|
||||
A = coo_matrix([[1,2],[3,4]])
|
||||
B = coo_matrix([[5,6]])
|
||||
|
||||
expected = matrix([[1, 2],
|
||||
[3, 4],
|
||||
[5, 6]])
|
||||
assert_equal(construct.vstack([A,B]).todense(), expected)
|
||||
assert_equal(construct.vstack([A,B], dtype=np.float32).dtype, np.float32)
|
||||
assert_equal(construct.vstack([A.tocsr(),B.tocsr()]).todense(),
|
||||
expected)
|
||||
assert_equal(construct.vstack([A.tocsr(),B.tocsr()], dtype=np.float32).dtype,
|
||||
np.float32)
|
||||
assert_equal(construct.vstack([A.tocsr(),B.tocsr()],
|
||||
dtype=np.float32).indices.dtype, np.int32)
|
||||
assert_equal(construct.vstack([A.tocsr(),B.tocsr()],
|
||||
dtype=np.float32).indptr.dtype, np.int32)
|
||||
|
||||
def test_hstack(self):
|
||||
|
||||
A = coo_matrix([[1,2],[3,4]])
|
||||
B = coo_matrix([[5],[6]])
|
||||
|
||||
expected = matrix([[1, 2, 5],
|
||||
[3, 4, 6]])
|
||||
assert_equal(construct.hstack([A,B]).todense(), expected)
|
||||
assert_equal(construct.hstack([A,B], dtype=np.float32).dtype, np.float32)
|
||||
assert_equal(construct.hstack([A.tocsc(),B.tocsc()]).todense(),
|
||||
expected)
|
||||
assert_equal(construct.hstack([A.tocsc(),B.tocsc()], dtype=np.float32).dtype,
|
||||
np.float32)
|
||||
|
||||
def test_bmat(self):
|
||||
|
||||
A = coo_matrix([[1,2],[3,4]])
|
||||
B = coo_matrix([[5],[6]])
|
||||
C = coo_matrix([[7]])
|
||||
D = coo_matrix((0,0))
|
||||
|
||||
expected = matrix([[1, 2, 5],
|
||||
[3, 4, 6],
|
||||
[0, 0, 7]])
|
||||
assert_equal(construct.bmat([[A,B],[None,C]]).todense(), expected)
|
||||
|
||||
expected = matrix([[1, 2, 0],
|
||||
[3, 4, 0],
|
||||
[0, 0, 7]])
|
||||
assert_equal(construct.bmat([[A,None],[None,C]]).todense(), expected)
|
||||
|
||||
expected = matrix([[0, 5],
|
||||
[0, 6],
|
||||
[7, 0]])
|
||||
assert_equal(construct.bmat([[None,B],[C,None]]).todense(), expected)
|
||||
|
||||
expected = matrix(np.empty((0,0)))
|
||||
assert_equal(construct.bmat([[None,None]]).todense(), expected)
|
||||
assert_equal(construct.bmat([[None,D],[D,None]]).todense(), expected)
|
||||
|
||||
# test bug reported in gh-5976
|
||||
expected = matrix([[7]])
|
||||
assert_equal(construct.bmat([[None,D],[C,None]]).todense(), expected)
|
||||
|
||||
# test failure cases
|
||||
with assert_raises(ValueError) as excinfo:
|
||||
construct.bmat([[A], [B]])
|
||||
excinfo.match(r'Got blocks\[1,0\]\.shape\[1\] == 1, expected 2')
|
||||
|
||||
with assert_raises(ValueError) as excinfo:
|
||||
construct.bmat([[A, C]])
|
||||
excinfo.match(r'Got blocks\[0,1\]\.shape\[0\] == 1, expected 2')
|
||||
|
||||
@pytest.mark.slow
|
||||
def test_concatenate_int32_overflow(self):
|
||||
""" test for indptr overflow when concatenating matrices """
|
||||
check_free_memory(30000)
|
||||
|
||||
n = 33000
|
||||
A = csr_matrix(np.ones((n, n), dtype=bool))
|
||||
B = A.copy()
|
||||
C = construct._compressed_sparse_stack((A,B), 0)
|
||||
|
||||
assert_(np.all(np.equal(np.diff(C.indptr), n)))
|
||||
assert_equal(C.indices.dtype, np.int64)
|
||||
assert_equal(C.indptr.dtype, np.int64)
|
||||
|
||||
def test_block_diag_basic(self):
|
||||
""" basic test for block_diag """
|
||||
A = coo_matrix([[1,2],[3,4]])
|
||||
B = coo_matrix([[5],[6]])
|
||||
C = coo_matrix([[7]])
|
||||
|
||||
expected = matrix([[1, 2, 0, 0],
|
||||
[3, 4, 0, 0],
|
||||
[0, 0, 5, 0],
|
||||
[0, 0, 6, 0],
|
||||
[0, 0, 0, 7]])
|
||||
|
||||
assert_equal(construct.block_diag((A, B, C)).todense(), expected)
|
||||
|
||||
def test_block_diag_scalar_1d_args(self):
|
||||
""" block_diag with scalar and 1d arguments """
|
||||
# one 1d matrix and a scalar
|
||||
assert_array_equal(construct.block_diag([[2,3], 4]).toarray(),
|
||||
[[2, 3, 0], [0, 0, 4]])
|
||||
|
||||
def test_block_diag_1(self):
|
||||
""" block_diag with one matrix """
|
||||
assert_equal(construct.block_diag([[1, 0]]).todense(),
|
||||
matrix([[1, 0]]))
|
||||
assert_equal(construct.block_diag([[[1, 0]]]).todense(),
|
||||
matrix([[1, 0]]))
|
||||
assert_equal(construct.block_diag([[[1], [0]]]).todense(),
|
||||
matrix([[1], [0]]))
|
||||
# just on scalar
|
||||
assert_equal(construct.block_diag([1]).todense(),
|
||||
matrix([[1]]))
|
||||
|
||||
def test_random_sampling(self):
|
||||
# Simple sanity checks for sparse random sampling.
|
||||
for f in sprand, _sprandn:
|
||||
for t in [np.float32, np.float64, np.longdouble,
|
||||
np.int32, np.int64, np.complex64, np.complex128]:
|
||||
x = f(5, 10, density=0.1, dtype=t)
|
||||
assert_equal(x.dtype, t)
|
||||
assert_equal(x.shape, (5, 10))
|
||||
assert_equal(x.nnz, 5)
|
||||
|
||||
x1 = f(5, 10, density=0.1, random_state=4321)
|
||||
assert_equal(x1.dtype, np.double)
|
||||
|
||||
x2 = f(5, 10, density=0.1,
|
||||
random_state=np.random.RandomState(4321))
|
||||
|
||||
assert_array_equal(x1.data, x2.data)
|
||||
assert_array_equal(x1.row, x2.row)
|
||||
assert_array_equal(x1.col, x2.col)
|
||||
|
||||
for density in [0.0, 0.1, 0.5, 1.0]:
|
||||
x = f(5, 10, density=density)
|
||||
assert_equal(x.nnz, int(density * np.prod(x.shape)))
|
||||
|
||||
for fmt in ['coo', 'csc', 'csr', 'lil']:
|
||||
x = f(5, 10, format=fmt)
|
||||
assert_equal(x.format, fmt)
|
||||
|
||||
assert_raises(ValueError, lambda: f(5, 10, 1.1))
|
||||
assert_raises(ValueError, lambda: f(5, 10, -0.1))
|
||||
|
||||
def test_rand(self):
|
||||
# Simple distributional checks for sparse.rand.
|
||||
for random_state in None, 4321, np.random.RandomState():
|
||||
x = sprand(10, 20, density=0.5, dtype=np.float64,
|
||||
random_state=random_state)
|
||||
assert_(np.all(np.less_equal(0, x.data)))
|
||||
assert_(np.all(np.less_equal(x.data, 1)))
|
||||
|
||||
def test_randn(self):
|
||||
# Simple distributional checks for sparse.randn.
|
||||
# Statistically, some of these should be negative
|
||||
# and some should be greater than 1.
|
||||
for random_state in None, 4321, np.random.RandomState():
|
||||
x = _sprandn(10, 20, density=0.5, dtype=np.float64,
|
||||
random_state=random_state)
|
||||
assert_(np.any(np.less(x.data, 0)))
|
||||
assert_(np.any(np.less(1, x.data)))
|
||||
|
||||
def test_random_accept_str_dtype(self):
|
||||
# anything that np.dtype can convert to a dtype should be accepted
|
||||
# for the dtype
|
||||
a = construct.random(10, 10, dtype='d')
|
||||
|
||||
@@ -0,0 +1,36 @@
|
||||
from __future__ import division, print_function, absolute_import
|
||||
|
||||
import numpy as np
|
||||
from numpy.testing import assert_array_almost_equal, assert_
|
||||
from scipy.sparse import csr_matrix, csc_matrix
|
||||
|
||||
|
||||
def test_csc_getrow():
|
||||
N = 10
|
||||
np.random.seed(0)
|
||||
X = np.random.random((N, N))
|
||||
X[X > 0.7] = 0
|
||||
Xcsc = csc_matrix(X)
|
||||
|
||||
for i in range(N):
|
||||
arr_row = X[i:i + 1, :]
|
||||
csc_row = Xcsc.getrow(i)
|
||||
|
||||
assert_array_almost_equal(arr_row, csc_row.toarray())
|
||||
assert_(type(csc_row) is csr_matrix)
|
||||
|
||||
|
||||
def test_csc_getcol():
|
||||
N = 10
|
||||
np.random.seed(0)
|
||||
X = np.random.random((N, N))
|
||||
X[X > 0.7] = 0
|
||||
Xcsc = csc_matrix(X)
|
||||
|
||||
for i in range(N):
|
||||
arr_col = X[:, i:i + 1]
|
||||
csc_col = Xcsc.getcol(i)
|
||||
|
||||
assert_array_almost_equal(arr_col, csc_col.toarray())
|
||||
assert_(type(csc_col) is csc_matrix)
|
||||
|
||||
@@ -0,0 +1,60 @@
|
||||
from __future__ import division, print_function, absolute_import
|
||||
|
||||
import numpy as np
|
||||
from numpy.testing import assert_array_almost_equal, assert_
|
||||
from scipy.sparse import csr_matrix
|
||||
|
||||
|
||||
def _check_csr_rowslice(i, sl, X, Xcsr):
|
||||
np_slice = X[i, sl]
|
||||
csr_slice = Xcsr[i, sl]
|
||||
assert_array_almost_equal(np_slice, csr_slice.toarray()[0])
|
||||
assert_(type(csr_slice) is csr_matrix)
|
||||
|
||||
|
||||
def test_csr_rowslice():
|
||||
N = 10
|
||||
np.random.seed(0)
|
||||
X = np.random.random((N, N))
|
||||
X[X > 0.7] = 0
|
||||
Xcsr = csr_matrix(X)
|
||||
|
||||
slices = [slice(None, None, None),
|
||||
slice(None, None, -1),
|
||||
slice(1, -2, 2),
|
||||
slice(-2, 1, -2)]
|
||||
|
||||
for i in range(N):
|
||||
for sl in slices:
|
||||
_check_csr_rowslice(i, sl, X, Xcsr)
|
||||
|
||||
|
||||
def test_csr_getrow():
|
||||
N = 10
|
||||
np.random.seed(0)
|
||||
X = np.random.random((N, N))
|
||||
X[X > 0.7] = 0
|
||||
Xcsr = csr_matrix(X)
|
||||
|
||||
for i in range(N):
|
||||
arr_row = X[i:i + 1, :]
|
||||
csr_row = Xcsr.getrow(i)
|
||||
|
||||
assert_array_almost_equal(arr_row, csr_row.toarray())
|
||||
assert_(type(csr_row) is csr_matrix)
|
||||
|
||||
|
||||
def test_csr_getcol():
|
||||
N = 10
|
||||
np.random.seed(0)
|
||||
X = np.random.random((N, N))
|
||||
X[X > 0.7] = 0
|
||||
Xcsr = csr_matrix(X)
|
||||
|
||||
for i in range(N):
|
||||
arr_col = X[:, i:i + 1]
|
||||
csr_col = Xcsr.getcol(i)
|
||||
|
||||
assert_array_almost_equal(arr_col, csr_col.toarray())
|
||||
assert_(type(csr_col) is csr_matrix)
|
||||
|
||||
@@ -0,0 +1,44 @@
|
||||
"""test sparse matrix construction functions"""
|
||||
|
||||
from __future__ import division, print_function, absolute_import
|
||||
|
||||
from numpy.testing import assert_equal
|
||||
from scipy.sparse import csr_matrix
|
||||
|
||||
import numpy as np
|
||||
from scipy.sparse import extract
|
||||
|
||||
|
||||
class TestExtract(object):
|
||||
def setup_method(self):
|
||||
self.cases = [
|
||||
csr_matrix([[1,2]]),
|
||||
csr_matrix([[1,0]]),
|
||||
csr_matrix([[0,0]]),
|
||||
csr_matrix([[1],[2]]),
|
||||
csr_matrix([[1],[0]]),
|
||||
csr_matrix([[0],[0]]),
|
||||
csr_matrix([[1,2],[3,4]]),
|
||||
csr_matrix([[0,1],[0,0]]),
|
||||
csr_matrix([[0,0],[1,0]]),
|
||||
csr_matrix([[0,0],[0,0]]),
|
||||
csr_matrix([[1,2,0,0,3],[4,5,0,6,7],[0,0,8,9,0]]),
|
||||
csr_matrix([[1,2,0,0,3],[4,5,0,6,7],[0,0,8,9,0]]).T,
|
||||
]
|
||||
|
||||
def find(self):
|
||||
for A in self.cases:
|
||||
I,J,V = extract.find(A)
|
||||
assert_equal(A.toarray(), csr_matrix(((I,J),V), shape=A.shape))
|
||||
|
||||
def test_tril(self):
|
||||
for A in self.cases:
|
||||
B = A.toarray()
|
||||
for k in [-3,-2,-1,0,1,2,3]:
|
||||
assert_equal(extract.tril(A,k=k).toarray(), np.tril(B,k=k))
|
||||
|
||||
def test_triu(self):
|
||||
for A in self.cases:
|
||||
B = A.toarray()
|
||||
for k in [-3,-2,-1,0,1,2,3]:
|
||||
assert_equal(extract.triu(A,k=k).toarray(), np.triu(B,k=k))
|
||||
@@ -0,0 +1,93 @@
|
||||
from __future__ import division, print_function, absolute_import
|
||||
|
||||
import sys
|
||||
import os
|
||||
import numpy as np
|
||||
import tempfile
|
||||
|
||||
import pytest
|
||||
from pytest import raises as assert_raises
|
||||
from numpy.testing import assert_equal, assert_
|
||||
from scipy._lib._version import NumpyVersion
|
||||
|
||||
from scipy.sparse import (csc_matrix, csr_matrix, bsr_matrix, dia_matrix,
|
||||
coo_matrix, save_npz, load_npz, dok_matrix)
|
||||
|
||||
|
||||
DATA_DIR = os.path.join(os.path.dirname(__file__), 'data')
|
||||
|
||||
|
||||
def _save_and_load(matrix):
|
||||
fd, tmpfile = tempfile.mkstemp(suffix='.npz')
|
||||
os.close(fd)
|
||||
try:
|
||||
save_npz(tmpfile, matrix)
|
||||
loaded_matrix = load_npz(tmpfile)
|
||||
finally:
|
||||
os.remove(tmpfile)
|
||||
return loaded_matrix
|
||||
|
||||
def _check_save_and_load(dense_matrix):
|
||||
for matrix_class in [csc_matrix, csr_matrix, bsr_matrix, dia_matrix, coo_matrix]:
|
||||
matrix = matrix_class(dense_matrix)
|
||||
loaded_matrix = _save_and_load(matrix)
|
||||
assert_(type(loaded_matrix) is matrix_class)
|
||||
assert_(loaded_matrix.shape == dense_matrix.shape)
|
||||
assert_(loaded_matrix.dtype == dense_matrix.dtype)
|
||||
assert_equal(loaded_matrix.toarray(), dense_matrix)
|
||||
|
||||
def test_save_and_load_random():
|
||||
N = 10
|
||||
np.random.seed(0)
|
||||
dense_matrix = np.random.random((N, N))
|
||||
dense_matrix[dense_matrix > 0.7] = 0
|
||||
_check_save_and_load(dense_matrix)
|
||||
|
||||
def test_save_and_load_empty():
|
||||
dense_matrix = np.zeros((4,6))
|
||||
_check_save_and_load(dense_matrix)
|
||||
|
||||
def test_save_and_load_one_entry():
|
||||
dense_matrix = np.zeros((4,6))
|
||||
dense_matrix[1,2] = 1
|
||||
_check_save_and_load(dense_matrix)
|
||||
|
||||
|
||||
@pytest.mark.skipif(NumpyVersion(np.__version__) < '1.10.0',
|
||||
reason='disabling unpickling requires numpy >= 1.10.0')
|
||||
def test_malicious_load():
|
||||
class Executor(object):
|
||||
def __reduce__(self):
|
||||
return (assert_, (False, 'unexpected code execution'))
|
||||
|
||||
fd, tmpfile = tempfile.mkstemp(suffix='.npz')
|
||||
os.close(fd)
|
||||
try:
|
||||
np.savez(tmpfile, format=Executor())
|
||||
|
||||
# Should raise a ValueError, not execute code
|
||||
assert_raises(ValueError, load_npz, tmpfile)
|
||||
finally:
|
||||
os.remove(tmpfile)
|
||||
|
||||
|
||||
def test_py23_compatibility():
|
||||
# Try loading files saved on Python 2 and Python 3. They are not
|
||||
# the same, since files saved with Scipy versions < 1.0.0 may
|
||||
# contain unicode.
|
||||
|
||||
a = load_npz(os.path.join(DATA_DIR, 'csc_py2.npz'))
|
||||
b = load_npz(os.path.join(DATA_DIR, 'csc_py3.npz'))
|
||||
c = csc_matrix([[0]])
|
||||
|
||||
assert_equal(a.toarray(), c.toarray())
|
||||
assert_equal(b.toarray(), c.toarray())
|
||||
|
||||
def test_implemented_error():
|
||||
# Attempts to save an unsupported type and checks that an
|
||||
# NotImplementedError is raised.
|
||||
|
||||
x = dok_matrix((2,3))
|
||||
x[0,1] = 1
|
||||
|
||||
assert_raises(NotImplementedError, save_npz, 'x.npz', x)
|
||||
@@ -0,0 +1,328 @@
|
||||
from __future__ import division, print_function, absolute_import
|
||||
|
||||
import sys
|
||||
import os
|
||||
import gc
|
||||
import re
|
||||
import threading
|
||||
|
||||
import numpy as np
|
||||
from numpy.testing import assert_equal, assert_, assert_allclose
|
||||
from scipy.sparse import (_sparsetools, coo_matrix, csr_matrix, csc_matrix,
|
||||
bsr_matrix, dia_matrix)
|
||||
from scipy.sparse.sputils import supported_dtypes
|
||||
from scipy._lib._testutils import check_free_memory
|
||||
|
||||
import pytest
|
||||
from pytest import raises as assert_raises
|
||||
|
||||
def test_exception():
|
||||
assert_raises(MemoryError, _sparsetools.test_throw_error)
|
||||
|
||||
|
||||
def test_threads():
|
||||
# Smoke test for parallel threaded execution; doesn't actually
|
||||
# check that code runs in parallel, but just that it produces
|
||||
# expected results.
|
||||
nthreads = 10
|
||||
niter = 100
|
||||
|
||||
n = 20
|
||||
a = csr_matrix(np.ones([n, n]))
|
||||
bres = []
|
||||
|
||||
class Worker(threading.Thread):
|
||||
def run(self):
|
||||
b = a.copy()
|
||||
for j in range(niter):
|
||||
_sparsetools.csr_plus_csr(n, n,
|
||||
a.indptr, a.indices, a.data,
|
||||
a.indptr, a.indices, a.data,
|
||||
b.indptr, b.indices, b.data)
|
||||
bres.append(b)
|
||||
|
||||
threads = [Worker() for _ in range(nthreads)]
|
||||
for thread in threads:
|
||||
thread.start()
|
||||
for thread in threads:
|
||||
thread.join()
|
||||
|
||||
for b in bres:
|
||||
assert_(np.all(b.toarray() == 2))
|
||||
|
||||
|
||||
def test_regression_std_vector_dtypes():
|
||||
# Regression test for gh-3780, checking the std::vector typemaps
|
||||
# in sparsetools.cxx are complete.
|
||||
for dtype in supported_dtypes:
|
||||
ad = np.matrix([[1, 2], [3, 4]]).astype(dtype)
|
||||
a = csr_matrix(ad, dtype=dtype)
|
||||
|
||||
# getcol is one function using std::vector typemaps, and should not fail
|
||||
assert_equal(a.getcol(0).todense(), ad[:,0])
|
||||
|
||||
|
||||
@pytest.mark.slow
|
||||
def test_nnz_overflow():
|
||||
# Regression test for gh-7230 / gh-7871, checking that coo_todense
|
||||
# with nnz > int32max doesn't overflow.
|
||||
nnz = np.iinfo(np.int32).max + 1
|
||||
# Ensure ~20 GB of RAM is free to run this test.
|
||||
check_free_memory((4 + 4 + 1) * nnz / 1e6 + 0.5)
|
||||
|
||||
# Use nnz duplicate entries to keep the dense version small.
|
||||
row = np.zeros(nnz, dtype=np.int32)
|
||||
col = np.zeros(nnz, dtype=np.int32)
|
||||
data = np.zeros(nnz, dtype=np.int8)
|
||||
data[-1] = 4
|
||||
s = coo_matrix((data, (row, col)), shape=(1, 1), copy=False)
|
||||
# Sums nnz duplicates to produce a 1x1 array containing 4.
|
||||
d = s.toarray()
|
||||
|
||||
assert_allclose(d, [[4]])
|
||||
|
||||
|
||||
@pytest.mark.skipif(not (sys.platform.startswith('linux') and np.dtype(np.intp).itemsize >= 8),
|
||||
reason="test requires 64-bit Linux")
|
||||
class TestInt32Overflow(object):
|
||||
"""
|
||||
Some of the sparsetools routines use dense 2D matrices whose
|
||||
total size is not bounded by the nnz of the sparse matrix. These
|
||||
routines used to suffer from int32 wraparounds; here, we try to
|
||||
check that the wraparounds don't occur any more.
|
||||
"""
|
||||
# choose n large enough
|
||||
n = 50000
|
||||
|
||||
def setup_method(self):
|
||||
assert self.n**2 > np.iinfo(np.int32).max
|
||||
|
||||
# check there's enough memory even if everything is run at the
|
||||
# same time
|
||||
try:
|
||||
parallel_count = int(os.environ.get('PYTEST_XDIST_WORKER_COUNT', '1'))
|
||||
except ValueError:
|
||||
parallel_count = np.inf
|
||||
|
||||
check_free_memory(3000 * parallel_count)
|
||||
|
||||
def teardown_method(self):
|
||||
gc.collect()
|
||||
|
||||
def test_coo_todense(self):
|
||||
# Check *_todense routines (cf. gh-2179)
|
||||
#
|
||||
# All of them in the end call coo_matrix.todense
|
||||
|
||||
n = self.n
|
||||
|
||||
i = np.array([0, n-1])
|
||||
j = np.array([0, n-1])
|
||||
data = np.array([1, 2], dtype=np.int8)
|
||||
m = coo_matrix((data, (i, j)))
|
||||
|
||||
r = m.todense()
|
||||
assert_equal(r[0,0], 1)
|
||||
assert_equal(r[-1,-1], 2)
|
||||
del r
|
||||
gc.collect()
|
||||
|
||||
@pytest.mark.slow
|
||||
def test_matvecs(self):
|
||||
# Check *_matvecs routines
|
||||
n = self.n
|
||||
|
||||
i = np.array([0, n-1])
|
||||
j = np.array([0, n-1])
|
||||
data = np.array([1, 2], dtype=np.int8)
|
||||
m = coo_matrix((data, (i, j)))
|
||||
|
||||
b = np.ones((n, n), dtype=np.int8)
|
||||
for sptype in (csr_matrix, csc_matrix, bsr_matrix):
|
||||
m2 = sptype(m)
|
||||
r = m2.dot(b)
|
||||
assert_equal(r[0,0], 1)
|
||||
assert_equal(r[-1,-1], 2)
|
||||
del r
|
||||
gc.collect()
|
||||
|
||||
del b
|
||||
gc.collect()
|
||||
|
||||
@pytest.mark.slow
|
||||
def test_dia_matvec(self):
|
||||
# Check: huge dia_matrix _matvec
|
||||
n = self.n
|
||||
data = np.ones((n, n), dtype=np.int8)
|
||||
offsets = np.arange(n)
|
||||
m = dia_matrix((data, offsets), shape=(n, n))
|
||||
v = np.ones(m.shape[1], dtype=np.int8)
|
||||
r = m.dot(v)
|
||||
assert_equal(r[0], np.int8(n))
|
||||
del data, offsets, m, v, r
|
||||
gc.collect()
|
||||
|
||||
_bsr_ops = [pytest.param("matmat", marks=pytest.mark.xslow),
|
||||
pytest.param("matvecs", marks=pytest.mark.xslow),
|
||||
"matvec",
|
||||
"diagonal",
|
||||
"sort_indices",
|
||||
pytest.param("transpose", marks=pytest.mark.xslow)]
|
||||
|
||||
@pytest.mark.slow
|
||||
@pytest.mark.parametrize("op", _bsr_ops)
|
||||
def test_bsr_1_block(self, op):
|
||||
# Check: huge bsr_matrix (1-block)
|
||||
#
|
||||
# The point here is that indices inside a block may overflow.
|
||||
|
||||
def get_matrix():
|
||||
n = self.n
|
||||
data = np.ones((1, n, n), dtype=np.int8)
|
||||
indptr = np.array([0, 1], dtype=np.int32)
|
||||
indices = np.array([0], dtype=np.int32)
|
||||
m = bsr_matrix((data, indices, indptr), blocksize=(n, n), copy=False)
|
||||
del data, indptr, indices
|
||||
return m
|
||||
|
||||
gc.collect()
|
||||
try:
|
||||
getattr(self, "_check_bsr_" + op)(get_matrix)
|
||||
finally:
|
||||
gc.collect()
|
||||
|
||||
@pytest.mark.slow
|
||||
@pytest.mark.parametrize("op", _bsr_ops)
|
||||
def test_bsr_n_block(self, op):
|
||||
# Check: huge bsr_matrix (n-block)
|
||||
#
|
||||
# The point here is that while indices within a block don't
|
||||
# overflow, accumulators across many block may.
|
||||
|
||||
def get_matrix():
|
||||
n = self.n
|
||||
data = np.ones((n, n, 1), dtype=np.int8)
|
||||
indptr = np.array([0, n], dtype=np.int32)
|
||||
indices = np.arange(n, dtype=np.int32)
|
||||
m = bsr_matrix((data, indices, indptr), blocksize=(n, 1), copy=False)
|
||||
del data, indptr, indices
|
||||
return m
|
||||
|
||||
gc.collect()
|
||||
try:
|
||||
getattr(self, "_check_bsr_" + op)(get_matrix)
|
||||
finally:
|
||||
gc.collect()
|
||||
|
||||
def _check_bsr_matvecs(self, m):
|
||||
m = m()
|
||||
n = self.n
|
||||
|
||||
# _matvecs
|
||||
r = m.dot(np.ones((n, 2), dtype=np.int8))
|
||||
assert_equal(r[0,0], np.int8(n))
|
||||
|
||||
def _check_bsr_matvec(self, m):
|
||||
m = m()
|
||||
n = self.n
|
||||
|
||||
# _matvec
|
||||
r = m.dot(np.ones((n,), dtype=np.int8))
|
||||
assert_equal(r[0], np.int8(n))
|
||||
|
||||
def _check_bsr_diagonal(self, m):
|
||||
m = m()
|
||||
n = self.n
|
||||
|
||||
# _diagonal
|
||||
r = m.diagonal()
|
||||
assert_equal(r, np.ones(n))
|
||||
|
||||
def _check_bsr_sort_indices(self, m):
|
||||
# _sort_indices
|
||||
m = m()
|
||||
m.sort_indices()
|
||||
|
||||
def _check_bsr_transpose(self, m):
|
||||
# _transpose
|
||||
m = m()
|
||||
m.transpose()
|
||||
|
||||
def _check_bsr_matmat(self, m):
|
||||
m = m()
|
||||
n = self.n
|
||||
|
||||
# _bsr_matmat
|
||||
m2 = bsr_matrix(np.ones((n, 2), dtype=np.int8), blocksize=(m.blocksize[1], 2))
|
||||
m.dot(m2) # shouldn't SIGSEGV
|
||||
del m2
|
||||
|
||||
# _bsr_matmat
|
||||
m2 = bsr_matrix(np.ones((2, n), dtype=np.int8), blocksize=(2, m.blocksize[0]))
|
||||
m2.dot(m) # shouldn't SIGSEGV
|
||||
|
||||
|
||||
@pytest.mark.skip(reason="64-bit indices in sparse matrices not available")
|
||||
def test_csr_matmat_int64_overflow():
|
||||
n = 3037000500
|
||||
assert n**2 > np.iinfo(np.int64).max
|
||||
|
||||
# the test would take crazy amounts of memory
|
||||
check_free_memory(n * (8*2 + 1) * 3 / 1e6)
|
||||
|
||||
# int64 overflow
|
||||
data = np.ones((n,), dtype=np.int8)
|
||||
indptr = np.arange(n+1, dtype=np.int64)
|
||||
indices = np.zeros(n, dtype=np.int64)
|
||||
a = csr_matrix((data, indices, indptr))
|
||||
b = a.T
|
||||
|
||||
assert_raises(RuntimeError, a.dot, b)
|
||||
|
||||
|
||||
def test_upcast():
|
||||
a0 = csr_matrix([[np.pi, np.pi*1j], [3, 4]], dtype=complex)
|
||||
b0 = np.array([256+1j, 2**32], dtype=complex)
|
||||
|
||||
for a_dtype in supported_dtypes:
|
||||
for b_dtype in supported_dtypes:
|
||||
msg = "(%r, %r)" % (a_dtype, b_dtype)
|
||||
|
||||
if np.issubdtype(a_dtype, np.complexfloating):
|
||||
a = a0.copy().astype(a_dtype)
|
||||
else:
|
||||
a = a0.real.copy().astype(a_dtype)
|
||||
|
||||
if np.issubdtype(b_dtype, np.complexfloating):
|
||||
b = b0.copy().astype(b_dtype)
|
||||
else:
|
||||
b = b0.real.copy().astype(b_dtype)
|
||||
|
||||
if not (a_dtype == np.bool_ and b_dtype == np.bool_):
|
||||
c = np.zeros((2,), dtype=np.bool_)
|
||||
assert_raises(ValueError, _sparsetools.csr_matvec,
|
||||
2, 2, a.indptr, a.indices, a.data, b, c)
|
||||
|
||||
if ((np.issubdtype(a_dtype, np.complexfloating) and
|
||||
not np.issubdtype(b_dtype, np.complexfloating)) or
|
||||
(not np.issubdtype(a_dtype, np.complexfloating) and
|
||||
np.issubdtype(b_dtype, np.complexfloating))):
|
||||
c = np.zeros((2,), dtype=np.float64)
|
||||
assert_raises(ValueError, _sparsetools.csr_matvec,
|
||||
2, 2, a.indptr, a.indices, a.data, b, c)
|
||||
|
||||
c = np.zeros((2,), dtype=np.result_type(a_dtype, b_dtype))
|
||||
_sparsetools.csr_matvec(2, 2, a.indptr, a.indices, a.data, b, c)
|
||||
assert_allclose(c, np.dot(a.toarray(), b), err_msg=msg)
|
||||
|
||||
|
||||
def test_endianness():
|
||||
d = np.ones((3,4))
|
||||
offsets = [-1,0,1]
|
||||
|
||||
a = dia_matrix((d.astype('<f8'), offsets), (4, 4))
|
||||
b = dia_matrix((d.astype('>f8'), offsets), (4, 4))
|
||||
v = np.arange(4)
|
||||
|
||||
assert_allclose(a.dot(v), [1, 3, 6, 5])
|
||||
assert_allclose(b.dot(v), [1, 3, 6, 5])
|
||||
@@ -0,0 +1,99 @@
|
||||
from __future__ import division, print_function, absolute_import
|
||||
|
||||
from numpy import array, kron, matrix, diag
|
||||
from numpy.testing import assert_, assert_equal
|
||||
|
||||
from scipy.sparse import spfuncs
|
||||
from scipy.sparse import csr_matrix, csc_matrix, bsr_matrix
|
||||
from scipy.sparse._sparsetools import (csr_scale_rows, csr_scale_columns,
|
||||
bsr_scale_rows, bsr_scale_columns)
|
||||
|
||||
|
||||
class TestSparseFunctions(object):
|
||||
def test_scale_rows_and_cols(self):
|
||||
D = matrix([[1,0,0,2,3],
|
||||
[0,4,0,5,0],
|
||||
[0,0,6,7,0]])
|
||||
|
||||
#TODO expose through function
|
||||
S = csr_matrix(D)
|
||||
v = array([1,2,3])
|
||||
csr_scale_rows(3,5,S.indptr,S.indices,S.data,v)
|
||||
assert_equal(S.todense(), diag(v)*D)
|
||||
|
||||
S = csr_matrix(D)
|
||||
v = array([1,2,3,4,5])
|
||||
csr_scale_columns(3,5,S.indptr,S.indices,S.data,v)
|
||||
assert_equal(S.todense(), D*diag(v))
|
||||
|
||||
# blocks
|
||||
E = kron(D,[[1,2],[3,4]])
|
||||
S = bsr_matrix(E,blocksize=(2,2))
|
||||
v = array([1,2,3,4,5,6])
|
||||
bsr_scale_rows(3,5,2,2,S.indptr,S.indices,S.data,v)
|
||||
assert_equal(S.todense(), diag(v)*E)
|
||||
|
||||
S = bsr_matrix(E,blocksize=(2,2))
|
||||
v = array([1,2,3,4,5,6,7,8,9,10])
|
||||
bsr_scale_columns(3,5,2,2,S.indptr,S.indices,S.data,v)
|
||||
assert_equal(S.todense(), E*diag(v))
|
||||
|
||||
E = kron(D,[[1,2,3],[4,5,6]])
|
||||
S = bsr_matrix(E,blocksize=(2,3))
|
||||
v = array([1,2,3,4,5,6])
|
||||
bsr_scale_rows(3,5,2,3,S.indptr,S.indices,S.data,v)
|
||||
assert_equal(S.todense(), diag(v)*E)
|
||||
|
||||
S = bsr_matrix(E,blocksize=(2,3))
|
||||
v = array([1,2,3,4,5,6,7,8,9,10,11,12,13,14,15])
|
||||
bsr_scale_columns(3,5,2,3,S.indptr,S.indices,S.data,v)
|
||||
assert_equal(S.todense(), E*diag(v))
|
||||
|
||||
def test_estimate_blocksize(self):
|
||||
mats = []
|
||||
mats.append([[0,1],[1,0]])
|
||||
mats.append([[1,1,0],[0,0,1],[1,0,1]])
|
||||
mats.append([[0],[0],[1]])
|
||||
mats = [array(x) for x in mats]
|
||||
|
||||
blks = []
|
||||
blks.append([[1]])
|
||||
blks.append([[1,1],[1,1]])
|
||||
blks.append([[1,1],[0,1]])
|
||||
blks.append([[1,1,0],[1,0,1],[1,1,1]])
|
||||
blks = [array(x) for x in blks]
|
||||
|
||||
for A in mats:
|
||||
for B in blks:
|
||||
X = kron(A,B)
|
||||
r,c = spfuncs.estimate_blocksize(X)
|
||||
assert_(r >= B.shape[0])
|
||||
assert_(c >= B.shape[1])
|
||||
|
||||
def test_count_blocks(self):
|
||||
def gold(A,bs):
|
||||
R,C = bs
|
||||
I,J = A.nonzero()
|
||||
return len(set(zip(I//R,J//C)))
|
||||
|
||||
mats = []
|
||||
mats.append([[0]])
|
||||
mats.append([[1]])
|
||||
mats.append([[1,0]])
|
||||
mats.append([[1,1]])
|
||||
mats.append([[0,1],[1,0]])
|
||||
mats.append([[1,1,0],[0,0,1],[1,0,1]])
|
||||
mats.append([[0],[0],[1]])
|
||||
|
||||
for A in mats:
|
||||
for B in mats:
|
||||
X = kron(A,B)
|
||||
Y = csr_matrix(X)
|
||||
for R in range(1,6):
|
||||
for C in range(1,6):
|
||||
assert_equal(spfuncs.count_blocks(Y, (R, C)), gold(X, (R, C)))
|
||||
|
||||
X = kron([[1,1,0],[0,0,1],[1,0,1]],[[1,1]])
|
||||
Y = csc_matrix(X)
|
||||
assert_equal(spfuncs.count_blocks(X, (1, 2)), gold(X, (1, 2)))
|
||||
assert_equal(spfuncs.count_blocks(Y, (1, 2)), gold(X, (1, 2)))
|
||||
@@ -0,0 +1,153 @@
|
||||
"""unit tests for sparse utility functions"""
|
||||
|
||||
from __future__ import division, print_function, absolute_import
|
||||
|
||||
import numpy as np
|
||||
from numpy.testing import assert_equal, assert_raises
|
||||
from pytest import raises as assert_raises
|
||||
from scipy.sparse import sputils
|
||||
from scipy._lib._numpy_compat import suppress_warnings
|
||||
|
||||
|
||||
class TestSparseUtils(object):
|
||||
|
||||
def test_upcast(self):
|
||||
assert_equal(sputils.upcast('intc'), np.intc)
|
||||
assert_equal(sputils.upcast('int32', 'float32'), np.float64)
|
||||
assert_equal(sputils.upcast('bool', complex, float), np.complex128)
|
||||
assert_equal(sputils.upcast('i', 'd'), np.float64)
|
||||
|
||||
def test_getdtype(self):
|
||||
A = np.array([1], dtype='int8')
|
||||
|
||||
assert_equal(sputils.getdtype(None, default=float), float)
|
||||
assert_equal(sputils.getdtype(None, a=A), np.int8)
|
||||
|
||||
def test_isscalarlike(self):
|
||||
assert_equal(sputils.isscalarlike(3.0), True)
|
||||
assert_equal(sputils.isscalarlike(-4), True)
|
||||
assert_equal(sputils.isscalarlike(2.5), True)
|
||||
assert_equal(sputils.isscalarlike(1 + 3j), True)
|
||||
assert_equal(sputils.isscalarlike(np.array(3)), True)
|
||||
assert_equal(sputils.isscalarlike("16"), True)
|
||||
|
||||
assert_equal(sputils.isscalarlike(np.array([3])), False)
|
||||
assert_equal(sputils.isscalarlike([[3]]), False)
|
||||
assert_equal(sputils.isscalarlike((1,)), False)
|
||||
assert_equal(sputils.isscalarlike((1, 2)), False)
|
||||
|
||||
def test_isintlike(self):
|
||||
assert_equal(sputils.isintlike(-4), True)
|
||||
assert_equal(sputils.isintlike(np.array(3)), True)
|
||||
assert_equal(sputils.isintlike(np.array([3])), False)
|
||||
with suppress_warnings() as sup:
|
||||
sup.filter(DeprecationWarning,
|
||||
"Inexact indices into sparse matrices are deprecated")
|
||||
assert_equal(sputils.isintlike(3.0), True)
|
||||
|
||||
assert_equal(sputils.isintlike(2.5), False)
|
||||
assert_equal(sputils.isintlike(1 + 3j), False)
|
||||
assert_equal(sputils.isintlike((1,)), False)
|
||||
assert_equal(sputils.isintlike((1, 2)), False)
|
||||
|
||||
def test_isshape(self):
|
||||
assert_equal(sputils.isshape((1, 2)), True)
|
||||
assert_equal(sputils.isshape((5, 2)), True)
|
||||
|
||||
assert_equal(sputils.isshape((1.5, 2)), False)
|
||||
assert_equal(sputils.isshape((2, 2, 2)), False)
|
||||
assert_equal(sputils.isshape(([2], 2)), False)
|
||||
assert_equal(sputils.isshape((-1, 2), nonneg=False),True)
|
||||
assert_equal(sputils.isshape((2, -1), nonneg=False),True)
|
||||
assert_equal(sputils.isshape((-1, 2), nonneg=True),False)
|
||||
assert_equal(sputils.isshape((2, -1), nonneg=True),False)
|
||||
|
||||
def test_issequence(self):
|
||||
assert_equal(sputils.issequence((1,)), True)
|
||||
assert_equal(sputils.issequence((1, 2, 3)), True)
|
||||
assert_equal(sputils.issequence([1]), True)
|
||||
assert_equal(sputils.issequence([1, 2, 3]), True)
|
||||
assert_equal(sputils.issequence(np.array([1, 2, 3])), True)
|
||||
|
||||
assert_equal(sputils.issequence(np.array([[1], [2], [3]])), False)
|
||||
assert_equal(sputils.issequence(3), False)
|
||||
|
||||
def test_ismatrix(self):
|
||||
assert_equal(sputils.ismatrix(((),)), True)
|
||||
assert_equal(sputils.ismatrix([[1], [2]]), True)
|
||||
assert_equal(sputils.ismatrix(np.arange(3)[None]), True)
|
||||
|
||||
assert_equal(sputils.ismatrix([1, 2]), False)
|
||||
assert_equal(sputils.ismatrix(np.arange(3)), False)
|
||||
assert_equal(sputils.ismatrix([[[1]]]), False)
|
||||
assert_equal(sputils.ismatrix(3), False)
|
||||
|
||||
def test_isdense(self):
|
||||
assert_equal(sputils.isdense(np.array([1])), True)
|
||||
assert_equal(sputils.isdense(np.matrix([1])), True)
|
||||
|
||||
def test_validateaxis(self):
|
||||
assert_raises(TypeError, sputils.validateaxis, (0, 1))
|
||||
assert_raises(TypeError, sputils.validateaxis, 1.5)
|
||||
assert_raises(ValueError, sputils.validateaxis, 3)
|
||||
|
||||
# These function calls should not raise errors
|
||||
for axis in (-2, -1, 0, 1, None):
|
||||
sputils.validateaxis(axis)
|
||||
|
||||
def test_get_index_dtype(self):
|
||||
imax = np.iinfo(np.int32).max
|
||||
too_big = imax + 1
|
||||
|
||||
# Check that uint32's with no values too large doesn't return
|
||||
# int64
|
||||
a1 = np.ones(90, dtype='uint32')
|
||||
a2 = np.ones(90, dtype='uint32')
|
||||
assert_equal(
|
||||
np.dtype(sputils.get_index_dtype((a1, a2), check_contents=True)),
|
||||
np.dtype('int32')
|
||||
)
|
||||
|
||||
# Check that if we can not convert but all values are less than or
|
||||
# equal to max that we can just convert to int32
|
||||
a1[-1] = imax
|
||||
assert_equal(
|
||||
np.dtype(sputils.get_index_dtype((a1, a2), check_contents=True)),
|
||||
np.dtype('int32')
|
||||
)
|
||||
|
||||
# Check that if it can not convert directly and the contents are
|
||||
# too large that we return int64
|
||||
a1[-1] = too_big
|
||||
assert_equal(
|
||||
np.dtype(sputils.get_index_dtype((a1, a2), check_contents=True)),
|
||||
np.dtype('int64')
|
||||
)
|
||||
|
||||
# test that if can not convert and didn't specify to check_contents
|
||||
# we return int64
|
||||
a1 = np.ones(89, dtype='uint32')
|
||||
a2 = np.ones(89, dtype='uint32')
|
||||
assert_equal(
|
||||
np.dtype(sputils.get_index_dtype((a1, a2))),
|
||||
np.dtype('int64')
|
||||
)
|
||||
|
||||
# Check that even if we have arrays that can be converted directly
|
||||
# that if we specify a maxval directly it takes precedence
|
||||
a1 = np.ones(12, dtype='uint32')
|
||||
a2 = np.ones(12, dtype='uint32')
|
||||
assert_equal(
|
||||
np.dtype(sputils.get_index_dtype(
|
||||
(a1, a2), maxval=too_big, check_contents=True
|
||||
)),
|
||||
np.dtype('int64')
|
||||
)
|
||||
|
||||
# Check that an array with a too max size and maxval set
|
||||
# still returns int64
|
||||
a1[-1] = too_big
|
||||
assert_equal(
|
||||
np.dtype(sputils.get_index_dtype((a1, a2), maxval=too_big)),
|
||||
np.dtype('int64')
|
||||
)
|
||||
Reference in New Issue
Block a user