Trait FromCv

pub trait FromCv<T> {
    // Required method
    fn from_cv(from: T) -> Self;
}

Type conversion that is analogous to From.

Required Methods

fn from_cv(from: T) -> Self

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl<A, S, D> FromCv<&ArrayBase<S, D>> for Tensor

where A: Element + Clone, S: RawData<Elem = A> + Data, D: Dimension,

fn from_cv(from: &ArrayBase<S, D>) -> Self

impl<A, S, D> FromCv<ArrayBase<S, D>> for Tensor

where A: Element + Clone, S: RawData<Elem = A> + Data, D: Dimension,

fn from_cv(from: ArrayBase<S, D>) -> Self

impl<T> FromCv<&Point<T>> for Point_<T>

where T: Num + Copy,

fn from_cv(from: &Point<T>) -> Self

impl<T> FromCv<&OPoint<T, Const<2>>> for Point_<T>

where T: Scalar + Copy,

fn from_cv(from: &Point2<T>) -> Self

impl<T> FromCv<&OPoint<T, Const<3>>> for Point3_<T>

where T: Scalar + Copy,

fn from_cv(from: &Point3<T>) -> Self

impl<T> FromCv<&Point3_<T>> for Point3<T>

where T: Scalar + Copy,

fn from_cv(from: &Point3_<T>) -> Self

impl<T> FromCv<&Point_<T>> for Point<T>

where T: Num + Copy,

fn from_cv(from: &Point_<T>) -> Self

impl<T> FromCv<&Point_<T>> for Point2<T>

where T: Scalar + Copy,

fn from_cv(from: &Point_<T>) -> Self

impl<T> FromCv<Point<T>> for Point_<T>

where T: Num + Copy,

fn from_cv(from: Point<T>) -> Self

impl<T> FromCv<OPoint<T, Const<2>>> for Point_<T>

where T: Scalar + Copy,

fn from_cv(from: Point2<T>) -> Self

impl<T> FromCv<OPoint<T, Const<3>>> for Point3_<T>

where T: Scalar + Copy,

fn from_cv(from: Point3<T>) -> Self

impl<T> FromCv<Point3_<T>> for Point3<T>

where T: Scalar + Copy,

fn from_cv(from: Point3_<T>) -> Self

impl<T> FromCv<Point_<T>> for Point<T>

where T: Num + Copy,

fn from_cv(from: Point_<T>) -> Self

impl<T> FromCv<Point_<T>> for Point2<T>

where T: Scalar + Copy,

fn from_cv(from: Point_<T>) -> Self

impl<const N1: usize, const N2: usize> FromCv<&[[bool; N2]; N1]> for Tensor

fn from_cv(from: &[[bool; N2]; N1]) -> Self

impl<const N1: usize, const N2: usize> FromCv<&[[f32; N2]; N1]> for Tensor

fn from_cv(from: &[[f32; N2]; N1]) -> Self

impl<const N1: usize, const N2: usize> FromCv<&[[f64; N2]; N1]> for Tensor

fn from_cv(from: &[[f64; N2]; N1]) -> Self

impl<const N1: usize, const N2: usize> FromCv<&[[i8; N2]; N1]> for Tensor

fn from_cv(from: &[[i8; N2]; N1]) -> Self

impl<const N1: usize, const N2: usize> FromCv<&[[i16; N2]; N1]> for Tensor

fn from_cv(from: &[[i16; N2]; N1]) -> Self

impl<const N1: usize, const N2: usize> FromCv<&[[i32; N2]; N1]> for Tensor

fn from_cv(from: &[[i32; N2]; N1]) -> Self

impl<const N1: usize, const N2: usize> FromCv<&[[i64; N2]; N1]> for Tensor

fn from_cv(from: &[[i64; N2]; N1]) -> Self

impl<const N1: usize, const N2: usize> FromCv<&[[u8; N2]; N1]> for Tensor

fn from_cv(from: &[[u8; N2]; N1]) -> Self

impl<const N1: usize, const N2: usize> FromCv<&[[f16; N2]; N1]> for Tensor

fn from_cv(from: &[[f16; N2]; N1]) -> Self

impl<const N1: usize, const N2: usize> FromCv<[[bool; N2]; N1]> for Tensor

fn from_cv(from: [[bool; N2]; N1]) -> Self

impl<const N1: usize, const N2: usize> FromCv<[[f32; N2]; N1]> for Tensor

fn from_cv(from: [[f32; N2]; N1]) -> Self

impl<const N1: usize, const N2: usize> FromCv<[[f64; N2]; N1]> for Tensor

fn from_cv(from: [[f64; N2]; N1]) -> Self

impl<const N1: usize, const N2: usize> FromCv<[[i8; N2]; N1]> for Tensor

fn from_cv(from: [[i8; N2]; N1]) -> Self

impl<const N1: usize, const N2: usize> FromCv<[[i16; N2]; N1]> for Tensor

fn from_cv(from: [[i16; N2]; N1]) -> Self

impl<const N1: usize, const N2: usize> FromCv<[[i32; N2]; N1]> for Tensor

fn from_cv(from: [[i32; N2]; N1]) -> Self

impl<const N1: usize, const N2: usize> FromCv<[[i64; N2]; N1]> for Tensor

fn from_cv(from: [[i64; N2]; N1]) -> Self

impl<const N1: usize, const N2: usize> FromCv<[[u8; N2]; N1]> for Tensor

fn from_cv(from: [[u8; N2]; N1]) -> Self

impl<const N1: usize, const N2: usize> FromCv<[[f16; N2]; N1]> for Tensor

fn from_cv(from: [[f16; N2]; N1]) -> Self

impl<const N1: usize, const N2: usize, const N3: usize> FromCv<&[[[bool; N3]; N2]; N1]> for Tensor

fn from_cv(from: &[[[bool; N3]; N2]; N1]) -> Self

impl<const N1: usize, const N2: usize, const N3: usize> FromCv<&[[[f32; N3]; N2]; N1]> for Tensor

fn from_cv(from: &[[[f32; N3]; N2]; N1]) -> Self

impl<const N1: usize, const N2: usize, const N3: usize> FromCv<&[[[f64; N3]; N2]; N1]> for Tensor

fn from_cv(from: &[[[f64; N3]; N2]; N1]) -> Self

impl<const N1: usize, const N2: usize, const N3: usize> FromCv<&[[[i8; N3]; N2]; N1]> for Tensor

fn from_cv(from: &[[[i8; N3]; N2]; N1]) -> Self

impl<const N1: usize, const N2: usize, const N3: usize> FromCv<&[[[i16; N3]; N2]; N1]> for Tensor

fn from_cv(from: &[[[i16; N3]; N2]; N1]) -> Self

impl<const N1: usize, const N2: usize, const N3: usize> FromCv<&[[[i32; N3]; N2]; N1]> for Tensor

fn from_cv(from: &[[[i32; N3]; N2]; N1]) -> Self

impl<const N1: usize, const N2: usize, const N3: usize> FromCv<&[[[i64; N3]; N2]; N1]> for Tensor

fn from_cv(from: &[[[i64; N3]; N2]; N1]) -> Self

impl<const N1: usize, const N2: usize, const N3: usize> FromCv<&[[[u8; N3]; N2]; N1]> for Tensor

fn from_cv(from: &[[[u8; N3]; N2]; N1]) -> Self

impl<const N1: usize, const N2: usize, const N3: usize> FromCv<&[[[f16; N3]; N2]; N1]> for Tensor

fn from_cv(from: &[[[f16; N3]; N2]; N1]) -> Self

impl<const N1: usize, const N2: usize, const N3: usize> FromCv<[[[bool; N3]; N2]; N1]> for Tensor

fn from_cv(from: [[[bool; N3]; N2]; N1]) -> Self

impl<const N1: usize, const N2: usize, const N3: usize> FromCv<[[[f32; N3]; N2]; N1]> for Tensor

fn from_cv(from: [[[f32; N3]; N2]; N1]) -> Self

impl<const N1: usize, const N2: usize, const N3: usize> FromCv<[[[f64; N3]; N2]; N1]> for Tensor

fn from_cv(from: [[[f64; N3]; N2]; N1]) -> Self

impl<const N1: usize, const N2: usize, const N3: usize> FromCv<[[[i8; N3]; N2]; N1]> for Tensor

fn from_cv(from: [[[i8; N3]; N2]; N1]) -> Self

impl<const N1: usize, const N2: usize, const N3: usize> FromCv<[[[i16; N3]; N2]; N1]> for Tensor

fn from_cv(from: [[[i16; N3]; N2]; N1]) -> Self

impl<const N1: usize, const N2: usize, const N3: usize> FromCv<[[[i32; N3]; N2]; N1]> for Tensor

fn from_cv(from: [[[i32; N3]; N2]; N1]) -> Self

impl<const N1: usize, const N2: usize, const N3: usize> FromCv<[[[i64; N3]; N2]; N1]> for Tensor

fn from_cv(from: [[[i64; N3]; N2]; N1]) -> Self

impl<const N1: usize, const N2: usize, const N3: usize> FromCv<[[[u8; N3]; N2]; N1]> for Tensor

fn from_cv(from: [[[u8; N3]; N2]; N1]) -> Self

impl<const N1: usize, const N2: usize, const N3: usize> FromCv<[[[f16; N3]; N2]; N1]> for Tensor

fn from_cv(from: [[[f16; N3]; N2]; N1]) -> Self

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize> FromCv<&[[[[bool; N4]; N3]; N2]; N1]> for Tensor

fn from_cv(from: &[[[[bool; N4]; N3]; N2]; N1]) -> Self

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize> FromCv<&[[[[f32; N4]; N3]; N2]; N1]> for Tensor

fn from_cv(from: &[[[[f32; N4]; N3]; N2]; N1]) -> Self

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize> FromCv<&[[[[f64; N4]; N3]; N2]; N1]> for Tensor

fn from_cv(from: &[[[[f64; N4]; N3]; N2]; N1]) -> Self

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize> FromCv<&[[[[i8; N4]; N3]; N2]; N1]> for Tensor

fn from_cv(from: &[[[[i8; N4]; N3]; N2]; N1]) -> Self

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize> FromCv<&[[[[i16; N4]; N3]; N2]; N1]> for Tensor

fn from_cv(from: &[[[[i16; N4]; N3]; N2]; N1]) -> Self

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize> FromCv<&[[[[i32; N4]; N3]; N2]; N1]> for Tensor

fn from_cv(from: &[[[[i32; N4]; N3]; N2]; N1]) -> Self

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize> FromCv<&[[[[i64; N4]; N3]; N2]; N1]> for Tensor

fn from_cv(from: &[[[[i64; N4]; N3]; N2]; N1]) -> Self

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize> FromCv<&[[[[u8; N4]; N3]; N2]; N1]> for Tensor

fn from_cv(from: &[[[[u8; N4]; N3]; N2]; N1]) -> Self

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize> FromCv<&[[[[f16; N4]; N3]; N2]; N1]> for Tensor

fn from_cv(from: &[[[[f16; N4]; N3]; N2]; N1]) -> Self

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize> FromCv<[[[[bool; N4]; N3]; N2]; N1]> for Tensor

fn from_cv(from: [[[[bool; N4]; N3]; N2]; N1]) -> Self

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize> FromCv<[[[[f32; N4]; N3]; N2]; N1]> for Tensor

fn from_cv(from: [[[[f32; N4]; N3]; N2]; N1]) -> Self

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize> FromCv<[[[[f64; N4]; N3]; N2]; N1]> for Tensor

fn from_cv(from: [[[[f64; N4]; N3]; N2]; N1]) -> Self

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize> FromCv<[[[[i8; N4]; N3]; N2]; N1]> for Tensor

fn from_cv(from: [[[[i8; N4]; N3]; N2]; N1]) -> Self

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize> FromCv<[[[[i16; N4]; N3]; N2]; N1]> for Tensor

fn from_cv(from: [[[[i16; N4]; N3]; N2]; N1]) -> Self

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize> FromCv<[[[[i32; N4]; N3]; N2]; N1]> for Tensor

fn from_cv(from: [[[[i32; N4]; N3]; N2]; N1]) -> Self

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize> FromCv<[[[[i64; N4]; N3]; N2]; N1]> for Tensor

fn from_cv(from: [[[[i64; N4]; N3]; N2]; N1]) -> Self

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize> FromCv<[[[[u8; N4]; N3]; N2]; N1]> for Tensor

fn from_cv(from: [[[[u8; N4]; N3]; N2]; N1]) -> Self

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize> FromCv<[[[[f16; N4]; N3]; N2]; N1]> for Tensor

fn from_cv(from: [[[[f16; N4]; N3]; N2]; N1]) -> Self

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize> FromCv<&[[[[[bool; N5]; N4]; N3]; N2]; N1]> for Tensor

fn from_cv(from: &[[[[[bool; N5]; N4]; N3]; N2]; N1]) -> Self

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize> FromCv<&[[[[[f32; N5]; N4]; N3]; N2]; N1]> for Tensor

fn from_cv(from: &[[[[[f32; N5]; N4]; N3]; N2]; N1]) -> Self

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize> FromCv<&[[[[[f64; N5]; N4]; N3]; N2]; N1]> for Tensor

fn from_cv(from: &[[[[[f64; N5]; N4]; N3]; N2]; N1]) -> Self

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize> FromCv<&[[[[[i8; N5]; N4]; N3]; N2]; N1]> for Tensor

fn from_cv(from: &[[[[[i8; N5]; N4]; N3]; N2]; N1]) -> Self

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize> FromCv<&[[[[[i16; N5]; N4]; N3]; N2]; N1]> for Tensor

fn from_cv(from: &[[[[[i16; N5]; N4]; N3]; N2]; N1]) -> Self

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize> FromCv<&[[[[[i32; N5]; N4]; N3]; N2]; N1]> for Tensor

fn from_cv(from: &[[[[[i32; N5]; N4]; N3]; N2]; N1]) -> Self

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize> FromCv<&[[[[[i64; N5]; N4]; N3]; N2]; N1]> for Tensor

fn from_cv(from: &[[[[[i64; N5]; N4]; N3]; N2]; N1]) -> Self

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize> FromCv<&[[[[[u8; N5]; N4]; N3]; N2]; N1]> for Tensor

fn from_cv(from: &[[[[[u8; N5]; N4]; N3]; N2]; N1]) -> Self

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize> FromCv<&[[[[[f16; N5]; N4]; N3]; N2]; N1]> for Tensor

fn from_cv(from: &[[[[[f16; N5]; N4]; N3]; N2]; N1]) -> Self

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize> FromCv<[[[[[bool; N5]; N4]; N3]; N2]; N1]> for Tensor

fn from_cv(from: [[[[[bool; N5]; N4]; N3]; N2]; N1]) -> Self

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize> FromCv<[[[[[f32; N5]; N4]; N3]; N2]; N1]> for Tensor

fn from_cv(from: [[[[[f32; N5]; N4]; N3]; N2]; N1]) -> Self

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize> FromCv<[[[[[f64; N5]; N4]; N3]; N2]; N1]> for Tensor

fn from_cv(from: [[[[[f64; N5]; N4]; N3]; N2]; N1]) -> Self

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize> FromCv<[[[[[i8; N5]; N4]; N3]; N2]; N1]> for Tensor

fn from_cv(from: [[[[[i8; N5]; N4]; N3]; N2]; N1]) -> Self

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize> FromCv<[[[[[i16; N5]; N4]; N3]; N2]; N1]> for Tensor

fn from_cv(from: [[[[[i16; N5]; N4]; N3]; N2]; N1]) -> Self

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize> FromCv<[[[[[i32; N5]; N4]; N3]; N2]; N1]> for Tensor

fn from_cv(from: [[[[[i32; N5]; N4]; N3]; N2]; N1]) -> Self

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize> FromCv<[[[[[i64; N5]; N4]; N3]; N2]; N1]> for Tensor

fn from_cv(from: [[[[[i64; N5]; N4]; N3]; N2]; N1]) -> Self

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize> FromCv<[[[[[u8; N5]; N4]; N3]; N2]; N1]> for Tensor

fn from_cv(from: [[[[[u8; N5]; N4]; N3]; N2]; N1]) -> Self

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize> FromCv<[[[[[f16; N5]; N4]; N3]; N2]; N1]> for Tensor

fn from_cv(from: [[[[[f16; N5]; N4]; N3]; N2]; N1]) -> Self

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize, const N6: usize> FromCv<&[[[[[[bool; N6]; N5]; N4]; N3]; N2]; N1]> for Tensor

fn from_cv(from: &[[[[[[bool; N6]; N5]; N4]; N3]; N2]; N1]) -> Self

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize, const N6: usize> FromCv<&[[[[[[f32; N6]; N5]; N4]; N3]; N2]; N1]> for Tensor

fn from_cv(from: &[[[[[[f32; N6]; N5]; N4]; N3]; N2]; N1]) -> Self

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize, const N6: usize> FromCv<&[[[[[[f64; N6]; N5]; N4]; N3]; N2]; N1]> for Tensor

fn from_cv(from: &[[[[[[f64; N6]; N5]; N4]; N3]; N2]; N1]) -> Self

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize, const N6: usize> FromCv<&[[[[[[i8; N6]; N5]; N4]; N3]; N2]; N1]> for Tensor

fn from_cv(from: &[[[[[[i8; N6]; N5]; N4]; N3]; N2]; N1]) -> Self

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize, const N6: usize> FromCv<&[[[[[[i16; N6]; N5]; N4]; N3]; N2]; N1]> for Tensor

fn from_cv(from: &[[[[[[i16; N6]; N5]; N4]; N3]; N2]; N1]) -> Self

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize, const N6: usize> FromCv<&[[[[[[i32; N6]; N5]; N4]; N3]; N2]; N1]> for Tensor

fn from_cv(from: &[[[[[[i32; N6]; N5]; N4]; N3]; N2]; N1]) -> Self

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize, const N6: usize> FromCv<&[[[[[[i64; N6]; N5]; N4]; N3]; N2]; N1]> for Tensor

fn from_cv(from: &[[[[[[i64; N6]; N5]; N4]; N3]; N2]; N1]) -> Self

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize, const N6: usize> FromCv<&[[[[[[u8; N6]; N5]; N4]; N3]; N2]; N1]> for Tensor

fn from_cv(from: &[[[[[[u8; N6]; N5]; N4]; N3]; N2]; N1]) -> Self

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize, const N6: usize> FromCv<&[[[[[[f16; N6]; N5]; N4]; N3]; N2]; N1]> for Tensor

fn from_cv(from: &[[[[[[f16; N6]; N5]; N4]; N3]; N2]; N1]) -> Self

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize, const N6: usize> FromCv<[[[[[[bool; N6]; N5]; N4]; N3]; N2]; N1]> for Tensor

fn from_cv(from: [[[[[[bool; N6]; N5]; N4]; N3]; N2]; N1]) -> Self

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize, const N6: usize> FromCv<[[[[[[f32; N6]; N5]; N4]; N3]; N2]; N1]> for Tensor

fn from_cv(from: [[[[[[f32; N6]; N5]; N4]; N3]; N2]; N1]) -> Self

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize, const N6: usize> FromCv<[[[[[[f64; N6]; N5]; N4]; N3]; N2]; N1]> for Tensor

fn from_cv(from: [[[[[[f64; N6]; N5]; N4]; N3]; N2]; N1]) -> Self

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize, const N6: usize> FromCv<[[[[[[i8; N6]; N5]; N4]; N3]; N2]; N1]> for Tensor

fn from_cv(from: [[[[[[i8; N6]; N5]; N4]; N3]; N2]; N1]) -> Self

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize, const N6: usize> FromCv<[[[[[[i16; N6]; N5]; N4]; N3]; N2]; N1]> for Tensor

fn from_cv(from: [[[[[[i16; N6]; N5]; N4]; N3]; N2]; N1]) -> Self

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize, const N6: usize> FromCv<[[[[[[i32; N6]; N5]; N4]; N3]; N2]; N1]> for Tensor

fn from_cv(from: [[[[[[i32; N6]; N5]; N4]; N3]; N2]; N1]) -> Self

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize, const N6: usize> FromCv<[[[[[[i64; N6]; N5]; N4]; N3]; N2]; N1]> for Tensor

fn from_cv(from: [[[[[[i64; N6]; N5]; N4]; N3]; N2]; N1]) -> Self

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize, const N6: usize> FromCv<[[[[[[u8; N6]; N5]; N4]; N3]; N2]; N1]> for Tensor

fn from_cv(from: [[[[[[u8; N6]; N5]; N4]; N3]; N2]; N1]) -> Self

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize, const N6: usize> FromCv<[[[[[[f16; N6]; N5]; N4]; N3]; N2]; N1]> for Tensor

fn from_cv(from: [[[[[[f16; N6]; N5]; N4]; N3]; N2]; N1]) -> Self

impl<const N: usize> FromCv<&[bool; N]> for Tensor

fn from_cv(from: &[bool; N]) -> Self

impl<const N: usize> FromCv<&[f32; N]> for Tensor

fn from_cv(from: &[f32; N]) -> Self

impl<const N: usize> FromCv<&[f64; N]> for Tensor

fn from_cv(from: &[f64; N]) -> Self

impl<const N: usize> FromCv<&[i8; N]> for Tensor

fn from_cv(from: &[i8; N]) -> Self

impl<const N: usize> FromCv<&[i16; N]> for Tensor

fn from_cv(from: &[i16; N]) -> Self

impl<const N: usize> FromCv<&[i32; N]> for Tensor

fn from_cv(from: &[i32; N]) -> Self

impl<const N: usize> FromCv<&[i64; N]> for Tensor

fn from_cv(from: &[i64; N]) -> Self

impl<const N: usize> FromCv<&[u8; N]> for Tensor

fn from_cv(from: &[u8; N]) -> Self

impl<const N: usize> FromCv<&[f16; N]> for Tensor

fn from_cv(from: &[f16; N]) -> Self

impl<const N: usize> FromCv<[bool; N]> for Tensor

fn from_cv(from: [bool; N]) -> Self

impl<const N: usize> FromCv<[f32; N]> for Tensor

fn from_cv(from: [f32; N]) -> Self

impl<const N: usize> FromCv<[f64; N]> for Tensor

fn from_cv(from: [f64; N]) -> Self

impl<const N: usize> FromCv<[i8; N]> for Tensor

fn from_cv(from: [i8; N]) -> Self

impl<const N: usize> FromCv<[i16; N]> for Tensor

fn from_cv(from: [i16; N]) -> Self

impl<const N: usize> FromCv<[i32; N]> for Tensor

fn from_cv(from: [i32; N]) -> Self

impl<const N: usize> FromCv<[i64; N]> for Tensor

fn from_cv(from: [i64; N]) -> Self

impl<const N: usize> FromCv<[u8; N]> for Tensor

fn from_cv(from: [u8; N]) -> Self

impl<const N: usize> FromCv<[f16; N]> for Tensor

fn from_cv(from: [f16; N]) -> Self

Implementors

impl<P, Container> FromCv<&ImageBuffer<P, Container>> for TchTensorAsImage

where P: Pixel + 'static, P::Subpixel: 'static + Element, Container: Deref<Target = [P::Subpixel]>,

impl<P, Container> FromCv<ImageBuffer<P, Container>> for TchTensorAsImage

where P: Pixel + 'static, P::Subpixel: 'static + Element, Container: Deref<Target = [P::Subpixel]>,