Struct Tensor

pub struct Tensor<E: TensorElement, D, const LAYERS: usize, const ROWS: usize, const COLS: usize>
where
    [(); { _ }]:,
{
    pub data: [E; { _ }],
    pub _phantom: PhantomData<D>,
}

Fields

data: [E; { _ }]

_phantom: PhantomData<D>

Implementations

impl<E: TensorElement, D, const LAYERS: usize, const ROWS: usize, const COLS: usize> Tensor<E, D, LAYERS, ROWS, COLS>

where [(); { _ }]:,

pub fn new<U: Unit<Dimension = D>>(values: [E; { _ }]) -> Self

pub fn zero() -> Self

pub fn random<U: Unit<Dimension = D>>(min: E, max: E) -> Self

pub fn get<S: Unit<Dimension = D>>(&self) -> [E; { _ }]

pub fn get_at(&self, layer: usize, row: usize, col: usize) -> Scalar<E, D>

pub fn set_at( &mut self, layer: usize, row: usize, col: usize, value: Scalar<E, D>, )

impl<E: TensorElement, D, const LAYERS: usize, const ROWS: usize, const COLS: usize> Tensor<E, D, LAYERS, ROWS, COLS>

where [(); { _ }]:,

pub fn dtype(&self) -> &'static str

pub fn cast<T>(&self) -> Tensor<T, D, LAYERS, ROWS, COLS>

where T: TensorElement,

impl<E: TensorElement, D> Tensor<E, D, 1, 2, 1>

pub fn raw_tuple(&self) -> (E, E)

where E: TensorElement,

pub fn raw_tuple_as<T: From<E>>(&self) -> (T, T)

where E: TensorElement,

impl<E, D, const LAYERS: usize, const ROWS: usize, const COLS: usize> Tensor<E, D, LAYERS, ROWS, COLS>

where [(); { _ }]:, E: TensorElement,

pub fn raw_vec(&self) -> Vec<E>

pub fn raw_vec_as<T: From<E>>(&self) -> Vec<T>

impl<E, D> Tensor<E, D, 1, 2, 1>

where E: TensorElement,

pub fn x(&self) -> Scalar<E, D>

pub fn y(&self) -> Scalar<E, D>

impl<E, D> Tensor<E, D, 1, 3, 1>

where E: TensorElement,

pub fn x(&self) -> Scalar<E, D>

pub fn y(&self) -> Scalar<E, D>

pub fn z(&self) -> Scalar<E, D>

impl<E: TensorElement + Mul<Output = E> + Add<Output = E> + Copy, const LAYERS: usize, const L1: i32, const M1: i32, const T1: i32, const Θ1: i32, const I1: i32, const N1: i32, const J1: i32, const ROWS: usize, const COMMON: usize> Tensor<E, Dimension<L1, M1, T1, Θ1, I1, N1, J1>, LAYERS, ROWS, COMMON>

where [(); { _ }]:,

pub fn matmul<const L2: i32, const M2: i32, const T2: i32, const Θ2: i32, const I2: i32, const N2: i32, const J2: i32, const COLS: usize>( self, other: Tensor<E, Dimension<L2, M2, T2, Θ2, I2, N2, J2>, LAYERS, COMMON, COLS>, ) -> Tensor<E, <Dimension<L1, M1, T1, Θ1, I1, N1, J1> as MultiplyDimensions<Dimension<L2, M2, T2, Θ2, I2, N2, J2>>>::Output, LAYERS, ROWS, COLS>

where Dimension<L1, M1, T1, Θ1, I1, N1, J1>: MultiplyDimensions<Dimension<L2, M2, T2, Θ2, I2, N2, J2>>, [(); { _ }]:, [(); COLS]:,

Performs matrix multiplication between two tensors.

impl<E: TensorElement + Mul<Output = E> + Copy, D, const LAYERS: usize, const ROWS: usize, const COLS: usize> Tensor<E, D, LAYERS, ROWS, COLS>

where [(); { _ }]:,

pub fn scale<DS>( self, scalar: Tensor<E, DS, 1, 1, 1>, ) -> Tensor<E, <D as MultiplyDimensions<DS>>::Output, LAYERS, ROWS, COLS>

where D: MultiplyDimensions<DS>, <D as MultiplyDimensions<DS>>::Output:,

Multiplies every element of the tensor by a scalar.

impl<E: TensorElement + Div<Output = E> + Copy + PartialEq, D> Tensor<E, D, 1, 1, 1>

where [(); 1]:,

pub fn inv(self) -> Tensor<E, <D as InvertDimension>::Output, 1, 1, 1>

where D: InvertDimension,

impl<E, D, const LAYERS: usize, const ROWS: usize, const COLS: usize> Tensor<E, D, LAYERS, ROWS, COLS>

where E: TensorElement + Into<c64> + Copy, [(); { _ }]:,

pub fn to_c64(&self) -> Tensor<c64, D, LAYERS, ROWS, COLS>

Converts the tensor to one with c64 elements by mapping each element via Into.

impl<E: TensorElement, D, const LAYERS: usize, const ROWS: usize, const COLS: usize> Tensor<E, D, LAYERS, ROWS, COLS>

where [(); { _ }]:,

pub fn conjugate(self) -> Self

pub fn conjugate_transpose(self) -> Tensor<E, D, LAYERS, COLS, ROWS>

where [(); { _ }]:,

Returns the conjugate transpose of this tensor.

impl<E: TensorElement, D, const LAYERS: usize, const ROWS: usize, const COLS: usize> Tensor<E, D, LAYERS, ROWS, COLS>

where [(); { _ }]:,

pub fn transpose(self) -> Tensor<E, D, LAYERS, COLS, ROWS>

where [(); { _ }]:,

Returns the transpose of this tensor.

impl<E: TensorElement + Into<f64> + Copy, const L: i32, const M: i32, const T: i32, const Θ: i32, const I: i32, const N: i32, const J: i32, const ROWS: usize> Tensor<E, Dimension<L, M, T, Θ, I, N, J>, 1, ROWS, 1>

where [(); { _ }]:,

pub fn norm(self) -> Tensor<f64, Dimension<L, M, T, Θ, I, N, J>, 1, 1, 1>

where [(); { _ }]:,

pub fn dist( self, other: Self, ) -> Tensor<f64, Dimension<L, M, T, Θ, I, N, J>, 1, 1, 1>

where [(); { _ }]:,

impl<E: TensorElement, D, const LAYERS: usize, const ROWS: usize, const COLS: usize> Tensor<E, D, LAYERS, ROWS, COLS>

where [(); { _ }]:,

pub fn size(&self) -> usize

Returns the number of elements in the tensor.

pub fn shape(&self) -> (usize, usize, usize)

pub fn layers(&self) -> usize

Returns the number of layers in the tensor.

pub fn rows(&self) -> usize

Returns the number of rows in the tensor.

pub fn cols(&self) -> usize

Returns the number of columns in the tensor.

pub fn data(&self) -> &[E]

Returns the data as a slice.

pub fn reshape<const L: usize, const R: usize, const C: usize>( &self, ) -> Tensor<E, D, L, R, C>

where [(); { _ }]:,

pub fn flatten(&self) -> Tensor<E, D, 1, 1, { _ }>

where [(); { _ }]:,

impl<E: TensorElement, D, const LAYERS: usize, const ROWS: usize, const COLS: usize> Tensor<E, D, LAYERS, ROWS, COLS>

where [(); { _ }]:,

pub fn and(self, other: Self) -> Self

impl<E: TensorElement + PartialEq + Copy, D, const LAYERS: usize, const ROWS: usize, const COLS: usize> Tensor<E, D, LAYERS, ROWS, COLS>

where [(); { _ }]:,

pub fn or(self, other: Self) -> Self

impl<E: TensorElement, D, const LAYERS: usize, const ROWS: usize, const COLS: usize> Tensor<E, D, LAYERS, ROWS, COLS>

where [(); { _ }]:,

pub fn eq(self, other: Self) -> Self

impl<E: TensorElement, D, const LAYERS: usize, const ROWS: usize, const COLS: usize> Tensor<E, D, LAYERS, ROWS, COLS>

where [(); { _ }]:,

pub fn ne(self, other: Self) -> Self

impl<E: TensorElement, D, const LAYERS: usize, const ROWS: usize, const COLS: usize> Tensor<E, D, LAYERS, ROWS, COLS>

where [(); { _ }]:,

pub fn gt(self, other: Self) -> Self

impl<E: TensorElement, D, const LAYERS: usize, const ROWS: usize, const COLS: usize> Tensor<E, D, LAYERS, ROWS, COLS>

where [(); { _ }]:,

pub fn ge(self, other: Self) -> Self

impl<E: TensorElement, D> Tensor<E, D, 1, 1, 1>

pub const EPSILON: Scalar<E, D>

pub fn from<U: Unit<Dimension = D>>(value: E) -> Self

pub fn raw(&self) -> E

pub fn raw_as<T: From<E>>(&self) -> T

pub fn mag(&self) -> Scalar<f64, D>

impl<E: TensorElement, D> Tensor<E, D, 1, 1, 1>

pub fn epsilon(&self) -> Self

impl<const L: usize, const R: usize, const C: usize> Tensor<c64, Dimensionless, L, R, C>

where [(); { _ }]:,

pub fn nat(values: [c64; { _ }]) -> Self

pub fn randnat(min: c64, max: c64) -> Self

impl Tensor<c64, Dimensionless, 1, 1, 1>

pub fn item(&self) -> c64

Trait Implementations

impl<E: TensorElement + Add<Output = E> + Copy, D, const LAYERS: usize, const ROWS: usize, const COLS: usize> Add for Tensor<E, D, LAYERS, ROWS, COLS>

where [(); { _ }]:,

type Output = Tensor<E, D, LAYERS, ROWS, COLS>

The resulting type after applying the + operator.

fn add(self, other: Self) -> Self

Performs the + operation.

impl<E, D, const LAYERS: usize, const ROWS: usize, const COLS: usize> AddAssign for Tensor<E, D, LAYERS, ROWS, COLS>

where [(); { _ }]:, E: TensorElement + AddAssign,

fn add_assign(&mut self, other: Self)

Performs the += operation.

impl<E: Clone + TensorElement, D: Clone, const LAYERS: usize, const ROWS: usize, const COLS: usize> Clone for Tensor<E, D, LAYERS, ROWS, COLS>

where [(); { _ }]:,

fn clone(&self) -> Tensor<E, D, LAYERS, ROWS, COLS>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<E: TensorElement, D: Debug + Default, const LAYERS: usize, const ROWS: usize, const COLS: usize> Debug for Tensor<E, D, LAYERS, ROWS, COLS>

where [(); { _ }]:,

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

Formats the value using the given formatter.

impl<E: TensorElement, D: Display + Default, const LAYERS: usize, const ROWS: usize, const COLS: usize> Display for Tensor<E, D, LAYERS, ROWS, COLS>

where [(); { _ }]:,

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

Formats the value using the given formatter.

impl<E, D, DS, const LAYERS: usize, const ROWS: usize, const COLS: usize> Div<Tensor<E, DS, 1, 1, 1>> for Tensor<E, D, LAYERS, ROWS, COLS>

where E: TensorElement + Div<Output = E> + Copy, DS: InvertDimension, D: MultiplyDimensions<<DS as InvertDimension>::Output>, [(); { _ }]:,

type Output = Tensor<E, <D as MultiplyDimensions<<DS as InvertDimension>::Output>>::Output, LAYERS, ROWS, COLS>

The resulting type after applying the / operator.

fn div(self, rhs: Tensor<E, DS, 1, 1, 1>) -> Self::Output

Performs the / operation.

impl<E, D, DS, const LAYERS: usize, const ROWS: usize, const COLS: usize> Mul<Tensor<E, DS, 1, 1, 1>> for Tensor<E, D, LAYERS, ROWS, COLS>

where E: TensorElement + Mul<Output = E> + Copy, D: MultiplyDimensions<DS>, [(); { _ }]:,

type Output = Tensor<E, <D as MultiplyDimensions<DS>>::Output, LAYERS, ROWS, COLS>

The resulting type after applying the * operator.

fn mul(self, rhs: Tensor<E, DS, 1, 1, 1>) -> Self::Output

Performs the * operation.

impl<E: TensorElement + Neg<Output = E> + Copy, D, const LAYERS: usize, const ROWS: usize, const COLS: usize> Neg for Tensor<E, D, LAYERS, ROWS, COLS>

where [(); { _ }]:,

type Output = Tensor<E, D, LAYERS, ROWS, COLS>

The resulting type after applying the - operator.

fn neg(self) -> Self

Performs the unary - operation.

impl<E: TensorElement, D, const LAYERS: usize, const ROWS: usize, const COLS: usize> PartialEq for Tensor<E, D, LAYERS, ROWS, COLS>

where [(); { _ }]:,

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<E: TensorElement, D> PartialOrd for Tensor<E, D, 1, 1, 1>

where [(); 1]:,

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<E: TensorElement + Sub<Output = E> + Copy, D, const LAYERS: usize, const ROWS: usize, const COLS: usize> Sub for Tensor<E, D, LAYERS, ROWS, COLS>

where [(); { _ }]:,

type Output = Tensor<E, D, LAYERS, ROWS, COLS>

The resulting type after applying the - operator.

fn sub(self, other: Self) -> Self

Performs the - operation.

impl<E: Copy + TensorElement, D: Copy, const LAYERS: usize, const ROWS: usize, const COLS: usize> Copy for Tensor<E, D, LAYERS, ROWS, COLS>

where [(); { _ }]:,

impl<E: TensorElement, D, const LAYERS: usize, const ROWS: usize, const COLS: usize> Eq for Tensor<E, D, LAYERS, ROWS, COLS>

where [(); { _ }]:, c64: Eq,