Trait cv_convert::prelude::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

Object Safety

This trait is not object safe.

Implementations on Foreign Types

impl<A, S, D> FromCv<&ArrayBase<S, D>> for Tensorwhere 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 Tensorwhere 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 TchTensorAsImagewhere P: Pixel + 'static, P::Subpixel: 'static + Element, Container: Deref<Target = [P::Subpixel]>,

impl<P, Container> FromCv<ImageBuffer<P, Container>> for TchTensorAsImagewhere P: Pixel + 'static, P::Subpixel: 'static + Element, Container: Deref<Target = [P::Subpixel]>,