Enum Error 

#[non_exhaustive]
pub enum Error {
    Validation {
        op: &'static str,
        source: ValidationError,
    },
    InvalidSubscripts {
        message: String,
    },
    Planning {
        source: PlanningError,
    },
    Numerical {
        message: String,
    },
    Tensor(Error),
    Runtime(Error),
}

Errors produced while parsing, planning, lowering, or executing einsum expressions.

Examples

use tenferro_einsum::Error;
use tenferro_tensor::{ErrorKind, ShapeMismatch, ShapeVec, ValidationKind};

let err = Error::validation(
    "einsum",
    ShapeMismatch::ExpectedActual {
        expected: ShapeVec::from_vec(vec![2, 3]),
        actual: ShapeVec::from_vec(vec![2, 4]),
    }
    .into(),
);
assert_eq!(err.kind(), ErrorKind::Validation(ValidationKind::ShapeMismatch));

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.

Validation

A shared tensor validation fact discovered by an einsum operation.

Fields

op: &'static str

Public operation name.

source: ValidationError

Machine-readable validation payload.

InvalidSubscripts

Einsum notation is malformed or cannot be parsed.

Fields

message: String

Human-readable parser detail.

Planning

No valid contraction plan could be constructed for the supplied expression or optimizer configuration.

Fields

source: PlanningError

Typed planning-domain cause.

Numerical

A numerical contraction or backend accumulation failed to converge.

Fields

message: String

Human-readable numerical detail.

Tensor(Error)

A concrete tensor/backend operation failed.

Runtime(Error)

Graph construction or extension execution failed in the runtime.

Implementations

impl Error

pub fn validation(op: &'static str, source: ValidationError) -> Self

Construct a shared validation error.

Examples

use tenferro_einsum::Error;
use tenferro_tensor::ValidationError;

let error = Error::validation("einsum", ValidationError::RankMismatch {
    expected: 2,
    actual: 1,
});
assert!(matches!(error, Error::Validation { .. }));

pub fn invalid_argument( op: &'static str, argument: &'static str, message: impl Into<String>, ) -> Self

Construct an invalid-argument validation error.

Examples

use tenferro_einsum::Error;

let error = Error::invalid_argument("einsum", "inputs", "at least one input is required");
assert!(matches!(error, Error::Validation { .. }));

pub fn shape_mismatch( op: &'static str, expected: impl Into<Vec<usize>>, actual: impl Into<Vec<usize>>, ) -> Self

Construct a shape-mismatch validation error.

Examples

use tenferro_einsum::Error;

let error = Error::shape_mismatch("einsum", [2, 3], [2, 4]);
assert!(matches!(error, Error::Validation { .. }));

pub fn dtype_mismatch(op: &'static str, expected: DType, actual: DType) -> Self

Construct a dtype-mismatch validation error.

Examples

use tenferro_einsum::Error;
use tenferro_tensor::DType;

let error = Error::dtype_mismatch("einsum", DType::F32, DType::F64);
assert!(matches!(error, Error::Tensor(_)));

pub fn rank_mismatch(op: &'static str, expected: usize, actual: usize) -> Self

Construct a rank-mismatch validation error.

Examples

use tenferro_einsum::Error;

let error = Error::rank_mismatch("einsum", 2, 1);
assert!(matches!(error, Error::Validation { .. }));

pub fn invalid_subscripts(message: impl Into<String>) -> Self

Construct an invalid-notation error.

Examples

use tenferro_einsum::Error;

let error = Error::invalid_subscripts("missing `->`");
assert!(matches!(error, Error::InvalidSubscripts { .. }));

pub fn planning(message: impl Into<String>) -> Self

Construct a planning failure.

Examples

use tenferro_einsum::Error;

let error = Error::planning("no contraction path");
assert!(matches!(error, Error::Planning { .. }));

pub fn planning_runtime_state(message: impl Into<String>) -> Self

Construct a planning failure caused by unavailable planner state.

Examples

use tenferro_einsum::{Error, PlanningError};
use tenferro_tensor::ErrorKind;

let error = Error::planning_runtime_state("planner lock is poisoned");
assert_eq!(error.kind(), ErrorKind::RuntimeState);
assert!(matches!(
    error,
    Error::Planning {
        source: PlanningError::RuntimeState { .. }
    }
));

pub fn numerical(message: impl Into<String>) -> Self

Construct a numerical failure.

Examples

use tenferro_einsum::Error;

let error = Error::numerical("contraction did not converge");
assert!(matches!(error, Error::Numerical { .. }));

pub fn kind(&self) -> ErrorKind

Return the stable coarse classification of this einsum failure.

Examples

use tenferro_einsum::Error;
use tenferro_tensor::{ErrorKind, ValidationKind};

assert_eq!(
    Error::invalid_subscripts("bad").kind(),
    ErrorKind::Validation(ValidationKind::InvalidArgument),
);

pub fn into_tensor_error(self, op: &'static str) -> Error

Promote this error to the tensor error used by a type-erased extension boundary without formatting away its typed source.

Shared validation is promoted directly. All crate-local and nested errors remain a boxed source under the einsum extension family.

Examples

use std::error::Error as _;
use tenferro_einsum::Error;
use tenferro_tensor::{Error as TensorError, ErrorKind, ValidationKind};

let tensor_error = Error::planning("no valid contraction path")
    .into_tensor_error("einsum_extension");
assert_eq!(
    tensor_error.kind(),
    ErrorKind::Validation(ValidationKind::InvalidArgument)
);
assert!(matches!(tensor_error, TensorError::Extension { .. }));
assert!(tensor_error.source().is_some());

Trait Implementations

impl Debug for Error

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

Formats the value using the given formatter.

impl Display for Error

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

Formats the value using the given formatter.

impl Error for Error

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<Error> for Error

fn from(source: Error) -> Self

Converts to this type from the input type.

impl From<Error> for Error

fn from(source: Error) -> Self

Converts to this type from the input type.