Enum SymplexError 

#[non_exhaustive]
pub enum SymplexError {
    ContradictoryAssumptions {
        symbol: String,
        a: String,
        b: String,
    },
    PrecisionExhausted {
        requested: u32,
        achieved: u32,
    },
    FreeSymbol {
        name: String,
    },
    Unevaluable {
        reason: String,
    },
    ComputationFailed {
        operation: &'static str,
        reason: String,
    },
    NotImplemented(String),
    Divergent {
        operation: &'static str,
        reason: String,
    },
    NoSolution {
        operation: &'static str,
        reason: String,
    },
    InfiniteSolutions {
        operation: &'static str,
        reason: String,
    },
    InvalidArgument {
        operation: &'static str,
        reason: String,
    },
}

Errors that can occur during symbolic computation.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

ContradictoryAssumptions

Contradictory assumptions were specified for a symbol.

Fields

symbol: String

The symbol with conflicting assumptions.

a: String

The first conflicting property.

b: String

The second conflicting property.

PrecisionExhausted

Numerical evaluation could not achieve the requested precision.

Fields

requested: u32

Number of digits requested.

achieved: u32

Number of digits achieved before giving up.

FreeSymbol

Numerical evaluation failed because the expression contains a free (unbound) symbol.

Fields

name: String

The name of the unbound symbol.

Unevaluable

Numerical evaluation failed because a node type cannot be evaluated to a finite number.

Fields

reason: String

Human-readable description of why evaluation failed.

ComputationFailed

A symbolic computation could not produce a result.

The operation field names the operation that failed (e.g., “limit”, “solve”, “series”). The reason field provides a human-readable explanation.

Fields

operation: &'static str

The name of the operation that failed.

reason: String

Human-readable description of why the computation failed.

NotImplemented(String)

A feature or operation is not yet implemented.

Divergent

An integral, sum, product, or limit was shown to diverge.

Fields

operation: &'static str

The operation (e.g. “integrate”, “summation”).

reason: String

Why / how it diverges (e.g. “integrand has a non-integrable pole at x = 0”).

NoSolution

An equation or system is inconsistent — it has no solution at all.

Distinct from Ok(vec![]), which some solvers use for “no roots in the requested domain”; this variant means the problem itself is contradictory (e.g. x + y = 1, x + y = 2).

Fields

operation: &'static str

The operation that detected the inconsistency.

reason: String

Human-readable explanation.

InfiniteSolutions

An equation or system is satisfied by infinitely many values and the solver cannot (or was not asked to) return a parametric family.

For example solve on the identity 0 = 0, or an underdetermined linear system when a unique solution was requested.

Fields

operation: &'static str

The operation.

reason: String

Human-readable explanation.

InvalidArgument

A caller-supplied argument was invalid (wrong length, not a symbol, out of the function’s domain, …).

Fields

operation: &'static str

The operation that rejected its input.

reason: String

What was wrong with it.

Implementations

impl SymplexError

pub fn invalid_argument( operation: &'static str, reason: impl Into<String>, ) -> Self

InvalidArgument for operation: a caller-supplied value that fails validation (a shape, a parameter out of range, a symbol that is not one of the variables).

pub fn computation_failed( operation: &'static str, reason: impl Into<String>, ) -> Self

ComputationFailed for operation: the algorithm could not complete on valid input (a budget ran out, a series did not converge, an internal invariant did not hold).

Trait Implementations

impl Debug for SymplexError

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

Formats the value using the given formatter.

impl Display for SymplexError

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

Formats the value using the given formatter.

impl Error for SymplexError

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.