Enum SignalError 

pub enum SignalError {
    InvalidLength {
        len: usize,
        reason: &'static str,
    },
    InvalidPolicy {
        policy: &'static str,
        reason: &'static str,
    },
    ZeroStride,
    StrideOverflow,
    LengthMismatch {
        expected: usize,
        actual: usize,
    },
    InvalidTensorView {
        reason: &'static str,
    },
    AxisOutOfBounds {
        axis: usize,
        rank: usize,
    },
    DuplicateAxis {
        axis: usize,
    },
    ScratchLimit {
        required: usize,
        maximum: usize,
    },
    WorkLimit {
        required: u64,
        maximum: u64,
    },
    SingularModel {
        order: usize,
    },
    UnstableModel {
        order: usize,
    },
    SingularSystem {
        operation: &'static str,
        step: usize,
        pivot_magnitude: f64,
        threshold: f64,
    },
    DuplicateCoordinate {
        index: usize,
        value: f64,
    },
    OutOfDomain {
        index: usize,
        value: f64,
        minimum: f64,
        maximum: f64,
    },
    PredictionLimit {
        index: usize,
    },
    BlockStore {
        operation: &'static str,
        message: String,
    },
    InputKind {
        expected: &'static str,
        actual: &'static str,
    },
    NonFinite {
        index: usize,
        component: &'static str,
    },
    DegenerateNormalization {
        normalization: &'static str,
    },
}

Error returned when a transform plan or signal buffer is invalid.

Variants

InvalidLength

A transform length was zero or too short for its definition.

Fields

len: usize

Requested logical transform length.

reason: &'static str

Definition-level requirement that was not met.

InvalidPolicy

A policy combination is contradictory or unsupported.

Fields

policy: &'static str

Name of the policy that was rejected.

reason: &'static str

Reason the policy cannot be used.

ZeroStride

A stride step of zero was requested.

StrideOverflow

Offset/stride arithmetic overflowed usize.

LengthMismatch

The selected logical input length disagrees with the plan.

Fields

expected: usize

Length required by the plan.

actual: usize

Length available through the selected view.

InvalidTensorView

A tensor shape or physical layout is not a valid non-overlapping view.

Fields

reason: &'static str

View invariant that was not satisfied.

AxisOutOfBounds

A requested transform axis does not exist in the tensor rank.

Fields

axis: usize

Requested axis.

rank: usize

Number of tensor dimensions.

DuplicateAxis

A transform axis appeared more than once.

Fields

axis: usize

Repeated axis.

ScratchLimit

A bounded transform plan would exceed the caller’s scratch limit.

Fields

required: usize

Peak scratch bytes required by the selected plan.

maximum: usize

Caller-declared scratch-byte ceiling.

WorkLimit

A spectral estimator would exceed its declared deterministic work limit.

Fields

required: u64

Conservative work units required by the selected plan.

maximum: u64

Caller-declared work-unit ceiling.

SingularModel

Burg recursion encountered a zero-energy or numerically singular stage.

Fields

order: usize

One-based autoregressive order at which the recursion became singular.

UnstableModel

An autoregressive reflection coefficient crossed the declared stability margin.

Fields

order: usize

One-based autoregressive order at which stability was lost.

SingularSystem

A numerical system had no pivot above its declared singularity threshold.

Fields

operation: &'static str

Operation whose system was rejected.

step: usize

Zero-based elimination step.

pivot_magnitude: f64

Largest candidate pivot magnitude at the rejected step.

threshold: f64

Absolute pivot threshold required by the numerical policy.

DuplicateCoordinate

A sampled-data input repeated an abscissa under reject policy.

Fields

index: usize

Index of the repeated coordinate in the supplied input.

value: f64

Repeated abscissa.

OutOfDomain

A query lies outside a finite sampled-data domain under reject policy.

Fields

index: usize

Query index.

value: f64

Rejected coordinate.

minimum: f64

Smallest admitted coordinate.

maximum: f64

Largest admitted coordinate.

PredictionLimit

Recursive prediction exceeded its declared finite-amplitude bound.

Fields

index: usize

Zero-based predicted sample that first crossed the bound.

BlockStore

A Table/Dir block-store operation failed or returned invalid data.

Fields

operation: &'static str

Operation being performed.

message: String

Backend or encoding diagnostic.

InputKind

A transform received real data where complex data was required, or the reverse.

Fields

expected: &'static str

Input representation required by the plan.

actual: &'static str

Input representation supplied by the caller.

NonFinite

A signal contains a NaN or infinity.

Fields

index: usize

Logical signal position containing the invalid component.

component: &'static str

Component name (real, imag, or value).

DegenerateNormalization

A requested normalization has a zero or non-finite divisor.

Fields

normalization: &'static str

Name of the normalization whose divisor was unusable.

Trait Implementations

impl Clone for SignalError

fn clone(&self) -> SignalError

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for SignalError

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

Formats the value using the given formatter.

impl Display for SignalError

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

Formats the value using the given formatter.

impl Error for SignalError

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 PartialEq for SignalError

fn eq(&self, other: &SignalError) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for SignalError