Enum CoreErrors 

pub enum CoreErrors {
    InvalidArgument(String),
    MustBePositive(String),
    FaerSvdError(String),
    FaerEigenError,
    FaerCholeskyError(LltError),
    PcaAllMissing {
        axis: &'static str,
        index: usize,
    },
    PcaTooManyComponents {
        n_pcs: usize,
        max: usize,
    },
    BandwidthTooFewPoints {
        found: usize,
    },
    BandwidthTooSparse {
        stage: &'static str,
    },
    BandwidthNoBracket,
    LengthMismatch {
        name: &'static str,
        expected: usize,
        found: usize,
    },
    GpEmptyInput {
        name: &'static str,
    },
    GpDimensionMismatch {
        n_x: usize,
        n_y: usize,
    },
    GpInvalidHyperparameter {
        name: &'static str,
        value: f64,
    },
    GpNonFiniteInput {
        name: &'static str,
    },
    GpLandmarkCholeskyFailed {
        jitter: f64,
        n_landmarks: usize,
    },
    GpPosteriorCholeskyFailed,
    GpDegenerateLandmarks,
    GpAllWeightsZero,
    BetaDistribution(String),
    AnnSearchRsError(AnnSearchErrors),
    DistanceNotSupported(Dist),
    NonMatchingFeatureDim {
        dim_x: usize,
        dim_y: usize,
    },
    NumberLabelsNotEqualSampleNumber {
        label_length: usize,
        n_samples: usize,
    },
    ReferenceOutOfRange,
    Data2NotAvailable,
    SliceIndexOutOfBounds {
        index: usize,
        len: usize,
    },
    DuplicateSliceIndex(usize),
    SparseMatrixMultiplication {
        n_col_a: usize,
        n_row_b: usize,
    },
    DimensionMisMatchSparse {
        indices_len: usize,
        data_len: usize,
    },
    SparseIndptrInvalid {
        detail: &'static str,
        expected: usize,
        got: usize,
    },
    ShapeMismatchSparse,
    SparseMatrixMustBeCsr,
    SparseMatrixIsolatedRow {
        row: usize,
        row_sum: f64,
    },
    MalformedCsr(&'static str),
    SparseMatrixMustBeCsc,
    ShapeMismatch {
        expected: (usize, usize),
        got: (usize, usize),
    },
    SparseLayoutMismatch {
        expected: CompressedSparseFormat,
        got: CompressedSparseFormat,
    },
}

Error variants raised by bixverse-core.

Grouped by subsystem.

Variants

InvalidArgument(String)

General error for invalid arguments to a given function

MustBePositive(String)

Error for wrong integer parameters

FaerSvdError(String)

SVD from faer failed to converge or returned no solution.

Typically caused by ill-conditioned or degenerate input (e.g. all-zero rows, NaNs, rank-deficient matrices beyond the requested rank).

FaerEigenError

Eigen decomposition from faer failed.

Usually indicates a non-symmetric matrix being passed to a symmetric solver, or numerical breakdown on degenerate input.

FaerCholeskyError(LltError)

Cholesky decomposition from faer failed.

PcaAllMissing

A row or column of the input to PPCA / BPCA holds no observed value.

Fields

axis: &'static str

"row" or "column"

index: usize

Zero-based index of the offending row or column

PcaTooManyComponents

More components were requested than the data can hold.

Fields

n_pcs: usize

Requested number of components

max: usize

min(nrow, ncol)

BandwidthTooFewPoints

A kernel bandwidth was requested for fewer than two points.

Fields

found: usize

Number of points supplied

BandwidthTooSparse

A Sheather-Jones pilot functional came back non-finite or non-positive.

R raises “sample is too sparse to find TD” / “… alph2” here. It means the pair-distance counts carry too little signal for the pilot estimate, which in practice is a degenerate or near-constant sample.

Fields

stage: &'static str

Which pilot functional failed, TD or alph2

BandwidthNoBracket

The Sheather-Jones bracket search never enclosed a root.

LengthMismatch

Two vectors that had to agree in length did not.

Fields

name: &'static str

Name of the offending input

expected: usize

Length that was required

found: usize

Length that was supplied

GpEmptyInput

A Gaussian process was handed empty training data.

Fields

name: &'static str

Which input was empty

GpDimensionMismatch

The training inputs and responses disagree in length.

Fields

n_x: usize

Length of the input vector

n_y: usize

Rows in the response matrix

GpInvalidHyperparameter

A hyperparameter is outside its supported range.

Fields

name: &'static str

Name of the offending hyperparameter

value: f64

The value that was rejected

GpNonFiniteInput

A non-finite value reached the fit.

Checked up front because a NaN otherwise surfaces as an unexplained Cholesky failure much later, with nothing pointing back at the input.

Fields

name: &'static str

Which input carried the non-finite value

GpLandmarkCholeskyFailed

The landmark Gram matrix stayed singular through the whole jitter ladder.

Fields

jitter: f64

Largest jitter that was tried

n_landmarks: usize

Number of landmarks

GpPosteriorCholeskyFailed

The posterior Cholesky failed.

Distinct from [BixverseErrors::GpLandmarkCholeskyFailed] because this factorises A A^T / sigma^2 + I, whose smallest eigenvalue is at least one in exact arithmetic. A failure here means a non-finite value got through the input checks, not that the problem is ill-conditioned.

GpDegenerateLandmarks

Every landmark sits at the same coordinate.

GpAllWeightsZero

Every sample weight is zero.

A zero weight drops its observation, so this leaves the fit with no data and returns the prior everywhere. Indistinguishable from a genuinely flat response, hence an error rather than a silent zero curve.

BetaDistribution(String)

Beta distribution construction failed

AnnSearchRsError(AnnSearchErrors)

Propagate errors from the ann-search-rs crate

DistanceNotSupported(Dist)

Distance type not supported

NonMatchingFeatureDim

Error if the feature dimensions are not the same

Fields

dim_x: usize

Feature dimensions matrix x

dim_y: usize

Feature dimensions matrix y

NumberLabelsNotEqualSampleNumber

Label length and number of cells do not match for Harmony

Fields

label_length: usize

Provided label length

n_samples: usize

Number of cells

ReferenceOutOfRange

If the reference is out of range

Data2NotAvailable

Error in situations were data_2 in crate::prelude::CompressedSparseData2 is asked for but not available

SliceIndexOutOfBounds

Error if the slice index is out of bounds

Fields

index: usize

The chosen index

len: usize

The actual length

DuplicateSliceIndex(usize)

Error if the slice index is duplicated

SparseMatrixMultiplication

Error for sparse multiplication dimension mismatches

Fields

n_col_a: usize

Number of columns in matrix a

n_row_b: usize

Number of rows in matrix b

DimensionMisMatchSparse

Dimension mismatch error during construction

Fields

indices_len: usize

Length indices

data_len: usize

Length data

SparseIndptrInvalid

Error if the indptr of a crate::prelude::CompressedSparseData2 is inconsistent with the shape it declares or with the stored values.

Raised by crate::prelude::CompressedSparseData2::validate on input that crossed an FFI boundary, where the struct’s public fields could have been populated with anything.

Fields

detail: &'static str

Which invariant failed

expected: usize

The value implied by the rest of the structure

got: usize

The value actually found

ShapeMismatchSparse

Error if there is a dimension mismatch in terms of the two matrices

SparseMatrixMustBeCsr

Error if the crate::prelude::CompressedSparseData2 is not in CSR.

SparseMatrixIsolatedRow

A row summed to (effectively) zero where a row-stochastic normalisation was asked for.

On a kNN-derived affinity matrix every node has k out-edges, so a zero row means the kernel weights underflowed rather than that the graph is legitimately disconnected. Anything built on top of the operator would be meaningless, hence an error rather than leaving the row at zero.

Fields

row: usize

The offending row index

row_sum: f64

The row sum that was rejected

MalformedCsr(&'static str)

A CSR matrix failed one of its structural invariants.

Raised by crate::core::math::sparse::validate_square_csr. The static string names the invariant, because “the graph is malformed” alone leaves the caller to bisect their own input.

SparseMatrixMustBeCsc

Error if the crate::prelude::CompressedSparseData2 is not in Csc.

ShapeMismatch

Shape mismatch problem for matrices

Fields

expected: (usize, usize)

Expected shape

got: (usize, usize)

Provided shape

SparseLayoutMismatch

General error for sparse matrix format mismatches

Fields

expected: CompressedSparseFormat

The expected CompressedSparseFormat enum.

got: CompressedSparseFormat

The provided CompressedSparseFormat enum.

Trait Implementations

impl Debug for CoreErrors

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Display for CoreErrors

fn fmt(&self, __formatter: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Error for CoreErrors

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0:

use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl From<AnnSearchErrors> for CoreErrors

fn from(source: AnnSearchErrors) -> CoreErrors

Converts to this type from the input type.

impl From<CoreErrors> for MethodsErrors

fn from(source: CoreErrors) -> Self

Converts to this type from the input type.

impl From<LltError> for CoreErrors

fn from(source: LltError) -> CoreErrors

Converts to this type from the input type.

impl From<SparseErrors> for CoreErrors

Maps each SparseErrors variant onto the identically named CoreErrors variant, so callers keep matching on CoreErrors after the sparse structures moved to bixverse-sparse.

fn from(err: SparseErrors) -> CoreErrors

Converts to this type from the input type.