gx2 1.0.0__tar.gz

gx2-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Abhranil Das
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

gx2-1.0.0/PKG-INFO

@@ -0,0 +1,150 @@
+Metadata-Version: 2.4
+Name: gx2
+Version: 1.0.0
+Summary: Statistics, pdf, cdf, inverse cdf and random numbers of the generalized chi-square distribution
+Author-email: Abhranil Das <abhranil.das@utexas.edu>
+License-Expression: MIT
+Project-URL: Reference paper 1, https://arxiv.org/abs/2012.14331
+Project-URL: Reference paper 2, https://arxiv.org/abs/2404.05062
+Keywords: generalized chi-square,chi-square,quadratic form,normal distribution,statistics
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.21
+Requires-Dist: scipy>=1.7
+Requires-Dist: mpmath>=1.2
+Provides-Extra: plot
+Requires-Dist: matplotlib>=3.4; extra == "plot"
+Provides-Extra: test
+Requires-Dist: pytest>=7.0; extra == "test"
+Provides-Extra: docs
+Requires-Dist: jupyter; extra == "docs"
+Requires-Dist: matplotlib>=3.4; extra == "docs"
+Dynamic: license-file
+
+<p align="center">
+  <img src="https://raw.githubusercontent.com/abhranildas/gx2-py/main/gx2_icon.png" alt="gx2" width="260">
+</p>
+
+# gx2 — Generalized chi-square distribution
+
+`gx2` computes the statistics, characteristic function, pdf, cdf, inverse cdf
+and random numbers of the **generalized chi-square distribution**.
+
+A generalized chi-square variable is a weighted sum of independent non-central
+chi-square variables plus a normal variable — equivalently, the quadratic form
+of a normal random vector. It is parametrized by:
+
+| parameter | meaning |
+|-----------|---------|
+| `w`       | weights of the non-central chi-square terms |
+| `k`       | their degrees of freedom |
+| `lambda_` | their non-centralities (named `lambda_` because `lambda` is a Python keyword) |
+| `s`       | scale (standard deviation) of the added normal term |
+| `m`       | constant offset |
+
+## Installation
+
+```bash
+pip install gx2
+```
+
+Requires `numpy`, `scipy` and `mpmath`. `matplotlib` is optional, for plotting
+in the getting-started notebook.
+
+To install from a local clone instead:
+
+```bash
+pip install .
+# or, for development (editable install with test/plot extras):
+pip install -e ".[plot,test]"
+```
+
+## Getting started
+
+```python
+import gx2
+
+w, k, lambda_, s, m = [1, -5, 2], [1, 2, 3], [2, 3, 7], 0, 5
+
+gx2.stat(w, k, lambda_, s, m)          # mean and variance
+gx2.cdf(25, w, k, lambda_, s, m)       # cdf at x = 25
+gx2.pdf(25, w, k, lambda_, s, m)       # pdf at x = 25
+gx2.inv(0.9, w, k, lambda_, s, m)      # 90th percentile
+gx2.rnd(w, k, lambda_, s, m, size=5)   # random numbers
+```
+
+Open [`GettingStarted.ipynb`](GettingStarted.ipynb) for an interactive tour
+with worked examples and plots. For any function, see its full documentation
+with `help(gx2.cdf)` (or `gx2.cdf?` in Jupyter).
+
+## Public functions
+
+| function | purpose |
+|----------|---------|
+| `stat(w, k, lambda_, s, m)` | mean and variance |
+| `char(t, w, k, lambda_, s, m)` | characteristic function |
+| `rnd(w, k, lambda_, s, m, size=, method=)` | random numbers |
+| `cdf(x, w, k, lambda_, s, m, side=, method=, ...)` | cdf |
+| `pdf(x, w, k, lambda_, s, m, side=, method=, ...)` | pdf |
+| `inv(p, w, k, lambda_, s, m, side=, method=, ...)` | inverse cdf |
+| `gx2_to_norm_quad_params(w, k, lambda_, s, m)` | gx2 → quadratic-form coefficients of a standard normal |
+| `norm_quad_to_gx2_params(mu, v, quad, merge=)` | quadratic form of a normal → gx2 parameters |
+
+The individual computation routines (`imhof`, `ruben`, `ifft`, `pearson`,
+`tail`, `ellipse`, `cdf_ray`, `pdf_ray`, …) and numerical helpers
+(`log_sum_exp`, `signed_log_sum_exp`, `phi_ray`, …) are also exposed.
+
+## Computation methods for `cdf` / `pdf`
+
+`method='auto'` (default) picks a good method for the given parameters. You can
+also force one:
+
+| method | notes |
+|--------|-------|
+| `'imhof'`   | Imhof–Davies numerical integration (`precision='basic'` or `'vpa'`) |
+| `'ray'`     | ray-trace method (`precision='basic'`, `'log'` or `'vpa'`; tune with `n_rays`, `force_mc`) |
+| `'ifft'`    | inverse-FFT method; `x='full'` returns the cdf/pdf over a spanning grid |
+| `'ruben'`   | Ruben's series — requires all `w` the same sign and `s=0` |
+| `'tail'`    | infinite-tail approximation |
+| `'pearson'` | Pearson's 3-moment approximation |
+| `'ellipse'` | ellipse approximation near a finite tail — requires all `w` the same sign and `s=0` |
+
+## Usage notes
+
+* `cdf` and `pdf` return just the probability/density by default. Pass
+  `full_output=True` (auto-enabled for `x='full'`) to also receive the error
+  estimate and, for `x='full'`, the grid of x-values.
+* In the far tails, probabilities can fall below double precision (~1e-308).
+  The `'tail'`, `'ellipse'` and `'ray'` methods then return the **base-10
+  logarithm** of such values (a negative number); `inv` likewise accepts a
+  negative `p` as a log10 probability. `precision='log'` (the ray default) is
+  the easiest way to reach this regime.
+* The `'ray'` method runs on the CPU with NumPy and batches automatically over
+  rays to bound memory. `precision='vpa'` uses `mpmath` and returns
+  `mpmath.mpf` objects for sub-`realmin` values.
+
+## Author and citation
+
+Abhranil Das, Center for Perceptual Systems, The University of Texas at Austin.
+Bugs / comments / questions / suggestions to abhranil.das@utexas.edu.
+
+This is the Python port of the
+[MATLAB toolbox](https://www.mathworks.com/matlabcentral/fileexchange/85028-generalized-chi-square-distribution).
+If you use this code, please cite:
+ - [Methods to integrate multinormals and compute classification measures](https://arxiv.org/abs/2012.14331)
+ - New methods to compute the generalized chi-square distribution: [journal](https://www.tandfonline.com/doi/abs/10.1080/00949655.2025.2501401) / [arxiv](https://arxiv.org/abs/2404.05062)
+
+## License
+
+MIT — see [LICENSE](LICENSE).

gx2-1.0.0/README.md

@@ -0,0 +1,116 @@
+<p align="center">
+  <img src="https://raw.githubusercontent.com/abhranildas/gx2-py/main/gx2_icon.png" alt="gx2" width="260">
+</p>
+
+# gx2 — Generalized chi-square distribution
+
+`gx2` computes the statistics, characteristic function, pdf, cdf, inverse cdf
+and random numbers of the **generalized chi-square distribution**.
+
+A generalized chi-square variable is a weighted sum of independent non-central
+chi-square variables plus a normal variable — equivalently, the quadratic form
+of a normal random vector. It is parametrized by:
+
+| parameter | meaning |
+|-----------|---------|
+| `w`       | weights of the non-central chi-square terms |
+| `k`       | their degrees of freedom |
+| `lambda_` | their non-centralities (named `lambda_` because `lambda` is a Python keyword) |
+| `s`       | scale (standard deviation) of the added normal term |
+| `m`       | constant offset |
+
+## Installation
+
+```bash
+pip install gx2
+```
+
+Requires `numpy`, `scipy` and `mpmath`. `matplotlib` is optional, for plotting
+in the getting-started notebook.
+
+To install from a local clone instead:
+
+```bash
+pip install .
+# or, for development (editable install with test/plot extras):
+pip install -e ".[plot,test]"
+```
+
+## Getting started
+
+```python
+import gx2
+
+w, k, lambda_, s, m = [1, -5, 2], [1, 2, 3], [2, 3, 7], 0, 5
+
+gx2.stat(w, k, lambda_, s, m)          # mean and variance
+gx2.cdf(25, w, k, lambda_, s, m)       # cdf at x = 25
+gx2.pdf(25, w, k, lambda_, s, m)       # pdf at x = 25
+gx2.inv(0.9, w, k, lambda_, s, m)      # 90th percentile
+gx2.rnd(w, k, lambda_, s, m, size=5)   # random numbers
+```
+
+Open [`GettingStarted.ipynb`](GettingStarted.ipynb) for an interactive tour
+with worked examples and plots. For any function, see its full documentation
+with `help(gx2.cdf)` (or `gx2.cdf?` in Jupyter).
+
+## Public functions
+
+| function | purpose |
+|----------|---------|
+| `stat(w, k, lambda_, s, m)` | mean and variance |
+| `char(t, w, k, lambda_, s, m)` | characteristic function |
+| `rnd(w, k, lambda_, s, m, size=, method=)` | random numbers |
+| `cdf(x, w, k, lambda_, s, m, side=, method=, ...)` | cdf |
+| `pdf(x, w, k, lambda_, s, m, side=, method=, ...)` | pdf |
+| `inv(p, w, k, lambda_, s, m, side=, method=, ...)` | inverse cdf |
+| `gx2_to_norm_quad_params(w, k, lambda_, s, m)` | gx2 → quadratic-form coefficients of a standard normal |
+| `norm_quad_to_gx2_params(mu, v, quad, merge=)` | quadratic form of a normal → gx2 parameters |
+
+The individual computation routines (`imhof`, `ruben`, `ifft`, `pearson`,
+`tail`, `ellipse`, `cdf_ray`, `pdf_ray`, …) and numerical helpers
+(`log_sum_exp`, `signed_log_sum_exp`, `phi_ray`, …) are also exposed.
+
+## Computation methods for `cdf` / `pdf`
+
+`method='auto'` (default) picks a good method for the given parameters. You can
+also force one:
+
+| method | notes |
+|--------|-------|
+| `'imhof'`   | Imhof–Davies numerical integration (`precision='basic'` or `'vpa'`) |
+| `'ray'`     | ray-trace method (`precision='basic'`, `'log'` or `'vpa'`; tune with `n_rays`, `force_mc`) |
+| `'ifft'`    | inverse-FFT method; `x='full'` returns the cdf/pdf over a spanning grid |
+| `'ruben'`   | Ruben's series — requires all `w` the same sign and `s=0` |
+| `'tail'`    | infinite-tail approximation |
+| `'pearson'` | Pearson's 3-moment approximation |
+| `'ellipse'` | ellipse approximation near a finite tail — requires all `w` the same sign and `s=0` |
+
+## Usage notes
+
+* `cdf` and `pdf` return just the probability/density by default. Pass
+  `full_output=True` (auto-enabled for `x='full'`) to also receive the error
+  estimate and, for `x='full'`, the grid of x-values.
+* In the far tails, probabilities can fall below double precision (~1e-308).
+  The `'tail'`, `'ellipse'` and `'ray'` methods then return the **base-10
+  logarithm** of such values (a negative number); `inv` likewise accepts a
+  negative `p` as a log10 probability. `precision='log'` (the ray default) is
+  the easiest way to reach this regime.
+* The `'ray'` method runs on the CPU with NumPy and batches automatically over
+  rays to bound memory. `precision='vpa'` uses `mpmath` and returns
+  `mpmath.mpf` objects for sub-`realmin` values.
+
+## Author and citation
+
+Abhranil Das, Center for Perceptual Systems, The University of Texas at Austin.
+Bugs / comments / questions / suggestions to abhranil.das@utexas.edu.
+
+This is the Python port of the
+[MATLAB toolbox](https://www.mathworks.com/matlabcentral/fileexchange/85028-generalized-chi-square-distribution).
+If you use this code, please cite:
+ - [Methods to integrate multinormals and compute classification measures](https://arxiv.org/abs/2012.14331)
+ - New methods to compute the generalized chi-square distribution: [journal](https://www.tandfonline.com/doi/abs/10.1080/00949655.2025.2501401) / [arxiv](https://arxiv.org/abs/2404.05062)
+
+## License
+
+MIT — see [LICENSE](LICENSE).

gx2-1.0.0/gx2/__init__.py

@@ -0,0 +1,53 @@
+"""gx2 - Generalized chi-square distribution
+============================================
+
+Python port of the MATLAB *Generalized chi-square distribution* toolbox by
+Abhranil Das (Center for Perceptual Systems, The University of Texas at
+Austin). It computes the statistics, characteristic function, pdf, cdf,
+inverse cdf and random numbers of the generalized chi-square distribution --
+the distribution of a weighted sum of non-central chi-square variables plus a
+normal variable, equivalently the quadratic form of a normal vector.
+
+A generalized chi-square is parametrised by:
+
+    w        weights of the non-central chi-square terms
+    k        their degrees of freedom
+    lambda_  their non-centralities (named ``lambda_`` since ``lambda`` is a
+             Python keyword)
+    s        scale of the added normal term
+    m        offset
+
+If you use this code, please cite:
+  1. A method to integrate and classify normal distributions
+     (https://arxiv.org/abs/2012.14331)
+  2. New methods for computing the generalized chi-square distribution
+     (https://arxiv.org/abs/2404.05062)
+"""
+
+from ._basic import stat, char, rnd
+from ._convert import gx2_to_norm_quad_params, norm_quad_to_gx2_params
+from ._distribution import cdf, pdf, inv, log_cdf
+from ._methods import (imhof, imhof_integrand, ruben, ifft,
+                       pearson, cdf_pearson, tail, ellipse)
+from ._ray import (cdf_ray, pdf_ray, ray_integrand, int_norm_ray,
+                   norm_prob_across_rays, norm_prob_across_angles)
+from ._helpers import (log_sum_exp, signed_log_sum_exp, phi_ray,
+                       Phibar_ray_split, Phibar_sym, prob_ray_sym, standard_quad)
+
+__version__ = "1.0.0"
+
+__all__ = [
+    # core distribution API
+    "stat", "char", "rnd", "cdf", "pdf", "inv", "log_cdf",
+    # parameter conversions
+    "gx2_to_norm_quad_params", "norm_quad_to_gx2_params",
+    # individual methods
+    "imhof", "imhof_integrand", "ruben", "ifft", "pearson",
+    "cdf_pearson", "tail", "ellipse",
+    # ray method internals
+    "cdf_ray", "pdf_ray", "ray_integrand", "int_norm_ray",
+    "norm_prob_across_rays", "norm_prob_across_angles",
+    # numerical helpers
+    "log_sum_exp", "signed_log_sum_exp", "phi_ray", "Phibar_ray_split",
+    "Phibar_sym", "prob_ray_sym", "standard_quad",
+]

gx2-1.0.0/gx2/_basic.py

@@ -0,0 +1,144 @@
+"""Mean/variance, characteristic function, and random number generation.
+Mirrors ``gx2stat.m``, ``gx2char.m`` and ``gx2rnd.m``.
+"""
+
+import numpy as np
+from scipy.stats import ncx2, chi2, norm
+
+from ._helpers import asrow
+from ._convert import gx2_to_norm_quad_params
+
+
+def stat(w, k, lambda_, s, m):
+    """Mean and variance of a generalized chi-square distribution.
+
+    Parameters
+    ----------
+    w : array_like
+        Weights of the non-central chi-square terms.
+    k : array_like
+        Degrees of freedom of the non-central chi-square terms.
+    lambda_ : array_like
+        Non-centrality parameters of the non-central chi-square terms.
+    s : float
+        Scale (standard deviation) of the added normal term.
+    m : float
+        Constant offset added to the distribution.
+
+    Returns
+    -------
+    mu : float
+        Mean.
+    v : float
+        Variance.
+    """
+    w = asrow(w)
+    k = asrow(k)
+    lambda_ = asrow(lambda_)
+    mu = float(np.dot(w, k + lambda_) + m)
+    v = float(2 * np.dot(w ** 2, k + 2 * lambda_) + s ** 2)
+    return mu, v
+
+
+def char(t, w, k, lambda_, s, m):
+    """Characteristic function of a generalized chi-square distribution.
+
+    Parameters
+    ----------
+    t : array_like
+        Point(s) at which to evaluate the characteristic function.
+    w : array_like
+        Weights of the non-central chi-square terms.
+    k : array_like
+        Degrees of freedom of the non-central chi-square terms.
+    lambda_ : array_like
+        Non-centrality parameters of the non-central chi-square terms.
+    s : float
+        Scale (standard deviation) of the added normal term.
+    m : float
+        Constant offset added to the distribution.
+
+    Returns
+    -------
+    phi : ndarray of complex
+        The characteristic function at each ``t``, shaped like ``t``.
+    """
+    w = asrow(w)
+    k = asrow(k)
+    lambda_ = asrow(lambda_)
+    t = np.asarray(t, dtype=float)
+    tf = t.ravel()
+    tc = tf[:, None]  # column
+
+    term = np.sum((w * lambda_) / (1 - 2j * tc * w), axis=1)
+    denom = np.prod((1 - 2j * w * tc) ** (k / 2), axis=1)
+    phi = np.exp(1j * m * tf + 1j * tf * term - s ** 2 * tf ** 2 / 2) / denom
+    return phi.reshape(t.shape)
+
+
+def rnd(w, k, lambda_, s, m, size=None, method="sum"):
+    """Generate generalized chi-square random numbers.
+
+    Parameters
+    ----------
+    w : array_like
+        Weights of the non-central chi-square terms.
+    k : array_like
+        Degrees of freedom of the non-central chi-square terms.
+    lambda_ : array_like
+        Non-centrality parameters of the non-central chi-square terms.
+    s : float
+        Scale (standard deviation) of the added normal term.
+    m : float
+        Constant offset added to the distribution.
+    size : int or tuple, optional
+        Output shape. A scalar ``n`` gives an ``n x n`` array; a tuple gives
+        that exact shape. If omitted, a single scalar is returned.
+    method : {'sum', 'norm_quad'}
+        ``'sum'`` (default) generates non-central chi-square and normal numbers
+        and adds them. ``'norm_quad'`` generates standard normal vectors and
+        computes their quadratic form.
+
+    Returns
+    -------
+    r : float or ndarray
+        Random sample(s), of shape ``size`` (or a scalar if ``size`` is None).
+    """
+    w = asrow(w)
+    k = asrow(k)
+    lambda_ = asrow(lambda_)
+
+    if size is None:
+        shape = ()
+    elif np.isscalar(size):
+        shape = (int(size), int(size))
+    else:
+        shape = tuple(int(x) for x in size)
+
+    method = str(method).lower()
+    if method == "sum":
+        r = np.zeros(shape)
+        for wi, ki, li in zip(w, k, lambda_):
+            if li == 0:
+                r = r + wi * chi2.rvs(df=ki, size=shape)
+            else:
+                r = r + wi * ncx2.rvs(df=ki, nc=li, size=shape)
+        if s:
+            r = r + norm.rvs(loc=m, scale=s, size=shape)
+        else:
+            r = r + m
+        return r
+    elif method == "norm_quad":
+        quad = gx2_to_norm_quad_params(w, k, lambda_, s, m)
+        q1 = np.asarray(quad["q1"]).ravel()
+        q2 = np.asarray(quad["q2"])
+        q0 = quad["q0"]
+        dim = q1.size
+        n = int(np.prod(shape)) if shape else 1
+        z = norm.rvs(loc=0, scale=1, size=(dim, n))
+        r = np.sum(z * (q2 @ z), axis=0) + q1 @ z + q0
+        if shape:
+            return r.reshape(shape)
+        return float(r[0])
+    else:
+        raise ValueError("method must be 'sum' or 'norm_quad'")

gx2-1.0.0/gx2/_convert.py

@@ -0,0 +1,106 @@
+"""Conversions between generalized chi-square parameters and the quadratic form
+of a normal vector. Mirrors ``gx2_to_norm_quad_params.m`` and
+``norm_quad_to_gx2_params.m``.
+"""
+
+import numpy as np
+from ._helpers import asrow, uniquetol
+
+
+def gx2_to_norm_quad_params(w, k, lambda_, s, m):
+    """Quadratic-form coefficients of the standard normal whose quadratic form
+    is the given generalized chi-square.
+
+    Parameters
+    ----------
+    w, k, lambda_ : array_like
+        Weights, degrees of freedom and non-centralities of the non-central
+        chi-square terms.
+    s : float
+        Scale of the normal term.
+    m : float
+        Offset.
+
+    Returns
+    -------
+    quad : dict
+        ``{'q2': matrix, 'q1': vector, 'q0': scalar}``. The dimension of the
+        standard normal is ``len(q1)``.
+    """
+    w = asrow(w)
+    k = asrow(k)
+    lambda_ = asrow(lambda_)
+
+    q2_parts = []
+    q1_parts = []
+    for wi, ki, li in zip(w, k, lambda_):
+        ki = int(round(ki))
+        q2_parts.append(np.full(ki, wi))
+        q1_parts.append(np.concatenate(([wi * np.sqrt(li)], np.zeros(ki - 1))))
+    q2 = np.concatenate(q2_parts) if q2_parts else np.array([])
+    q1 = -2 * (np.concatenate(q1_parts) if q1_parts else np.array([]))
+
+    if s:
+        q2 = np.append(q2, 0.0)
+        q1 = np.append(q1, s)
+
+    return {"q2": np.diag(q2), "q1": q1.astype(float), "q0": float(np.dot(w, lambda_) + m)}
+
+
+def norm_quad_to_gx2_params(mu, v, quad, merge=True):
+    """Parameters of the generalized chi-square distribution of a quadratic
+    form ``q(x) = x' q2 x + q1' x + q0`` of a normal vector ``x ~ N(mu, v)``.
+
+    Parameters
+    ----------
+    mu : array_like
+        Column vector of the normal mean.
+    v : array_like
+        Normal covariance matrix.
+    quad : dict
+        ``{'q2': matrix, 'q1': vector, 'q0': scalar}``.
+    merge : bool, optional
+        If True (default), merge non-central chi-square components with
+        close-enough weights into single components. Set False to return all
+        raw exact components.
+
+    Returns
+    -------
+    w, k, lambda_, s, m
+    """
+    mu = np.asarray(mu, dtype=float).ravel()
+    v = np.asarray(v, dtype=float)
+    q2_in = np.asarray(quad["q2"], dtype=float)
+    q1_in = np.asarray(quad["q1"], dtype=float).ravel()
+    q0_in = float(quad["q0"])
+
+    q2_sym = 0.5 * (q2_in + q2_in.T)
+
+    # sqrtm(v) avoiding small negative eigenvalues
+    d, R = np.linalg.eigh(v)
+    d = np.where(d < 0, 0.0, d)
+    sqrt_v = R @ np.diag(np.sqrt(d)) @ R.T
+
+    q2 = sqrt_v @ q2_sym @ sqrt_v
+    q2 = (q2 + q2.T) / 2
+    q1 = sqrt_v @ (2 * q2_sym @ mu + q1_in)
+    q0 = float(mu @ q2_sym @ mu + q1_in @ mu + q0_in)
+
+    d2, R2 = np.linalg.eigh(q2)
+    d = d2
+    b = (R2.T @ q1)
+
+    nz = d != 0
+    if merge:
+        w, ic = uniquetol(d[nz])
+        k = np.bincount(ic, minlength=w.size).astype(float)
+        b_sq_sum = np.bincount(ic, weights=b[nz] ** 2, minlength=w.size)
+        lambda_ = b_sq_sum / (4 * w ** 2)
+    else:
+        w = d[nz].copy()
+        k = np.ones(w.size)
+        lambda_ = b[nz] ** 2 / (4 * w ** 2)
+
+    m = q0 - np.dot(w, lambda_)
+    s = np.linalg.norm(b[~nz])
+    return w, k, lambda_, s, m