Enum Error 

pub enum Error {
    UnexpectedDType {
        msg: &'static str,
        expected: DType,
        got: DType,
    },
    DTypeMismatchBinaryOp {
        lhs: DType,
        rhs: DType,
        op: &'static str,
    },
    DTypeMismatch {
        lhs: DType,
        rhs: DType,
        op: &'static str,
    },
    UnsupportedDTypeForOp(DType, &'static str),
    IndexOutOfRangeTake {
        storage_len: usize,
        index: usize,
    },
    IndexOutOfRange {
        max_size: usize,
        index: usize,
        op: &'static str,
    },
    DimOutOfRange {
        shape: Shape,
        dim: i32,
        op: &'static str,
    },
    DimSizeOutOfRange {
        size: usize,
        op: &'static str,
    },
    DuplicateDimIndex {
        shape: Shape,
        dims: Vec<usize>,
        op: &'static str,
    },
    RepeatRankOutOfRange {
        repeats: Shape,
        shape: Shape,
    },
    ElementCountMismatchInReshape {
        origin: Shape,
        target: Shape,
    },
    ElementSizeMismatch {
        expected: usize,
        got: usize,
        op: &'static str,
    },
    UnexpectedNumberOfDims {
        expected: usize,
        got: usize,
        shape: Shape,
    },
    UnexpectedShape {
        msg: String,
        expected: Shape,
        got: Shape,
    },
    RequiresContiguous {
        op: &'static str,
    },
    InvalidIndex {
        index: usize,
        size: usize,
        op: &'static str,
    },
    ShapeMismatchBinaryOp {
        lhs: Shape,
        rhs: Shape,
        op: &'static str,
    },
    DeviceMismatchBinaryOp {
        lhs: String,
        rhs: String,
        op: &'static str,
    },
    ShapeMismatchCat {
        dim: usize,
        first_shape: Shape,
        n: usize,
        nth_shape: Shape,
    },
    ShapeMismatchMaskedSelect {
        src: Shape,
        condition: Shape,
    },
    ShapeMismatchSelect {
        mask: Shape,
        who: &'static str,
    },
    ShapeMismatchCopyFrom {
        dst: Shape,
        src: Shape,
    },
    NarrowInvalidArgs {
        shape: Shape,
        dim: usize,
        start: usize,
        len: usize,
        msg: &'static str,
    },
    SqueezeDimNot1 {
        shape: Shape,
        dim: usize,
    },
    BroadcastIncompatibleShapes {
        src_shape: Shape,
        dst_shape: Shape,
    },
    OpRequiresAtLeastOneTensor {
        op: &'static str,
    },
    Rand(String),
    NotScalar,
    BackwardNotSupported(&'static str),
    ParseInt(ParseIntError),
    FromUtf8(FromUtf8Error),
    Io(Error),
    Utf8(Utf8Error),
    MetaTensor,
    Msg(String),
    UnwrapNone,
}

Variants

UnexpectedDType

Fields

msg: &'static str

expected: DType

got: DType

DTypeMismatchBinaryOp

Fields

lhs: DType

rhs: DType

op: &'static str

DTypeMismatch

A Float/Int tensor holds a concrete precision (f32/f64, …) decided at runtime; two operands must share the same precision. Use .cast(..) to align them.

Fields

lhs: DType

rhs: DType

op: &'static str

UnsupportedDTypeForOp(DType, &'static str)

IndexOutOfRangeTake

Fields

storage_len: usize

index: usize

IndexOutOfRange

Fields

max_size: usize

index: usize

op: &'static str

DimOutOfRange

Fields

shape: Shape

dim: i32

op: &'static str

DimSizeOutOfRange

Fields

size: usize

op: &'static str

DuplicateDimIndex

Fields

shape: Shape

dims: Vec<usize>

op: &'static str

RepeatRankOutOfRange

Fields

repeats: Shape

shape: Shape

ElementCountMismatchInReshape

Fields

origin: Shape

target: Shape

ElementSizeMismatch

Fields

expected: usize

got: usize

op: &'static str

UnexpectedNumberOfDims

Fields

expected: usize

got: usize

shape: Shape

UnexpectedShape

Fields

msg: String

expected: Shape

got: Shape

RequiresContiguous

Fields

op: &'static str

InvalidIndex

Fields

index: usize

size: usize

op: &'static str

ShapeMismatchBinaryOp

Fields

lhs: Shape

rhs: Shape

op: &'static str

DeviceMismatchBinaryOp

Fields

lhs: String

rhs: String

op: &'static str

ShapeMismatchCat

Fields

dim: usize

first_shape: Shape

n: usize

nth_shape: Shape

ShapeMismatchMaskedSelect

Fields

src: Shape

condition: Shape

ShapeMismatchSelect

Fields

mask: Shape

who: &'static str

ShapeMismatchCopyFrom

Fields

dst: Shape

src: Shape

NarrowInvalidArgs

Fields

shape: Shape

dim: usize

start: usize

len: usize

msg: &'static str

SqueezeDimNot1

Fields

shape: Shape

dim: usize

BroadcastIncompatibleShapes

Fields

src_shape: Shape

dst_shape: Shape

OpRequiresAtLeastOneTensor

Fields

op: &'static str

Rand(String)

NotScalar

BackwardNotSupported(&'static str)

ParseInt(ParseIntError)

Integer parse error.

FromUtf8(FromUtf8Error)

Utf8 parse error.

Io(Error)

I/O error.

Utf8(Utf8Error)

MetaTensor

Storage error

Msg(String)

User generated error message

UnwrapNone

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

fn from(source: FromUtf8Error) -> Self

Converts to this type from the input type.

impl From<ParseIntError> for Error

fn from(source: ParseIntError) -> Self

Converts to this type from the input type.

impl From<Utf8Error> for Error

fn from(source: Utf8Error) -> Self

Converts to this type from the input type.