Struct slas::backends::Blas

source · [−]

pub struct Blas;

Expand description

Binding to blas with cblas-sys as a slas backend.

Trait Implementations

source

impl Backend<Complex<f32>> for Blas

source

fn dot<const LEN: usize>(
 &self,
 a: &impl StaticVec<T, LEN>,
 b: &impl StaticVec<T, LEN>
) -> <Self as DotProduct<T>>::DotOutput where
 Self: DotProduct<T>,

source

fn norm<const LEN: usize>(
 &self,
 a: &impl StaticVec<T, LEN>
) -> <Self as Normalize<T>>::NormOutput where
 Self: Normalize<T>,

source

fn normalize<const LEN: usize>(
 &self,
 a: &mut impl StaticVec<T, LEN>
) -> <Self as Normalize<T>>::NormalizeOutput where
 Self: Normalize<T>,
 T: From<<Self as Normalize<T>>::NormOutput>,

source

fn matrix_mul<A: StaticVec<T, ALEN>, B: StaticVec<T, BLEN>, C: StaticVec<T, CLEN>, const ALEN: usize, const BLEN: usize, const CLEN: usize>(
 &self,
 a: &A,
 b: &B,
 buffer: &mut C,
 m: usize,
 n: usize,
 k: usize,
 lda: usize,
 ldb: usize,
 ldc: usize,
 a_trans: bool,
 b_trans: bool
) -> <Self as MatrixMul<T>>::MatrixMulOutput where
 Self: MatrixMul<T>,
 A: Sized,
 B: Sized,
 C: Sized,
 T: Copy,

source

fn matrix_vector_mul<A: StaticVec<T, ALEN>, B: StaticVec<T, BLEN>, C: StaticVec<T, CLEN>, const ALEN: usize, const BLEN: usize, const CLEN: usize>(
 &self,
 a: &A,
 b: &B,
 buffer: &mut C,
 m: usize,
 n: usize,
 lda: usize,
 a_trans: bool
) -> <Self as MatrixMul<T>>::MatrixVectorMulOutput where
 Self: MatrixMul<T>,
 A: Sized,
 B: Sized,
 C: Sized,
 T: Copy,

source

fn transpose_inplace<const LEN: usize>(
 &self,
 a: &mut impl StaticVec<T, LEN>,
 columns: usize
) -> <Self as Transpose<T>>::TransposeInplaceOutput where
 Self: Transpose<T>,

source

fn transpose<const LEN: usize>(
 &self,
 a: &impl StaticVec<T, LEN>,
 buffer: &mut impl StaticVec<T, LEN>,
 columns: usize
) -> <Self as Transpose<T>>::TransposeOutput where
 Self: Transpose<T>,

source

fn add<const LEN: usize>(
 &self,
 a: &impl StaticVec<T, LEN>,
 b: &impl StaticVec<T, LEN>,
 c: &mut impl StaticVec<T, LEN>
) -> <Self as Addition<T>>::AddOutput where
 Self: Addition<T>,

source

fn sub<const LEN: usize>(
 &self,
 a: &impl StaticVec<T, LEN>,
 b: &impl StaticVec<T, LEN>,
 c: &mut impl StaticVec<T, LEN>
) -> <Self as Subtraction<T>>::SubOutput where
 Self: Subtraction<T>,

source

fn mul<const LEN: usize>(
 &self,
 a: &impl StaticVec<T, LEN>,
 b: &impl StaticVec<T, LEN>,
 c: &mut impl StaticVec<T, LEN>
) -> <Self as Multiplication<T>>::MulOutput where
 Self: Multiplication<T>,

source

fn div<const LEN: usize>(
 &self,
 a: &impl StaticVec<T, LEN>,
 b: &impl StaticVec<T, LEN>,
 c: &mut impl StaticVec<T, LEN>
) -> <Self as Divition<T>>::DivOutput where
 Self: Divition<T>,

source

impl Backend<Complex<f64>> for Blas

source

fn dot<const LEN: usize>(
 &self,
 a: &impl StaticVec<T, LEN>,
 b: &impl StaticVec<T, LEN>
) -> <Self as DotProduct<T>>::DotOutput where
 Self: DotProduct<T>,

source

fn norm<const LEN: usize>(
 &self,
 a: &impl StaticVec<T, LEN>
) -> <Self as Normalize<T>>::NormOutput where
 Self: Normalize<T>,

source

fn normalize<const LEN: usize>(
 &self,
 a: &mut impl StaticVec<T, LEN>
) -> <Self as Normalize<T>>::NormalizeOutput where
 Self: Normalize<T>,
 T: From<<Self as Normalize<T>>::NormOutput>,

source

fn matrix_mul<A: StaticVec<T, ALEN>, B: StaticVec<T, BLEN>, C: StaticVec<T, CLEN>, const ALEN: usize, const BLEN: usize, const CLEN: usize>(
 &self,
 a: &A,
 b: &B,
 buffer: &mut C,
 m: usize,
 n: usize,
 k: usize,
 lda: usize,
 ldb: usize,
 ldc: usize,
 a_trans: bool,
 b_trans: bool
) -> <Self as MatrixMul<T>>::MatrixMulOutput where
 Self: MatrixMul<T>,
 A: Sized,
 B: Sized,
 C: Sized,
 T: Copy,

source

fn matrix_vector_mul<A: StaticVec<T, ALEN>, B: StaticVec<T, BLEN>, C: StaticVec<T, CLEN>, const ALEN: usize, const BLEN: usize, const CLEN: usize>(
 &self,
 a: &A,
 b: &B,
 buffer: &mut C,
 m: usize,
 n: usize,
 lda: usize,
 a_trans: bool
) -> <Self as MatrixMul<T>>::MatrixVectorMulOutput where
 Self: MatrixMul<T>,
 A: Sized,
 B: Sized,
 C: Sized,
 T: Copy,

source

fn transpose_inplace<const LEN: usize>(
 &self,
 a: &mut impl StaticVec<T, LEN>,
 columns: usize
) -> <Self as Transpose<T>>::TransposeInplaceOutput where
 Self: Transpose<T>,

source

fn transpose<const LEN: usize>(
 &self,
 a: &impl StaticVec<T, LEN>,
 buffer: &mut impl StaticVec<T, LEN>,
 columns: usize
) -> <Self as Transpose<T>>::TransposeOutput where
 Self: Transpose<T>,

source

fn add<const LEN: usize>(
 &self,
 a: &impl StaticVec<T, LEN>,
 b: &impl StaticVec<T, LEN>,
 c: &mut impl StaticVec<T, LEN>
) -> <Self as Addition<T>>::AddOutput where
 Self: Addition<T>,

source

fn sub<const LEN: usize>(
 &self,
 a: &impl StaticVec<T, LEN>,
 b: &impl StaticVec<T, LEN>,
 c: &mut impl StaticVec<T, LEN>
) -> <Self as Subtraction<T>>::SubOutput where
 Self: Subtraction<T>,

source

fn mul<const LEN: usize>(
 &self,
 a: &impl StaticVec<T, LEN>,
 b: &impl StaticVec<T, LEN>,
 c: &mut impl StaticVec<T, LEN>
) -> <Self as Multiplication<T>>::MulOutput where
 Self: Multiplication<T>,

source

fn div<const LEN: usize>(
 &self,
 a: &impl StaticVec<T, LEN>,
 b: &impl StaticVec<T, LEN>,
 c: &mut impl StaticVec<T, LEN>
) -> <Self as Divition<T>>::DivOutput where
 Self: Divition<T>,

source

impl Backend<f32> for Blas

source

fn dot<const LEN: usize>(
 &self,
 a: &impl StaticVec<T, LEN>,
 b: &impl StaticVec<T, LEN>
) -> <Self as DotProduct<T>>::DotOutput where
 Self: DotProduct<T>,

source

fn norm<const LEN: usize>(
 &self,
 a: &impl StaticVec<T, LEN>
) -> <Self as Normalize<T>>::NormOutput where
 Self: Normalize<T>,

source

fn normalize<const LEN: usize>(
 &self,
 a: &mut impl StaticVec<T, LEN>
) -> <Self as Normalize<T>>::NormalizeOutput where
 Self: Normalize<T>,
 T: From<<Self as Normalize<T>>::NormOutput>,

source

fn matrix_mul<A: StaticVec<T, ALEN>, B: StaticVec<T, BLEN>, C: StaticVec<T, CLEN>, const ALEN: usize, const BLEN: usize, const CLEN: usize>(
 &self,
 a: &A,
 b: &B,
 buffer: &mut C,
 m: usize,
 n: usize,
 k: usize,
 lda: usize,
 ldb: usize,
 ldc: usize,
 a_trans: bool,
 b_trans: bool
) -> <Self as MatrixMul<T>>::MatrixMulOutput where
 Self: MatrixMul<T>,
 A: Sized,
 B: Sized,
 C: Sized,
 T: Copy,

source

fn matrix_vector_mul<A: StaticVec<T, ALEN>, B: StaticVec<T, BLEN>, C: StaticVec<T, CLEN>, const ALEN: usize, const BLEN: usize, const CLEN: usize>(
 &self,
 a: &A,
 b: &B,
 buffer: &mut C,
 m: usize,
 n: usize,
 lda: usize,
 a_trans: bool
) -> <Self as MatrixMul<T>>::MatrixVectorMulOutput where
 Self: MatrixMul<T>,
 A: Sized,
 B: Sized,
 C: Sized,
 T: Copy,

source

fn transpose_inplace<const LEN: usize>(
 &self,
 a: &mut impl StaticVec<T, LEN>,
 columns: usize
) -> <Self as Transpose<T>>::TransposeInplaceOutput where
 Self: Transpose<T>,

source

fn transpose<const LEN: usize>(
 &self,
 a: &impl StaticVec<T, LEN>,
 buffer: &mut impl StaticVec<T, LEN>,
 columns: usize
) -> <Self as Transpose<T>>::TransposeOutput where
 Self: Transpose<T>,

source

fn add<const LEN: usize>(
 &self,
 a: &impl StaticVec<T, LEN>,
 b: &impl StaticVec<T, LEN>,
 c: &mut impl StaticVec<T, LEN>
) -> <Self as Addition<T>>::AddOutput where
 Self: Addition<T>,

source

fn sub<const LEN: usize>(
 &self,
 a: &impl StaticVec<T, LEN>,
 b: &impl StaticVec<T, LEN>,
 c: &mut impl StaticVec<T, LEN>
) -> <Self as Subtraction<T>>::SubOutput where
 Self: Subtraction<T>,

source

fn mul<const LEN: usize>(
 &self,
 a: &impl StaticVec<T, LEN>,
 b: &impl StaticVec<T, LEN>,
 c: &mut impl StaticVec<T, LEN>
) -> <Self as Multiplication<T>>::MulOutput where
 Self: Multiplication<T>,

source

fn div<const LEN: usize>(
 &self,
 a: &impl StaticVec<T, LEN>,
 b: &impl StaticVec<T, LEN>,
 c: &mut impl StaticVec<T, LEN>
) -> <Self as Divition<T>>::DivOutput where
 Self: Divition<T>,

source

impl Backend<f64> for Blas

source

fn dot<const LEN: usize>(
 &self,
 a: &impl StaticVec<T, LEN>,
 b: &impl StaticVec<T, LEN>
) -> <Self as DotProduct<T>>::DotOutput where
 Self: DotProduct<T>,

source

fn norm<const LEN: usize>(
 &self,
 a: &impl StaticVec<T, LEN>
) -> <Self as Normalize<T>>::NormOutput where
 Self: Normalize<T>,

source

fn normalize<const LEN: usize>(
 &self,
 a: &mut impl StaticVec<T, LEN>
) -> <Self as Normalize<T>>::NormalizeOutput where
 Self: Normalize<T>,
 T: From<<Self as Normalize<T>>::NormOutput>,

source

fn matrix_mul<A: StaticVec<T, ALEN>, B: StaticVec<T, BLEN>, C: StaticVec<T, CLEN>, const ALEN: usize, const BLEN: usize, const CLEN: usize>(
 &self,
 a: &A,
 b: &B,
 buffer: &mut C,
 m: usize,
 n: usize,
 k: usize,
 lda: usize,
 ldb: usize,
 ldc: usize,
 a_trans: bool,
 b_trans: bool
) -> <Self as MatrixMul<T>>::MatrixMulOutput where
 Self: MatrixMul<T>,
 A: Sized,
 B: Sized,
 C: Sized,
 T: Copy,

source

fn matrix_vector_mul<A: StaticVec<T, ALEN>, B: StaticVec<T, BLEN>, C: StaticVec<T, CLEN>, const ALEN: usize, const BLEN: usize, const CLEN: usize>(
 &self,
 a: &A,
 b: &B,
 buffer: &mut C,
 m: usize,
 n: usize,
 lda: usize,
 a_trans: bool
) -> <Self as MatrixMul<T>>::MatrixVectorMulOutput where
 Self: MatrixMul<T>,
 A: Sized,
 B: Sized,
 C: Sized,
 T: Copy,

source

fn transpose_inplace<const LEN: usize>(
 &self,
 a: &mut impl StaticVec<T, LEN>,
 columns: usize
) -> <Self as Transpose<T>>::TransposeInplaceOutput where
 Self: Transpose<T>,

source

fn transpose<const LEN: usize>(
 &self,
 a: &impl StaticVec<T, LEN>,
 buffer: &mut impl StaticVec<T, LEN>,
 columns: usize
) -> <Self as Transpose<T>>::TransposeOutput where
 Self: Transpose<T>,

source

fn add<const LEN: usize>(
 &self,
 a: &impl StaticVec<T, LEN>,
 b: &impl StaticVec<T, LEN>,
 c: &mut impl StaticVec<T, LEN>
) -> <Self as Addition<T>>::AddOutput where
 Self: Addition<T>,

source

fn sub<const LEN: usize>(
 &self,
 a: &impl StaticVec<T, LEN>,
 b: &impl StaticVec<T, LEN>,
 c: &mut impl StaticVec<T, LEN>
) -> <Self as Subtraction<T>>::SubOutput where
 Self: Subtraction<T>,

source

fn mul<const LEN: usize>(
 &self,
 a: &impl StaticVec<T, LEN>,
 b: &impl StaticVec<T, LEN>,
 c: &mut impl StaticVec<T, LEN>
) -> <Self as Multiplication<T>>::MulOutput where
 Self: Multiplication<T>,

source

fn div<const LEN: usize>(
 &self,
 a: &impl StaticVec<T, LEN>,
 b: &impl StaticVec<T, LEN>,
 c: &mut impl StaticVec<T, LEN>
) -> <Self as Divition<T>>::DivOutput where
 Self: Divition<T>,

source

impl Clone for Blas

source

fn clone(&self) -> Blas

Returns a copy of the value. Read more

1.0.0 · source

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

Performs copy-assignment from source. Read more

source

impl Default for Blas

source

fn default() -> Blas

Returns the “default value” for a type. Read more

source

impl DotProduct<Complex<f32>> for Blas

Dot product for two complex vectors. Also has support for multiple (and mixed) types.

source

fn dot<const LEN: usize>(
 &self,
 a: &impl StaticVec<Complex<f32>, LEN>,
 b: &impl StaticVec<Complex<f32>, LEN>
) -> Complex<f32>

type DotOutput = T

source

impl DotProduct<Complex<f64>> for Blas

Dot product for two complex vectors. Also has support for multiple (and mixed) types.

source

fn dot<const LEN: usize>(
 &self,
 a: &impl StaticVec<Complex<f64>, LEN>,
 b: &impl StaticVec<Complex<f64>, LEN>
) -> Complex<f64>

type DotOutput = T

source

impl DotProduct<f32> for Blas

Thin wrapper around blas for the various dot product functions that works for multiple different (and mixed) vector types.

Example

use slas::prelude::*;
assert!(slas_backend::Blas.dot(&[1., 2., 3.], &moo![f32: -1, 2, -1]) == 0.);

source

fn dot<const LEN: usize>(
 &self,
 a: &impl StaticVec<f32, LEN>,
 b: &impl StaticVec<f32, LEN>
) -> f32

type DotOutput = T

source

impl DotProduct<f64> for Blas

Thin wrapper around blas for the various dot product functions that works for multiple different (and mixed) vector types.

Example

use slas::prelude::*;
assert!(slas_backend::Blas.dot(&[1., 2., 3.], &moo![f32: -1, 2, -1]) == 0.);

source

fn dot<const LEN: usize>(
 &self,
 a: &impl StaticVec<f64, LEN>,
 b: &impl StaticVec<f64, LEN>
) -> f64

type DotOutput = T

source

impl MatrixMul<f32> for Blas

This is matrix multiplication, NOT element wise multiplication. Take a look at wiki, 3Blue1Brown at yt and/or Khan Academy for more information.

It’s notable that your left hand matrix needs to be as wide as the right hand matrix is tall.

source

fn matrix_vector_mul<A: StaticVec<f32, ALEN>, B: StaticVec<f32, BLEN>, C: StaticVec<f32, CLEN>, const ALEN: usize, const BLEN: usize, const CLEN: usize>(
 &self,
 a: &A,
 b: &B,
 buffer: &mut C,
 m: usize,
 n: usize,
 lda: usize,
 a_trans: bool
) where
 A: Sized,
 B: Sized,

Matrix-vector multiplication using gemv.

source

fn matrix_mul<A: StaticVec<f32, ALEN>, B: StaticVec<f32, BLEN>, C: StaticVec<f32, CLEN>, const ALEN: usize, const BLEN: usize, const CLEN: usize>(
 &self,
 a: &A,
 b: &B,
 buffer: &mut C,
 m: usize,
 n: usize,
 k: usize,
 lda: usize,
 ldb: usize,
 ldc: usize,
 a_trans: bool,
 b_trans: bool
) where
 A: Sized,
 B: Sized,

type MatrixMulOutput = ()

type MatrixVectorMulOutput = ()

source

impl MatrixMul<f64> for Blas

This is matrix multiplication, NOT element wise multiplication. Take a look at wiki, 3Blue1Brown at yt and/or Khan Academy for more information.

It’s notable that your left hand matrix needs to be as wide as the right hand matrix is tall.

source

fn matrix_vector_mul<A: StaticVec<f64, ALEN>, B: StaticVec<f64, BLEN>, C: StaticVec<f64, CLEN>, const ALEN: usize, const BLEN: usize, const CLEN: usize>(
 &self,
 a: &A,
 b: &B,
 buffer: &mut C,
 m: usize,
 n: usize,
 lda: usize,
 a_trans: bool
) where
 A: Sized,
 B: Sized,

Matrix-vector multiplication using gemv.

source

fn matrix_mul<A: StaticVec<f64, ALEN>, B: StaticVec<f64, BLEN>, C: StaticVec<f64, CLEN>, const ALEN: usize, const BLEN: usize, const CLEN: usize>(
 &self,
 a: &A,
 b: &B,
 buffer: &mut C,
 m: usize,
 n: usize,
 k: usize,
 lda: usize,
 ldb: usize,
 ldc: usize,
 a_trans: bool,
 b_trans: bool
) where
 A: Sized,
 B: Sized,

type MatrixMulOutput = ()

type MatrixVectorMulOutput = ()

source

impl Normalize<Complex<f32>> for Blas

type NormOutput = f32

source

fn norm<const LEN: usize>(&self, a: &impl StaticVec<Complex<f32>, LEN>) -> f32

source

fn normalize<const LEN: usize>(&self, a: &mut impl StaticVec<Complex<f32>, LEN>)

type NormalizeOutput = ()

source

impl Normalize<Complex<f64>> for Blas

type NormOutput = f64

source

fn norm<const LEN: usize>(&self, a: &impl StaticVec<Complex<f64>, LEN>) -> f64

source

fn normalize<const LEN: usize>(&self, a: &mut impl StaticVec<Complex<f64>, LEN>)

type NormalizeOutput = ()

source

impl Normalize<f32> for Blas

type NormOutput = f32

source

fn norm<const LEN: usize>(&self, a: &impl StaticVec<f32, LEN>) -> f32

source

fn normalize<const LEN: usize>(&self, a: &mut impl StaticVec<f32, LEN>)

type NormalizeOutput = ()

source

impl Normalize<f64> for Blas

type NormOutput = f64

source

fn norm<const LEN: usize>(&self, a: &impl StaticVec<f64, LEN>) -> f64

source

fn normalize<const LEN: usize>(&self, a: &mut impl StaticVec<f64, LEN>)

type NormalizeOutput = ()

source

impl Copy for Blas

Auto Trait Implementations

impl RefUnwindSafe for Blas

impl Send for Blas

impl Sync for Blas

impl Unpin for Blas

impl UnwindSafe for Blas

Blanket Implementations

source

impl<T> Any for T where
T: 'static + ?Sized,

source

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

source

impl<T> Borrow<T> for T where
T: ?Sized,

const: unstable · source

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

source

impl<T> BorrowMut<T> for T where
T: ?Sized,

const: unstable · source

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

source

impl<T> From<T> for T

const: unstable · source

fn from(t: T) -> T

Returns the argument unchanged.

source

impl<T, U> Into for T where
U: From<T>,

const: unstable · source

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source

impl<T> ToOwned for T where
T: Clone,

type Owned = T

The resulting type after obtaining ownership.

source

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more

source

fn clone_into(&self, target: &mut T)

🔬 This is a nightly-only experimental API. (toowned_clone_into)

Uses borrowed data to replace owned data, usually by cloning. Read more

source

impl<T, U> TryFrom for T where
U: Into<T>,

type Error = Infallible

The type returned in the event of a conversion error.

const: unstable · source

fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>

Performs the conversion.

source

impl<T, U> TryInto for T where
U: TryFrom<T>,

type Error = >::Error

The type returned in the event of a conversion error.

const: unstable · source

fn try_into(self) -> Result<U, >::Error>

Performs the conversion.

Struct slas::backends::Blas

Trait Implementations

impl Backend<Complex<f32>> for Blas

fn dot<const LEN: usize>( &self, a: &impl StaticVec<T, LEN>, b: &impl StaticVec<T, LEN>) -> <Self as DotProduct<T>>::DotOutput where Self: DotProduct<T>,

fn norm<const LEN: usize>( &self, a: &impl StaticVec<T, LEN>) -> <Self as Normalize<T>>::NormOutput where Self: Normalize<T>,

fn normalize<const LEN: usize>( &self, a: &mut impl StaticVec<T, LEN>) -> <Self as Normalize<T>>::NormalizeOutput where Self: Normalize<T>, T: From<<Self as Normalize<T>>::NormOutput>,

fn transpose_inplace<const LEN: usize>( &self, a: &mut impl StaticVec<T, LEN>, columns: usize) -> <Self as Transpose<T>>::TransposeInplaceOutput where Self: Transpose<T>,

fn transpose<const LEN: usize>( &self, a: &impl StaticVec<T, LEN>, buffer: &mut impl StaticVec<T, LEN>, columns: usize) -> <Self as Transpose<T>>::TransposeOutput where Self: Transpose<T>,

fn add<const LEN: usize>( &self, a: &impl StaticVec<T, LEN>, b: &impl StaticVec<T, LEN>, c: &mut impl StaticVec<T, LEN>) -> <Self as Addition<T>>::AddOutput where Self: Addition<T>,

fn sub<const LEN: usize>( &self, a: &impl StaticVec<T, LEN>, b: &impl StaticVec<T, LEN>, c: &mut impl StaticVec<T, LEN>) -> <Self as Subtraction<T>>::SubOutput where Self: Subtraction<T>,

fn mul<const LEN: usize>( &self, a: &impl StaticVec<T, LEN>, b: &impl StaticVec<T, LEN>, c: &mut impl StaticVec<T, LEN>) -> <Self as Multiplication<T>>::MulOutput where Self: Multiplication<T>,

fn div<const LEN: usize>( &self, a: &impl StaticVec<T, LEN>, b: &impl StaticVec<T, LEN>, c: &mut impl StaticVec<T, LEN>) -> <Self as Divition<T>>::DivOutput where Self: Divition<T>,

impl Backend<Complex<f64>> for Blas

fn dot<const LEN: usize>( &self, a: &impl StaticVec<T, LEN>, b: &impl StaticVec<T, LEN>) -> <Self as DotProduct<T>>::DotOutput where Self: DotProduct<T>,

fn norm<const LEN: usize>( &self, a: &impl StaticVec<T, LEN>) -> <Self as Normalize<T>>::NormOutput where Self: Normalize<T>,

fn normalize<const LEN: usize>( &self, a: &mut impl StaticVec<T, LEN>) -> <Self as Normalize<T>>::NormalizeOutput where Self: Normalize<T>, T: From<<Self as Normalize<T>>::NormOutput>,

fn transpose_inplace<const LEN: usize>( &self, a: &mut impl StaticVec<T, LEN>, columns: usize) -> <Self as Transpose<T>>::TransposeInplaceOutput where Self: Transpose<T>,

fn transpose<const LEN: usize>( &self, a: &impl StaticVec<T, LEN>, buffer: &mut impl StaticVec<T, LEN>, columns: usize) -> <Self as Transpose<T>>::TransposeOutput where Self: Transpose<T>,

fn add<const LEN: usize>( &self, a: &impl StaticVec<T, LEN>, b: &impl StaticVec<T, LEN>, c: &mut impl StaticVec<T, LEN>) -> <Self as Addition<T>>::AddOutput where Self: Addition<T>,

fn sub<const LEN: usize>( &self, a: &impl StaticVec<T, LEN>, b: &impl StaticVec<T, LEN>, c: &mut impl StaticVec<T, LEN>) -> <Self as Subtraction<T>>::SubOutput where Self: Subtraction<T>,

fn mul<const LEN: usize>( &self, a: &impl StaticVec<T, LEN>, b: &impl StaticVec<T, LEN>, c: &mut impl StaticVec<T, LEN>) -> <Self as Multiplication<T>>::MulOutput where Self: Multiplication<T>,

fn div<const LEN: usize>( &self, a: &impl StaticVec<T, LEN>, b: &impl StaticVec<T, LEN>, c: &mut impl StaticVec<T, LEN>) -> <Self as Divition<T>>::DivOutput where Self: Divition<T>,

impl Backend<f32> for Blas

fn dot<const LEN: usize>( &self, a: &impl StaticVec<T, LEN>, b: &impl StaticVec<T, LEN>) -> <Self as DotProduct<T>>::DotOutput where Self: DotProduct<T>,

fn norm<const LEN: usize>( &self, a: &impl StaticVec<T, LEN>) -> <Self as Normalize<T>>::NormOutput where Self: Normalize<T>,

fn normalize<const LEN: usize>( &self, a: &mut impl StaticVec<T, LEN>) -> <Self as Normalize<T>>::NormalizeOutput where Self: Normalize<T>, T: From<<Self as Normalize<T>>::NormOutput>,

fn transpose_inplace<const LEN: usize>( &self, a: &mut impl StaticVec<T, LEN>, columns: usize) -> <Self as Transpose<T>>::TransposeInplaceOutput where Self: Transpose<T>,

fn transpose<const LEN: usize>( &self, a: &impl StaticVec<T, LEN>, buffer: &mut impl StaticVec<T, LEN>, columns: usize) -> <Self as Transpose<T>>::TransposeOutput where Self: Transpose<T>,

fn add<const LEN: usize>( &self, a: &impl StaticVec<T, LEN>, b: &impl StaticVec<T, LEN>, c: &mut impl StaticVec<T, LEN>) -> <Self as Addition<T>>::AddOutput where Self: Addition<T>,

fn sub<const LEN: usize>( &self, a: &impl StaticVec<T, LEN>, b: &impl StaticVec<T, LEN>, c: &mut impl StaticVec<T, LEN>) -> <Self as Subtraction<T>>::SubOutput where Self: Subtraction<T>,

fn mul<const LEN: usize>( &self, a: &impl StaticVec<T, LEN>, b: &impl StaticVec<T, LEN>, c: &mut impl StaticVec<T, LEN>) -> <Self as Multiplication<T>>::MulOutput where Self: Multiplication<T>,

fn div<const LEN: usize>( &self, a: &impl StaticVec<T, LEN>, b: &impl StaticVec<T, LEN>, c: &mut impl StaticVec<T, LEN>) -> <Self as Divition<T>>::DivOutput where Self: Divition<T>,

impl Backend<f64> for Blas

fn dot<const LEN: usize>( &self, a: &impl StaticVec<T, LEN>, b: &impl StaticVec<T, LEN>) -> <Self as DotProduct<T>>::DotOutput where Self: DotProduct<T>,

fn norm<const LEN: usize>( &self, a: &impl StaticVec<T, LEN>) -> <Self as Normalize<T>>::NormOutput where Self: Normalize<T>,

fn normalize<const LEN: usize>( &self, a: &mut impl StaticVec<T, LEN>) -> <Self as Normalize<T>>::NormalizeOutput where Self: Normalize<T>, T: From<<Self as Normalize<T>>::NormOutput>,

fn transpose_inplace<const LEN: usize>( &self, a: &mut impl StaticVec<T, LEN>, columns: usize) -> <Self as Transpose<T>>::TransposeInplaceOutput where Self: Transpose<T>,

fn transpose<const LEN: usize>( &self, a: &impl StaticVec<T, LEN>, buffer: &mut impl StaticVec<T, LEN>, columns: usize) -> <Self as Transpose<T>>::TransposeOutput where Self: Transpose<T>,

fn add<const LEN: usize>( &self, a: &impl StaticVec<T, LEN>, b: &impl StaticVec<T, LEN>, c: &mut impl StaticVec<T, LEN>) -> <Self as Addition<T>>::AddOutput where Self: Addition<T>,

fn sub<const LEN: usize>( &self, a: &impl StaticVec<T, LEN>, b: &impl StaticVec<T, LEN>, c: &mut impl StaticVec<T, LEN>) -> <Self as Subtraction<T>>::SubOutput where Self: Subtraction<T>,

fn mul<const LEN: usize>( &self, a: &impl StaticVec<T, LEN>, b: &impl StaticVec<T, LEN>, c: &mut impl StaticVec<T, LEN>) -> <Self as Multiplication<T>>::MulOutput where Self: Multiplication<T>,

fn div<const LEN: usize>( &self, a: &impl StaticVec<T, LEN>, b: &impl StaticVec<T, LEN>, c: &mut impl StaticVec<T, LEN>) -> <Self as Divition<T>>::DivOutput where Self: Divition<T>,

impl Clone for Blas

fn clone(&self) -> Blas

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

impl Default for Blas

fn default() -> Blas

impl DotProduct<Complex<f32>> for Blas

fn dot<const LEN: usize>( &self, a: &impl StaticVec<Complex<f32>, LEN>, b: &impl StaticVec<Complex<f32>, LEN>) -> Complex<f32>

type DotOutput = T

impl DotProduct<Complex<f64>> for Blas

fn dot<const LEN: usize>( &self, a: &impl StaticVec<Complex<f64>, LEN>, b: &impl StaticVec<Complex<f64>, LEN>) -> Complex<f64>

type DotOutput = T

impl DotProduct<f32> for Blas

Example

fn dot<const LEN: usize>( &self, a: &impl StaticVec<f32, LEN>, b: &impl StaticVec<f32, LEN>) -> f32

type DotOutput = T

impl DotProduct<f64> for Blas

Example

fn dot<const LEN: usize>( &self, a: &impl StaticVec<f64, LEN>, b: &impl StaticVec<f64, LEN>) -> f64

type DotOutput = T

impl MatrixMul<f32> for Blas

fn matrix_vector_mul<A: StaticVec<f32, ALEN>, B: StaticVec<f32, BLEN>, C: StaticVec<f32, CLEN>, const ALEN: usize, const BLEN: usize, const CLEN: usize>( &self, a: &A, b: &B, buffer: &mut C, m: usize, n: usize, lda: usize, a_trans: bool) where A: Sized, B: Sized,

type MatrixMulOutput = ()

type MatrixVectorMulOutput = ()

impl MatrixMul<f64> for Blas

fn matrix_vector_mul<A: StaticVec<f64, ALEN>, B: StaticVec<f64, BLEN>, C: StaticVec<f64, CLEN>, const ALEN: usize, const BLEN: usize, const CLEN: usize>( &self, a: &A, b: &B, buffer: &mut C, m: usize, n: usize, lda: usize, a_trans: bool) where A: Sized, B: Sized,

type MatrixMulOutput = ()

type MatrixVectorMulOutput = ()

impl Normalize<Complex<f32>> for Blas

type NormOutput = f32

fn norm<const LEN: usize>(&self, a: &impl StaticVec<Complex<f32>, LEN>) -> f32

fn normalize<const LEN: usize>(&self, a: &mut impl StaticVec<Complex<f32>, LEN>)

type NormalizeOutput = ()

impl Normalize<Complex<f64>> for Blas

type NormOutput = f64

fn norm<const LEN: usize>(&self, a: &impl StaticVec<Complex<f64>, LEN>) -> f64

fn normalize<const LEN: usize>(&self, a: &mut impl StaticVec<Complex<f64>, LEN>)

type NormalizeOutput = ()

impl Normalize<f32> for Blas

fn dot<const LEN: usize>(
&self,
a: &impl StaticVec<T, LEN>,
b: &impl StaticVec<T, LEN>
) -> <Self as DotProduct<T>>::DotOutput where
Self: DotProduct<T>,

fn norm<const LEN: usize>(
&self,
a: &impl StaticVec<T, LEN>
) -> <Self as Normalize<T>>::NormOutput where
Self: Normalize<T>,

fn normalize<const LEN: usize>(
&self,
a: &mut impl StaticVec<T, LEN>
) -> <Self as Normalize<T>>::NormalizeOutput where
Self: Normalize<T>,
T: From<<Self as Normalize<T>>::NormOutput>,

fn transpose_inplace<const LEN: usize>(
&self,
a: &mut impl StaticVec<T, LEN>,
columns: usize
) -> <Self as Transpose<T>>::TransposeInplaceOutput where
Self: Transpose<T>,

fn transpose<const LEN: usize>(
&self,
a: &impl StaticVec<T, LEN>,
buffer: &mut impl StaticVec<T, LEN>,
columns: usize
) -> <Self as Transpose<T>>::TransposeOutput where
Self: Transpose<T>,

fn add<const LEN: usize>(
&self,
a: &impl StaticVec<T, LEN>,
b: &impl StaticVec<T, LEN>,
c: &mut impl StaticVec<T, LEN>
) -> <Self as Addition<T>>::AddOutput where
Self: Addition<T>,

fn sub<const LEN: usize>(
&self,
a: &impl StaticVec<T, LEN>,
b: &impl StaticVec<T, LEN>,
c: &mut impl StaticVec<T, LEN>
) -> <Self as Subtraction<T>>::SubOutput where
Self: Subtraction<T>,

fn mul<const LEN: usize>(
&self,
a: &impl StaticVec<T, LEN>,
b: &impl StaticVec<T, LEN>,
c: &mut impl StaticVec<T, LEN>
) -> <Self as Multiplication<T>>::MulOutput where
Self: Multiplication<T>,

fn div<const LEN: usize>(
&self,
a: &impl StaticVec<T, LEN>,
b: &impl StaticVec<T, LEN>,
c: &mut impl StaticVec<T, LEN>
) -> <Self as Divition<T>>::DivOutput where
Self: Divition<T>,

fn dot<const LEN: usize>(
&self,
a: &impl StaticVec<T, LEN>,
b: &impl StaticVec<T, LEN>
) -> <Self as DotProduct<T>>::DotOutput where
Self: DotProduct<T>,

fn norm<const LEN: usize>(
&self,
a: &impl StaticVec<T, LEN>
) -> <Self as Normalize<T>>::NormOutput where
Self: Normalize<T>,

fn normalize<const LEN: usize>(
&self,
a: &mut impl StaticVec<T, LEN>
) -> <Self as Normalize<T>>::NormalizeOutput where
Self: Normalize<T>,
T: From<<Self as Normalize<T>>::NormOutput>,

fn transpose_inplace<const LEN: usize>(
&self,
a: &mut impl StaticVec<T, LEN>,
columns: usize
) -> <Self as Transpose<T>>::TransposeInplaceOutput where
Self: Transpose<T>,

fn transpose<const LEN: usize>(
&self,
a: &impl StaticVec<T, LEN>,
buffer: &mut impl StaticVec<T, LEN>,
columns: usize
) -> <Self as Transpose<T>>::TransposeOutput where
Self: Transpose<T>,

fn add<const LEN: usize>(
&self,
a: &impl StaticVec<T, LEN>,
b: &impl StaticVec<T, LEN>,
c: &mut impl StaticVec<T, LEN>
) -> <Self as Addition<T>>::AddOutput where
Self: Addition<T>,

fn sub<const LEN: usize>(
&self,
a: &impl StaticVec<T, LEN>,
b: &impl StaticVec<T, LEN>,
c: &mut impl StaticVec<T, LEN>
) -> <Self as Subtraction<T>>::SubOutput where
Self: Subtraction<T>,

fn mul<const LEN: usize>(
&self,
a: &impl StaticVec<T, LEN>,
b: &impl StaticVec<T, LEN>,
c: &mut impl StaticVec<T, LEN>
) -> <Self as Multiplication<T>>::MulOutput where
Self: Multiplication<T>,

fn div<const LEN: usize>(
&self,
a: &impl StaticVec<T, LEN>,
b: &impl StaticVec<T, LEN>,
c: &mut impl StaticVec<T, LEN>
) -> <Self as Divition<T>>::DivOutput where
Self: Divition<T>,

fn dot<const LEN: usize>(
&self,
a: &impl StaticVec<T, LEN>,
b: &impl StaticVec<T, LEN>
) -> <Self as DotProduct<T>>::DotOutput where
Self: DotProduct<T>,

fn norm<const LEN: usize>(
&self,
a: &impl StaticVec<T, LEN>
) -> <Self as Normalize<T>>::NormOutput where
Self: Normalize<T>,

fn normalize<const LEN: usize>(
&self,
a: &mut impl StaticVec<T, LEN>
) -> <Self as Normalize<T>>::NormalizeOutput where
Self: Normalize<T>,
T: From<<Self as Normalize<T>>::NormOutput>,

fn transpose_inplace<const LEN: usize>(
&self,
a: &mut impl StaticVec<T, LEN>,
columns: usize
) -> <Self as Transpose<T>>::TransposeInplaceOutput where
Self: Transpose<T>,

fn transpose<const LEN: usize>(
&self,
a: &impl StaticVec<T, LEN>,
buffer: &mut impl StaticVec<T, LEN>,
columns: usize
) -> <Self as Transpose<T>>::TransposeOutput where
Self: Transpose<T>,

fn add<const LEN: usize>(
&self,
a: &impl StaticVec<T, LEN>,
b: &impl StaticVec<T, LEN>,
c: &mut impl StaticVec<T, LEN>
) -> <Self as Addition<T>>::AddOutput where
Self: Addition<T>,

fn sub<const LEN: usize>(
&self,
a: &impl StaticVec<T, LEN>,
b: &impl StaticVec<T, LEN>,
c: &mut impl StaticVec<T, LEN>
) -> <Self as Subtraction<T>>::SubOutput where
Self: Subtraction<T>,

fn mul<const LEN: usize>(
&self,
a: &impl StaticVec<T, LEN>,
b: &impl StaticVec<T, LEN>,
c: &mut impl StaticVec<T, LEN>
) -> <Self as Multiplication<T>>::MulOutput where
Self: Multiplication<T>,

fn div<const LEN: usize>(
&self,
a: &impl StaticVec<T, LEN>,
b: &impl StaticVec<T, LEN>,
c: &mut impl StaticVec<T, LEN>
) -> <Self as Divition<T>>::DivOutput where
Self: Divition<T>,

fn dot<const LEN: usize>(
&self,
a: &impl StaticVec<T, LEN>,
b: &impl StaticVec<T, LEN>
) -> <Self as DotProduct<T>>::DotOutput where
Self: DotProduct<T>,

fn norm<const LEN: usize>(
&self,
a: &impl StaticVec<T, LEN>
) -> <Self as Normalize<T>>::NormOutput where
Self: Normalize<T>,

fn normalize<const LEN: usize>(
&self,
a: &mut impl StaticVec<T, LEN>
) -> <Self as Normalize<T>>::NormalizeOutput where
Self: Normalize<T>,
T: From<<Self as Normalize<T>>::NormOutput>,

fn transpose_inplace<const LEN: usize>(
&self,
a: &mut impl StaticVec<T, LEN>,
columns: usize
) -> <Self as Transpose<T>>::TransposeInplaceOutput where
Self: Transpose<T>,

fn transpose<const LEN: usize>(
&self,
a: &impl StaticVec<T, LEN>,
buffer: &mut impl StaticVec<T, LEN>,
columns: usize
) -> <Self as Transpose<T>>::TransposeOutput where
Self: Transpose<T>,

fn add<const LEN: usize>(
&self,
a: &impl StaticVec<T, LEN>,
b: &impl StaticVec<T, LEN>,
c: &mut impl StaticVec<T, LEN>
) -> <Self as Addition<T>>::AddOutput where
Self: Addition<T>,

fn sub<const LEN: usize>(
&self,
a: &impl StaticVec<T, LEN>,
b: &impl StaticVec<T, LEN>,
c: &mut impl StaticVec<T, LEN>
) -> <Self as Subtraction<T>>::SubOutput where
Self: Subtraction<T>,

fn mul<const LEN: usize>(
&self,
a: &impl StaticVec<T, LEN>,
b: &impl StaticVec<T, LEN>,
c: &mut impl StaticVec<T, LEN>
) -> <Self as Multiplication<T>>::MulOutput where
Self: Multiplication<T>,

fn div<const LEN: usize>(
&self,
a: &impl StaticVec<T, LEN>,
b: &impl StaticVec<T, LEN>,
c: &mut impl StaticVec<T, LEN>
) -> <Self as Divition<T>>::DivOutput where
Self: Divition<T>,

fn dot<const LEN: usize>(
&self,
a: &impl StaticVec<Complex<f32>, LEN>,
b: &impl StaticVec<Complex<f32>, LEN>
) -> Complex<f32>

fn dot<const LEN: usize>(
&self,
a: &impl StaticVec<Complex<f64>, LEN>,
b: &impl StaticVec<Complex<f64>, LEN>
) -> Complex<f64>

fn dot<const LEN: usize>(
&self,
a: &impl StaticVec<f32, LEN>,
b: &impl StaticVec<f32, LEN>
) -> f32

fn dot<const LEN: usize>(
&self,
a: &impl StaticVec<f64, LEN>,
b: &impl StaticVec<f64, LEN>
) -> f64

fn matrix_vector_mul<A: StaticVec<f32, ALEN>, B: StaticVec<f32, BLEN>, C: StaticVec<f32, CLEN>, const ALEN: usize, const BLEN: usize, const CLEN: usize>(
&self,
a: &A,
b: &B,
buffer: &mut C,
m: usize,
n: usize,
lda: usize,
a_trans: bool
) where
A: Sized,
B: Sized,

fn matrix_vector_mul<A: StaticVec<f64, ALEN>, B: StaticVec<f64, BLEN>, C: StaticVec<f64, CLEN>, const ALEN: usize, const BLEN: usize, const CLEN: usize>(
&self,
a: &A,
b: &B,
buffer: &mut C,
m: usize,
n: usize,
lda: usize,
a_trans: bool
) where
A: Sized,
B: Sized,

impl<T> Any for T where
T: 'static + ?Sized,

impl<T> Borrow<T> for T where
T: ?Sized,

impl<T> BorrowMut<T> for T where
T: ?Sized,

impl<T, U> Into<U> for T where
U: From<T>,

impl<T> ToOwned for T where
T: Clone,

impl<T, U> TryFrom<U> for T where
U: Into<T>,

impl<T, U> TryInto<U> for T where
U: TryFrom<T>,