Struct Naive 

pub struct Naive;

Simple backend, mostly for demonstratration purposes

Trait Implementations

impl<T: ComplexFloat<Real = T> + PartialOrd + Add<Output = T> + Mul<Output = T> + Zero + Copy> Argmax<T> for Naive

fn argmax_write<Lx: Layout, S: Shape>( &self, x: &Slice<T, S, Lx>, output: &mut Vec<usize>, ) -> bool

fn argmax<Lx: Layout, S: Shape>( &self, x: &Slice<T, S, Lx>, ) -> Option<Vec<usize>>

Index of max xᵢ (argmaxᵢ xᵢ)

fn argmax_abs_write<Lx: Layout, S: Shape>( &self, x: &Slice<T, S, Lx>, output: &mut Vec<usize>, ) -> bool

fn argmax_abs<Lx: Layout, S: Shape>( &self, x: &Slice<T, S, Lx>, ) -> Option<Vec<usize>>

Index of max |xᵢ| (argmaxᵢ |xᵢ|)

impl<T> Contract<T> for Naive

where T: ComplexFloat + Zero + One + MulAdd<Output = T> + AddAssign + Sum,

fn matmul<'a, D0, D1, D2, La, Lb>( &self, a: &'a Slice<T, (D0, D1), La>, b: &'a Slice<T, (D1, D2), Lb>, ) -> impl MatmulBuilder<'a, T, D0, D1, D2, La, Lb>

where La: Layout, Lb: Layout, D0: Dim, D1: Dim, D2: Dim,

Matrix multiplication.

fn contract_all<'a, Sa, Sb, La, Lb>( &self, a: &'a Slice<T, Sa, La>, b: &'a Slice<T, Sb, Lb>, ) -> T

where T: 'a, Sa: Shape, Sb: Shape, La: Layout, Lb: Layout,

Contracts all axes of a with all axes of b.

fn contract_n<'a, Sa, Sb, La, Lb>( &self, a: &'a Slice<T, Sa, La>, b: &'a Slice<T, Sb, Lb>, n: usize, ) -> impl ContractBuilder<'a, T, Sa, Sb, La, Lb>

where T: 'a, Sa: Shape, Sb: Shape, La: Layout, Lb: Layout,

Contracts the last n axes of a with the first n axes of b.

fn contract_pairs<'a, Sa, Sb, La, Lb>( &self, a: &'a Slice<T, Sa, La>, b: &'a Slice<T, Sb, Lb>, axes_a: &'a [usize], axes_b: &'a [usize], ) -> impl ContractBuilder<'a, T, Sa, Sb, La, Lb>

where T: 'a, Sa: Shape, Sb: Shape, La: Layout, Lb: Layout,

Contracts explicit pairs of axes.

fn contract<'a, Sa, Sb, La, Lb>( &self, a: &'a Slice<T, Sa, La>, b: &'a Slice<T, Sb, Lb>, indices_a: &'a [u8], indices_b: &'a [u8], indices_c: &'a [u8], ) -> impl ContractBuilder<'a, T, Sa, Sb, La, Lb>

where T: 'a, Sa: Shape, Sb: Shape, La: Layout, Lb: Layout,

Fully general contraction of two tensors, à la einsum.

impl Default for Naive

fn default() -> Naive

Returns the “default value” for a type.

impl<T, D0: Dim, D1: Dim> MatVec<T, D0, D1> for Naive

where T: ComplexFloat,

fn matvec<'a, La, Lx>( &self, a: &'a Slice<T, (D0, D1), La>, x: &'a Slice<T, (D1,), Lx>, ) -> impl MatVecBuilder<'a, T, La, Lx, D0, D1>

where La: Layout, Lx: Layout,

impl<T, Dx, Dy> Outer<T, Dx, Dy> for Naive

where T: ComplexFloat, Dx: Dim, Dy: Dim,

fn outer<'a, Lx, Ly>( &self, x: &'a Slice<T, (Dx,), Lx>, y: &'a Slice<T, (Dy,), Ly>, ) -> impl OuterBuilder<'a, T, Lx, Ly, Dx, Dy>

where Lx: Layout, Ly: Layout,

impl<T, D0: Dim, D1: Dim> QR<T, D0, D1> for Naive

where T: ComplexFloat + Zero + One + MulAdd<Output = T>,

fn qr_write<D2: Dim, L: Layout, Lq: Layout, Lr: Layout>( &self, a: &mut Slice<T, (D0, D1), L>, q: &mut Slice<T, (D0, D2), Lq>, r: &mut Slice<T, (D2, D1), Lr>, )

Compute QR decomposition overwriting existing matrices

fn qr<L: Layout>( &self, a: &mut Slice<T, (D0, D1), L>, ) -> (Array<T, (D0, usize)>, Array<T, (usize, D1)>)

Compute QR decomposition with new allocated matrices

impl<T: ComplexFloat + Add<Output = T> + Mul<Output = T> + Zero + Copy, D: Dim> VecOps<T, D> for Naive

type Real = <T as ComplexFloat>::Real

Real scalar type used for norm results and real rotation coefficients.

fn add_to_scaled<Lx: Layout, Ly: Layout>( &self, alpha: T, x: &Slice<T, (D,), Lx>, y: &mut Slice<T, (D,), Ly>, )

Accumulate a scaled vector: y := α·x + y

fn dot<Lx: Layout, Ly: Layout>( &self, x: &Slice<T, (D,), Lx>, y: &Slice<T, (D,), Ly>, ) -> T

Dot product: ∑xᵢyᵢ

fn dotc<Lx: Layout, Ly: Layout>( &self, x: &Slice<T, (D,), Lx>, y: &Slice<T, (D,), Ly>, ) -> T

Conjugated dot product: ∑conj(xᵢ) * yᵢ (BLAS convention)

fn norm2<Lx: Layout>(&self, x: &Slice<T, (D,), Lx>) -> Self::Real

L2 norm: √(∑|xᵢ|²)

fn norm1<Lx: Layout>(&self, x: &Slice<T, (D,), Lx>) -> Self::Real

L1 norm (Manhattan) for complex numbers: ∑(|re(xᵢ)| + |im(xᵢ)|). For real numbers this reduces to ∑|xᵢ|.

fn rot<Lx: Layout, Ly: Layout>( &self, x: &mut Slice<T, (D,), Lx>, y: &mut Slice<T, (D,), Ly>, c: Self::Real, s: T, )

Givens rotation