freealg 0.1.15__tar.gz → 0.3.0__tar.gz

{freealg-0.1.15 → freealg-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: freealg
-Version: 0.1.15
+Version: 0.3.0
 Summary: Free probability for large matrices
 Keywords: leaderboard bot chat
 Platform: Linux

{freealg-0.1.15 → freealg-0.3.0}/freealg/__init__.py

@@ -7,9 +7,10 @@
 # directory of this source tree.
 
 from .freeform import FreeForm
-from .eigfree import eigfree, condfree
+from .eigh import eigh, cond, norm, trace, slogdet
 from . import distributions
 
-__all__ = ['FreeForm', 'distributions', 'eigfree', 'condfree']
+__all__ = ['FreeForm', 'distributions', 'eigh', 'cond', 'norm', 'trace',
+           'slogdet']
 
 from .__version__ import __version__                          # noqa: F401 E402

freealg-0.3.0/freealg/__version__.py

@@ -0,0 +1 @@
+__version__ = "0.3.0"

{freealg-0.1.15 → freealg-0.3.0}/freealg/_decompress.py

@@ -12,6 +12,10 @@
 
 import numpy
 
+# Fallback to previous API
+if not hasattr(numpy, 'trapezoid'):
+    numpy.trapezoid = numpy.trapz
+
 __all__ = ['decompress', 'reverse_characteristics']
 
 
@@ -19,7 +23,6 @@ __all__ = ['decompress', 'reverse_characteristics']
 # secant method
 # =============
 
-
 def secant_complex(f, z0, z1, a=0+0j, tol=1e-12, max_iter=100,
                    alpha=0.5, max_bt=1, eps=1e-30, step_factor=5.0,
                    post_smooth=True, jump_tol=10.0, verbose=False):
@@ -200,7 +203,6 @@ def secant_complex(f, z0, z1, a=0+0j, tol=1e-12, max_iter=100,
 # decompress
 # ==========
 
-
 def decompress(freeform, size, x=None, delta=1e-4, max_iter=500,
                tolerance=1e-8):
     """
@@ -287,9 +289,9 @@ def decompress(freeform, size, x=None, delta=1e-4, max_iter=500,
     def _char_z(z):
         return z + (1 / m(z)) * (1 - alpha)
 
-    z0 = numpy.full(target.shape, numpy.mean(freeform.support) + .1j,
+    z0 = numpy.full(target.shape, numpy.mean(freeform.support) + 0.1j,
                     dtype=numpy.complex128)
-    z1 = z0 - .2j
+    z1 = z0 - 0.2j
 
     roots, _, _ = secant_complex(
         _char_z, z0, z1,

{freealg-0.1.15 → freealg-0.3.0}/freealg/_pade.py

@@ -299,7 +299,6 @@ def wynn_pade(coeffs, x):
 # fit pade
 # ========
 
-
 def fit_pade(x, f, lam_m, lam_p, p=1, q=2, odd_side='left', pade_reg=0.0,
              safety=1.0, max_outer=40, xtol=1e-12, ftol=1e-12, optimizer='ls',
              verbose=0):

{freealg-0.1.15 → freealg-0.3.0}/freealg/_support.py

@@ -14,6 +14,12 @@ import numpy
 import numba
 from scipy.stats import gaussian_kde
 
+__all__ = ['support_from_density', 'detect_support']
+
+
+# ====================
+# support from density
+# ====================
 
 @numba.njit(numba.types.UniTuple(numba.types.int64, 2)(
     numba.types.float64,
@@ -24,6 +30,7 @@ def support_from_density(dx, density):
     Estimates the support from a collection of noisy observations of a
     density over a grid of x-values with mesh spacing dx.
     """
+
     n = density.shape[0]
     target = 1.0 / dx
 
@@ -92,6 +99,10 @@ def support_from_density(dx, density):
     return optimal_i, optimal_j
 
 
+# ==============
+# detect support
+# ==============
+
 def detect_support(eigs, method='asymp', k=None, p=0.001, **kwargs):
     """
     Estimates the support of the eigenvalue density.

{freealg-0.1.15 → freealg-0.3.0}/freealg/_util.py

@@ -16,6 +16,10 @@ import scipy
 from scipy.stats import beta
 from scipy.optimize import minimize
 
+# Fallback to previous API
+if not hasattr(numpy, 'trapezoid'):
+    numpy.trapezoid = numpy.trapz
+
 __all__ = ['compute_eig', 'beta_kde', 'force_density']
 
 

freealg-0.3.0/freealg/eigh.py

@@ -0,0 +1,426 @@
+# SPDX-License-Identifier: BSD-3-Clause
+# SPDX-FileType: SOURCE
+#
+# This program is free software: you can redistribute it and/or modify it under
+# the terms of the license found in the LICENSE.txt file in the root directory
+# of this source tree.
+
+
+# =======
+# Imports
+# =======
+
+import numpy
+from ._util import compute_eig
+from .freeform import FreeForm
+
+__all__ = ['eigh', 'cond', 'norm', 'trace', 'slogdet']
+
+
+# ====
+# eigh
+# ====
+
+def eigh(A, N=None, psd=None, plots=False):
+    """
+    Estimate the eigenvalues of a matrix.
+
+    This function estimates the eigenvalues of the matrix :math:`\\mathbf{A}`
+    or a larger matrix containing :math:`\\mathbf{A}` using free decompression.
+
+    Parameters
+    ----------
+
+    A : numpy.ndarray
+        The symmetric real-valued matrix :math:`\\mathbf{A}` whose eigenvalues
+        (or those of a matrix containing :math:`\\mathbf{A}`) are to be
+        computed.
+
+    N : int, default=None
+        The size of the matrix containing :math:`\\mathbf{A}` to estimate
+        eigenvalues of. If None, returns estimates of the eigenvalues of
+        :math:`\\mathbf{A}` itself.
+
+    psd : bool, default=None
+        Determines whether the matrix is positive-semidefinite (PSD; all
+        eigenvalues are non-negative). If `None`, the matrix is considered PSD
+        if all sampled eigenvalues are positive.
+
+    plots : bool, default=False
+        Print out all relevant plots for diagnosing eigenvalue accuracy.
+
+    Returns
+    -------
+
+    eigs : numpy.array
+        Eigenvalues of decompressed matrix
+
+    See Also
+    --------
+
+    cond
+
+    Notes
+    -----
+
+    This is a convenience function for the :class:`freealg.FreeForm` class with
+    some effective defaults that work well for common random matrix ensembles.
+    For improved performance and plotting utilites, consider fine-tuning
+    parameters using the FreeForm class.
+
+    References
+    ----------
+
+    .. [1] Reference.
+
+    Examples
+    --------
+
+    .. code-block:: python
+        :emphasize-lines: 6
+
+        >>> from freealg import cond
+        >>> from freealg.distributions import MarchenkoPastur
+
+        >>> mp = MarchenkoPastur(1/50)
+        >>> A = mp.matrix(3000)
+        >>> eigs = eigh(A)
+    """
+
+    if A.ndim != 2 or A.shape[0] != A.shape[1]:
+        raise RuntimeError("Only square matrices are permitted.")
+    n = A.shape[0]
+
+    if N is None:
+        N = n
+
+    # Size of sample matrix
+    n_s = int(80*(1 + numpy.log(n)))
+    # If matrix is not large enough, return eigenvalues
+    if n < n_s:
+        return compute_eig(A)
+    # Number of samples
+    num_samples = int(10 * (n / n_s)**0.5)
+
+    # Collect eigenvalue samples
+    samples = []
+    for _ in range(num_samples):
+        indices = numpy.random.choice(n, n_s, replace=False)
+        samples.append(compute_eig(A[numpy.ix_(indices, indices)]))
+    samples = numpy.concatenate(samples).ravel()
+
+    # If all eigenvalues are positive, set PSD flag
+    if psd is None:
+        psd = samples.min() > 0
+
+    ff = FreeForm(samples)
+    # Since we are resampling, we need to provide the correct matrix size
+    ff.n = n_s
+
+    # Perform fit and estimate eigenvalues
+    order = 1 + int(len(samples)**.2)
+    ff.fit(method='chebyshev', K=order, projection='sample',
+           force=True, plot=False, latex=False, save=False)
+
+    if plots:
+        ff.density(plot=True)
+        ff.stieltjes(plot=True)
+
+    _, _, eigs = ff.decompress(N, plot=plots)
+
+    if psd:
+        eigs = numpy.abs(eigs)
+        eigs.sort()
+
+    return eigs
+
+
+# ====
+# cond
+# ====
+
+def cond(A, N=None):
+    """
+    Estimate the condition number of a Hermitian positive-definite matrix.
+
+    This function estimates the condition number of the matrix
+    :math:`\\mathbf{A}` or a larger matrix containing :math:`\\mathbf{A}`
+    using free decompression.
+
+    Parameters
+    ----------
+
+    A : numpy.ndarray
+        The symmetric real-valued matrix :math:`\\mathbf{A}` whose condition
+        number (or that of a matrix containing :math:`\\mathbf{A}`) are to be
+        computed.
+
+    N : int, default=None
+        The size of the matrix containing :math:`\\mathbf{A}` to estimate
+        eigenvalues of. If None, returns estimates of the eigenvalues of
+        :math:`\\mathbf{A}` itself.
+
+    Returns
+    -------
+
+    c : float
+        Condition number
+
+    See Also
+    --------
+
+    eigh
+    norm
+    slogdet
+    trace
+
+    Notes
+    -----
+
+    This is a convenience function using :func:`freealg.eigh`.
+
+    Examples
+    --------
+
+    .. code-block:: python
+        :emphasize-lines: 6
+
+        >>> from freealg import cond
+        >>> from freealg.distributions import MarchenkoPastur
+
+        >>> mp = MarchenkoPastur(1/50)
+        >>> A = mp.matrix(3000)
+        >>> cond(A)
+    """
+
+    eigs = eigh(A, N)
+    return eigs.max() / eigs.min()
+
+
+# ====
+# norm
+# ====
+
+def norm(A, N=None, order=None):
+    """
+    Estimate the Schatten norm of a Hermitian matrix.
+
+    This function estimates the norm of the matrix :math:`\\mathbf{A}` or a
+    larger matrix containing :math:`\\mathbf{A}` using free decompression.
+
+    Parameters
+    ----------
+
+    A : numpy.ndarray
+        The symmetric real-valued matrix :math:`\\mathbf{A}` whose condition
+        number (or that of a matrix containing :math:`\\mathbf{A}`) are to be
+        computed.
+
+    N : int, default=None
+        The size of the matrix containing :math:`\\mathbf{A}` to estimate
+        eigenvalues of. If None, returns estimates of the eigenvalues of
+        :math:`\\mathbf{A}` itself.
+
+    order : {float, ``''inf``, ``'-inf'``, ``'fro'``, ``'nuc'``}, default=2
+        Order of the norm.
+
+        * float :math:`p`: Schtten p-norm.
+        * ``'inf'``: Largest absolute eigenvalue
+          :math:`\\max \\vert \\lambda_i \\vert)`
+        * ``'-inf'``: Smallest absolute eigenvalue
+          :math:`\\min \\vert \\lambda_i \\vert)`
+        * ``'fro'``: Frobenius norm corresponding to :math:`p=2`
+        * ``'nuc'``: Nuclear (or trace) norm corresponding to :math:`p=1`
+
+    Returns
+    -------
+
+    norm : float
+        matrix norm
+
+    See Also
+    --------
+
+    eigh
+    cond
+    slogdet
+    trace
+
+    Notes
+    -----
+
+    Thes Schatten :math:`p`-norm is defined by
+
+    .. math::
+
+        \\Vert \\mathbf{A} \\Vert_p = \\left(
+        \\sum_{i=1}^N \\vert \\lambda_i \\vert^p \\right)^{1/p}.
+
+    Examples
+    --------
+
+    .. code-block:: python
+        :emphasize-lines: 6
+
+        >>> from freealg import norm
+        >>> from freealg.distributions import MarchenkoPastur
+
+        >>> mp = MarchenkoPastur(1/50)
+        >>> A = mp.matrix(3000)
+        >>> norm(A, 100_000, order='fro')
+    """
+
+    eigs = eigh(A, N)
+
+    if (order == 'inf') or numpy.isinf(order):
+        norm_ = max(numpy.abs(eigs))
+
+    elif (order == '-inf') or numpy.isneginf(order):
+        norm_ = min(numpy.abs(eigs))
+
+    elif (order == 'nuc') or (order == 1.0):
+        norm_ = numpy.sum(numpy.abs(eigs))
+
+    elif (order == 'fro') or (order == 2.0):
+        norm_2 = numpy.sum(numpy.abs(eigs)**2)
+        norm_ = numpy.sqrt(norm_2)
+
+    elif isinstance(order, (int, float, numpy.integer, numpy.floating)) and \
+            not isinstance(order, (bool, numpy.bool_)):
+        norm_q = numpy.sum(numpy.abs(eigs)**order)
+        norm_ = norm_q**(1.0 / order)
+
+    else:
+        raise ValueError('"order" is invalid.')
+
+    return norm_
+
+
+# =====
+# trace
+# =====
+
+def trace(A, N=None):
+    """
+    Estimate the trace of a Hermitian matrix.
+
+    This function estimates the trace of the matrix :math:`\\mathbf{A}` or a
+    larger matrix containing :math:`\\mathbf{A}` using free decompression.
+
+    Parameters
+    ----------
+
+    A : numpy.ndarray
+        The symmetric real-valued matrix :math:`\\mathbf{A}` whose condition
+        number (or that of a matrix containing :math:`\\mathbf{A}`) are to be
+        computed.
+
+    N : int, default=None
+        The size of the matrix containing :math:`\\mathbf{A}` to estimate
+        eigenvalues of. If None, returns estimates of the eigenvalues of
+        :math:`\\mathbf{A}` itself.
+
+    Returns
+    -------
+
+    trace : float
+        matrix trace
+
+    See Also
+    --------
+
+    eigh
+    cond
+    slogdet
+    norm
+
+    Notes
+    -----
+
+    This is a convenience function using :func:`freealg.eigh`.
+
+    Examples
+    --------
+
+    .. code-block:: python
+        :emphasize-lines: 6
+
+        >>> from freealg import norm
+        >>> from freealg.distributions import MarchenkoPastur
+
+        >>> mp = MarchenkoPastur(1/50)
+        >>> A = mp.matrix(3000)
+        >>> trace(A, 100_000)
+    """
+
+    eigs = eigh(A, N)
+    trace_ = numpy.sum(eigs)
+
+    return trace_
+
+
+# =======
+# slogdet
+# =======
+
+def slogdet(A, N=None):
+    """
+    Estimate the sign and logarithm of the determinant of a Hermitian matrix.
+
+    This function estimates the *slogdet* of the matrix :math:`\\mathbf{A}` or
+    a larger matrix containing :math:`\\mathbf{A}` using free decompression.
+
+    Parameters
+    ----------
+
+    A : numpy.ndarray
+        The symmetric real-valued matrix :math:`\\mathbf{A}` whose condition
+        number (or that of a matrix containing :math:`\\mathbf{A}`) are to be
+        computed.
+
+    N : int, default=None
+        The size of the matrix containing :math:`\\mathbf{A}` to estimate
+        eigenvalues of. If None, returns estimates of the eigenvalues of
+        :math:`\\mathbf{A}` itself.
+
+    Returns
+    -------
+
+    sign : float
+        Sign of determinant
+
+    ld : float
+        natural logarithm of the absolute value of the determinant
+
+    See Also
+    --------
+
+    eigh
+    cond
+    trace
+    norm
+
+    Notes
+    -----
+
+    This is a convenience function using :func:`freealg.eigh`.
+
+    Examples
+    --------
+
+    .. code-block:: python
+        :emphasize-lines: 6
+
+        >>> from freealg import norm
+        >>> from freealg.distributions import MarchenkoPastur
+
+        >>> mp = MarchenkoPastur(1/50)
+        >>> A = mp.matrix(3000)
+        >>> sign, ld = slogdet(A, 100_000)
+    """
+
+    eigs = eigh(A, N)
+    sign = numpy.prod(numpy.sign(eigs))
+    ld = numpy.sum(numpy.log(numpy.abs(eigs)))
+
+    return sign, ld

{freealg-0.1.15 → freealg-0.3.0}/freealg/freeform.py

@@ -28,6 +28,10 @@ from ._decompress import decompress
 from ._sample import qmc_sample
 from ._support import detect_support
 
+# Fallback to previous API
+if not hasattr(numpy, 'trapezoid'):
+    numpy.trapezoid = numpy.trapz
+
 __all__ = ['FreeForm']
 
 
@@ -55,13 +59,14 @@ class FreeForm(object):
         Size of perturbations into the upper half plane for Plemelj's
         formula.
 
-    Parameters for the ``detect_support`` function can also be prescribed here
-    when ``support=None``.
+    **kwargs : dict, optional
+        Parameters for the ``detect_support`` function can also be prescribed
+        here when ``support=None``.
 
     Notes
     -----
 
-    Notes.
+    TBD
 
     References
     ----------
@@ -890,103 +895,3 @@ class FreeForm(object):
             return x, rho, eigs
         else:
             return x, rho
-
-
-def eigfree(A, N=None, psd=None, plots=False):
-    """
-    Estimate the eigenvalues of a matrix :math:`\\mathbf{A}` or a larger matrix
-    containing :math:`\\mathbf{A}` using free decompression.
-
-    This is a convenience function for the FreeForm class with some effective
-    defaults that work well for common random matrix ensembles. For improved
-    performance and plotting utilites, consider finetuning parameters using
-    the FreeForm class.
-
-    Parameters
-    ----------
-
-    A : numpy.ndarray
-        The symmetric real-valued matrix :math:`\\mathbf{A}` whose eigenvalues
-        (or those of a matrix containing :math:`\\mathbf{A}`) are to be
-        computed.
-
-    N : int, default=None
-        The size of the matrix containing :math:`\\mathbf{A}` to estimate
-        eigenvalues of. If None, returns estimates of the eigenvalues of
-        :math:`\\mathbf{A}` itself.
-
-    psd : bool, default=None
-        Determines whether the matrix is positive-semidefinite (PSD; all
-        eigenvalues are non-negative). If None, the matrix is considered PSD if
-        all sampled eigenvalues are positive.
-
-    plots : bool, default=False
-        Print out all relevant plots for diagnosing eigenvalue accuracy.
-
-    Notes
-    -----
-
-    Notes.
-
-    References
-    ----------
-
-    .. [1] Reference.
-
-    Examples
-    --------
-
-    .. code-block:: python
-
-        >>> from freealg import FreeForm
-    """
-    if A.ndim != 2 or A.shape[0] != A.shape[1]:
-        raise RuntimeError("Only square matrices are permitted.")
-    n = A.shape[0]
-
-    if N is None:
-        N = n
-
-    # Size of sample matrix
-    n_s = int(80*(1 + numpy.log(n)))
-    # If matrix is not large enough, return eigenvalues
-    if n < n_s:
-        return compute_eig(A)
-    # Number of samples
-    num_samples = int(10 * (n / n_s)**0.5)
-    # else:
-    #     # Use the entire matrix given
-    #     n_s = n
-    #     num_samples = 1
-
-    # Collect eigenvalue samples
-    samples = []
-    for _ in range(num_samples):
-        indices = numpy.random.choice(n, n_s, replace=False)
-        samples.append(compute_eig(A[numpy.ix_(indices, indices)]))
-    samples = numpy.concatenate(samples).ravel()
-
-    # If all eigenvalues are positive, set PSD flag
-    if psd is None:
-        psd = samples.min() > 0
-
-    ff = FreeForm(samples)
-    # Since we are resampling, we need to provide the correct matrix size
-    ff.n = n_s
-
-    # Perform fit and estimate eigenvalues
-    order = 1 + int(len(samples)**.2)
-    ff.fit(method='chebyshev', K=order, projection='sample',
-           force=True, plot=False, latex=False, save=False)
-
-    if plots:
-        ff.density(plot=True)
-        ff.stieltjes(plot=True)
-
-    _, _, eigs = ff.decompress(N, plot=plots)
-
-    if psd:
-        eigs = numpy.abs(eigs)
-        eigs.sort()
-
-    return eigs

{freealg-0.1.15 → freealg-0.3.0}/freealg.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: freealg
-Version: 0.1.15
+Version: 0.3.0
 Summary: Free probability for large matrices
 Keywords: leaderboard bot chat
 Platform: Linux

{freealg-0.1.15 → freealg-0.3.0}/freealg.egg-info/SOURCES.txt

@@ -18,7 +18,7 @@ freealg/_plot_util.py
 freealg/_sample.py
 freealg/_support.py
 freealg/_util.py
-freealg/eigfree.py
+freealg/eigh.py
 freealg/freeform.py
 freealg.egg-info/PKG-INFO
 freealg.egg-info/SOURCES.txt

freealg-0.1.15/freealg/__version__.py

@@ -1 +0,0 @@
-__version__ = "0.1.15"

freealg-0.1.15/freealg/eigfree.py

@@ -1,170 +0,0 @@
-# SPDX-FileCopyrightText: Copyright 2025, Siavash Ameli <sameli@berkeley.edu>
-# SPDX-License-Identifier: BSD-3-Clause
-# SPDX-FileType: SOURCE
-#
-# This program is free software: you can redistribute it and/or modify it under
-# the terms of the license found in the LICENSE.txt file in the root directory
-# of this source tree.
-
-
-# =======
-# Imports
-# =======
-
-import numpy
-from ._util import compute_eig
-from .freeform import FreeForm
-
-__all__ = ['eigfree', 'condfree']
-
-
-# ========
-# eig free
-# ========
-
-
-def eigfree(A, N=None, psd=None, plots=False):
-    """
-    Estimate the eigenvalues of a matrix.
-
-    This function estimates the eigenvalues of the matrix :math:`\\mathbf{A}`
-    or a larger matrix containing :math:`\\mathbf{A}` using free decompression.
-
-    Parameters
-    ----------
-
-    A : numpy.ndarray
-        The symmetric real-valued matrix :math:`\\mathbf{A}` whose eigenvalues
-        (or those of a matrix containing :math:`\\mathbf{A}`) are to be
-        computed.
-
-    N : int, default=None
-        The size of the matrix containing :math:`\\mathbf{A}` to estimate
-        eigenvalues of. If None, returns estimates of the eigenvalues of
-        :math:`\\mathbf{A}` itself.
-
-    psd: bool, default=None
-        Determines whether the matrix is positive-semidefinite (PSD; all
-        eigenvalues are non-negative). If None, the matrix is considered PSD if
-        all sampled eigenvalues are positive.
-
-    plots : bool, default=False
-        Print out all relevant plots for diagnosing eigenvalue accuracy.
-
-    Notes
-    -----
-
-    This is a convenience function for the FreeForm class with some effective
-    defaults that work well for common random matrix ensembles. For improved
-    performance and plotting utilites, consider finetuning parameters using
-    the FreeForm class.
-
-    References
-    ----------
-
-    .. [1] Reference.
-
-    Examples
-    --------
-
-    .. code-block:: python
-
-        >>> from freealg import condfree
-        >>> from freealg.distributions import MarchenkoPastur
-        >>> mp = MarchenkoPastur(1/50)
-        >>> A = mp.matrix(3000)
-        >>> eigs = eigfree(A)
-    """
-
-    if A.ndim != 2 or A.shape[0] != A.shape[1]:
-        raise RuntimeError("Only square matrices are permitted.")
-    n = A.shape[0]
-
-    if N is None:
-        N = n
-
-    # Size of sample matrix
-    n_s = int(80*(1 + numpy.log(n)))
-    # If matrix is not large enough, return eigenvalues
-    if n < n_s:
-        return compute_eig(A)
-    # Number of samples
-    num_samples = int(10 * (n / n_s)**0.5)
-
-    # Collect eigenvalue samples
-    samples = []
-    for _ in range(num_samples):
-        indices = numpy.random.choice(n, n_s, replace=False)
-        samples.append(compute_eig(A[numpy.ix_(indices, indices)]))
-    samples = numpy.concatenate(samples).ravel()
-
-    # If all eigenvalues are positive, set PSD flag
-    if psd is None:
-        psd = samples.min() > 0
-
-    ff = FreeForm(samples)
-    # Since we are resampling, we need to provide the correct matrix size
-    ff.n = n_s
-
-    # Perform fit and estimate eigenvalues
-    order = 1 + int(len(samples)**.2)
-    ff.fit(method='chebyshev', K=order, projection='sample',
-           force=True, plot=False, latex=False, save=False)
-
-    if plots:
-        ff.density(plot=True)
-        ff.stieltjes(plot=True)
-
-    _, _, eigs = ff.decompress(N, plot=plots)
-
-    if psd:
-        eigs = numpy.abs(eigs)
-        eigs.sort()
-
-    return eigs
-
-
-# ========
-# cond free
-# ========
-
-def condfree(A, N=None):
-    """
-    Estimate the condition number of a positive-definite matrix.
-
-    This function estimates the condition number of the matrix
-    :math:`\\mathbf{A}` or a larger matrix containing :math:`\\mathbf{A}`
-    using free decompression.
-
-    Parameters
-    ----------
-
-    A : numpy.ndarray
-        The symmetric real-valued matrix :math:`\\mathbf{A}` whose condition
-        number (or that of a matrix containing :math:`\\mathbf{A}`) are to be
-        computed.
-
-    N : int, default=None
-        The size of the matrix containing :math:`\\mathbf{A}` to estimate
-        eigenvalues of. If None, returns estimates of the eigenvalues of
-        :math:`\\mathbf{A}` itself.
-
-    Notes
-    -----
-
-    This is a convenience function using the eigfree procedure.
-
-    Examples
-    --------
-
-    .. code-block:: python
-
-        >>> from freealg import condfree
-        >>> from freealg.distributions import MarchenkoPastur
-        >>> mp = MarchenkoPastur(1/50)
-        >>> A = mp.matrix(3000)
-        >>> condfree(A)
-    """
-
-    eigs = eigfree(A, N)
-    return eigs.max() / eigs.min()