# quimb.linalg.rand_linalg¶

Randomized iterative methods for decompositions.

## Attributes¶

 `njit` Numba no-python jit, but obeying cache setting.

## Functions¶

 `randn`([shape, dtype, scale, loc, num_threads, seed, dist]) Fast multithreaded generation of random normally distributed data. `dag`(qob) Conjugate transpose. `dot`(a, b) Matrix multiplication, dispatched to dense or sparse functions. `orthog`(X[, lu]) `QB_to_svd`(Q, B[, compute_uv]) `trim`(arrays, k) `possibly_extend_randn`(G, k, p, A) `isstring`(x, s) `rsvd_qb`(A, k, q, p, state[, AH]) `rsvd_core`(A, k[, compute_uv, q, p, state, AH]) Core R3SVD algorithm. `gen_k_steps`(start[, incr]) `rsvd_iterate`(A, eps[, compute_uv, q, p, G0, k_max, ...]) Handle rank-adaptively calling `rsvd_core`. `count_svdvals_needed`(s, eps) `isdouble`(dtype) Check if `dtype` is double precision. `estimate_rank`(A, eps[, k_max, use_sli, k_start, ...]) Estimate the rank of an linear operator. Uses a low quality random `maybe_flip`(UsV, flipped) `rsvd`(A, eps_or_k[, compute_uv, mode, use_qb, q, p, ...]) Fast, randomized, iterative SVD. Adaptive variant of method due

## Module Contents¶

quimb.linalg.rand_linalg.randn(shape=(), dtype=float, scale=1.0, loc=0.0, num_threads=None, seed=None, dist='normal')[source]

Fast multithreaded generation of random normally distributed data.

Parameters:
• shape (tuple[int]) – The shape of the output random array.

• dtype ({'complex128', 'float64', 'complex64' 'float32'}, optional) – The data-type of the output array.

• scale (float, optional) – A multiplicative scale for the random numbers.

• loc (float, optional) – An additive location for the random numbers.

• num_threads (int, optional) – How many threads to use. If `None`, decide automatically.

• dist ({'normal', 'uniform', 'rademacher', 'exp'}, optional) – Type of random number to generate.

quimb.linalg.rand_linalg.dag(qob)[source]

Conjugate transpose.

quimb.linalg.rand_linalg.dot(a, b)[source]

Matrix multiplication, dispatched to dense or sparse functions.

Parameters:
• a (dense or sparse operator) – First array.

• b (dense or sparse operator) – Second array.

Returns:

Dot product of `a` and `b`.

Return type:

dense or sparse operator

quimb.linalg.rand_linalg.njit

Numba no-python jit, but obeying cache setting.

quimb.linalg.rand_linalg.lu_orthog(X)[source]
quimb.linalg.rand_linalg.qr_orthog(X)[source]
quimb.linalg.rand_linalg.orthog(X, lu=False)[source]
quimb.linalg.rand_linalg.QB_to_svd(Q, B, compute_uv=True)[source]
quimb.linalg.rand_linalg.trim(arrays, k)[source]
quimb.linalg.rand_linalg.possibly_extend_randn(G, k, p, A)[source]
quimb.linalg.rand_linalg.isstring(x, s)[source]
quimb.linalg.rand_linalg.rsvd_qb(A, k, q, p, state, AH=None)[source]
quimb.linalg.rand_linalg.rsvd_core(A, k, compute_uv=True, q=2, p=0, state=None, AH=None)[source]

Core R3SVD algorithm.

Parameters:
• A (linear operator, shape (m, n)) – Operator to decompose, assumed m >= n.

• k (int) – Number of singular values to find.

• compute_uv (bool, optional) – Return the left and right singular vectors.

• q (int, optional) – Number of power iterations.

• p (int, optional) – Over sampling factor.

• state ({None, array_like, (), (G0,), (U0, s0, VH0, G0)}, optional) –

Iterate based on these previous results:

• None: basic mode.

• array_like: use this as the initial subspace.

• ’begin-svd’: begin block iterations, return U, s, VH, G

• (G0,) : begin block iterations with this subspace

• (U0, s0, VH0, G0): continue block iterations, return G

quimb.linalg.rand_linalg.is_sorted(x)[source]
quimb.linalg.rand_linalg.gen_k_steps(start, incr=1.4)[source]
quimb.linalg.rand_linalg.rsvd_iterate(A, eps, compute_uv=True, q=2, p=0, G0=None, k_max=None, k_start=2, k_incr=1.4, AH=None, use_qb=20)[source]

Handle rank-adaptively calling `rsvd_core`.

quimb.linalg.rand_linalg.count_svdvals_needed(s, eps)[source]
quimb.linalg.rand_linalg.isdouble(dtype)[source]

Check if `dtype` is double precision.

quimb.linalg.rand_linalg.estimate_rank(A, eps, k_max=None, use_sli=True, k_start=2, k_incr=1.4, q=0, p=0, get_vectors=False, G0=None, AH=None, use_qb=20)[source]

Estimate the rank of an linear operator. Uses a low quality random SVD with a resolution of ~ 10.

Parameters:
• A (linear operator) – The operator to find rank of.

• eps (float) – Find rank to this relative (compared to largest singular value) precision.

• k_max (int, optional) – The maximum rank to find.

• use_sli (bool, optional) – Whether to use `scipy.linalg.interpolative.estimate_rank()` if possible (double precision and no `k_max` set).

• k_start (int, optional) – Begin the adaptive SVD with a block of this size.

• k_incr (float, optional) – Adaptive rank increment factor. Increase the k-step (from k_start) by this factor each time. Set to 1 to use a constant step.

• q (int, optional) – Number of power iterations.

• get_vectors (bool, optional) – Return the right singular vectors found in the pass.

• G0 (, optional)

Returns:

• rank (int) – The rank.

• VH (array) – The (adjoint) right singular vectors if `get_vectors=True`.

quimb.linalg.rand_linalg.maybe_flip(UsV, flipped)[source]
quimb.linalg.rand_linalg.rsvd(A, eps_or_k, compute_uv=True, mode='adapt+block', use_qb=20, q=2, p=0, k_max=None, k_start=2, k_incr=1.4, G0=None, AH=None)[source]

Fast, randomized, iterative SVD. Adaptive variant of method due originally to Halko. This scales as `log(k)` rather than `k` so can be more efficient.

Parameters:
• A (operator, shape (m, n)) – The operator to decompose.

• eps_or_k (float or int) – Either the relative precision or the number of singular values to target. If precision, this is relative to the largest singular value.

• compute_uv (bool, optional) – Whether to return the left and right singular vectors.

How to perform the randomized SVD. If `eps_or_k` is an integer then this is implicitly ‘block’ and ignored. Else:

• ’adapt+block’, perform an initial low quality pass to estimate the rank of `A`, then use the subspace and rank from that to perform an accurate fully blocked RSVD.

• q (int, optional) – The number of power iterations, increase for accuracy at the expense of runtime.

• p (int, optional) – Oversampling factor. Perform projections with this many extra columns and then throw then away.

• k_max (int, optional) – Maximum adaptive rank. Default: `min(A.shape)`.

• k_start (int, optional) – Initial k when increasing rank adaptively.

• k_incr (float, optional) – Adaptive rank increment factor. Increase the k-step (from k_start) by this factor each time. Set to 1 to use a constant step.

• G0 (array_like, shape (n, k), optional) – Initial subspace to start iterating on. If not given a random one will be generated.

Returns:

• U, array, shape (m, k) – Left singular vectors, if `compute_uv=True`.

• s, array, shape (k,) – Singular values.

• V, array, shape (k, n) – Right singular vectors, if `compute_uv=True`.