Struct DeviceOpenBLAS 

pub struct DeviceOpenBLAS { /* private fields */ }

Implementations

impl DeviceOpenBLAS

pub fn new(num_threads: usize) -> Self

Trait Implementations

impl BlasThreadAPI for DeviceOpenBLAS

fn get_blas_num_threads(&self) -> usize

Get the number of threads used by the BLAS library.

fn set_blas_num_threads(&self, nthreads: usize)

Set the number of threads used by the BLAS library.

fn with_blas_num_threads<T>(&self, nthreads: usize, f: impl FnOnce() -> T) -> T

Set the number of threads in closure.

impl<'a, T, D, R: DataAPI<Data = Vec<T>>> CholeskyAPI<DeviceOpenBLAS> for &'a TensorAny<R, T, DeviceOpenBLAS, D>

where T: BlasFloat, D: DimAPI, (&'a TensorAny<R, T, DeviceOpenBLAS, D>, Option<FlagUpLo>): CholeskyAPI<DeviceOpenBLAS>,

type Out = <(&'a TensorBase<Storage<R, T, DeviceOpenBLAS>, D>, Option<FlagUpLo>) as CholeskyAPI<DeviceOpenBLAS>>::Out

fn cholesky_f(self) -> Result<Self::Out>

fn cholesky(self) -> Self::Out

where Self: Sized,

impl<T, D, R: DataAPI<Data = Vec<T>>> CholeskyAPI<DeviceOpenBLAS> for (&TensorAny<R, T, DeviceOpenBLAS, D>, Option<FlagUpLo>)

where T: BlasFloat, D: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, D>

fn cholesky_f(self) -> Result<Self::Out>

fn cholesky(self) -> Self::Out

where Self: Sized,

impl<'a, T, D> CholeskyAPI<DeviceOpenBLAS> for (TensorMut<'a, T, DeviceOpenBLAS, D>, Option<FlagUpLo>)

where T: BlasFloat, D: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = TensorBase<Storage<DataMut<'a, <DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, D>

fn cholesky_f(self) -> Result<Self::Out>

fn cholesky(self) -> Self::Out

where Self: Sized,

impl<T, D> CholeskyAPI<DeviceOpenBLAS> for (Tensor<T, DeviceOpenBLAS, D>, Option<FlagUpLo>)

where T: BlasFloat, D: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, D>

fn cholesky_f(self) -> Result<Self::Out>

fn cholesky(self) -> Self::Out

where Self: Sized,

impl<T, D> CholeskyAPI<DeviceOpenBLAS> for (TensorView<'_, T, DeviceOpenBLAS, D>, Option<FlagUpLo>)

where T: BlasFloat, D: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, D>

fn cholesky_f(self) -> Result<Self::Out>

fn cholesky(self) -> Self::Out

where Self: Sized,

impl<Tr> CholeskyAPI<DeviceOpenBLAS> for (Tr, FlagUpLo)

where (Tr, Option<FlagUpLo>): CholeskyAPI<DeviceOpenBLAS>,

type Out = <(Tr, Option<FlagUpLo>) as CholeskyAPI<DeviceOpenBLAS>>::Out

fn cholesky_f(self) -> Result<Self::Out>

fn cholesky(self) -> Self::Out

where Self: Sized,

impl<'a, T, D> CholeskyAPI<DeviceOpenBLAS> for TensorMut<'a, T, DeviceOpenBLAS, D>

where T: BlasFloat, D: DimAPI, (TensorMut<'a, T, DeviceOpenBLAS, D>, Option<FlagUpLo>): CholeskyAPI<DeviceOpenBLAS>,

type Out = <(TensorBase<Storage<DataMut<'a, <DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, D>, Option<FlagUpLo>) as CholeskyAPI<DeviceOpenBLAS>>::Out

fn cholesky_f(self) -> Result<Self::Out>

fn cholesky(self) -> Self::Out

where Self: Sized,

impl<T, D> CholeskyAPI<DeviceOpenBLAS> for Tensor<T, DeviceOpenBLAS, D>

where T: BlasFloat, D: DimAPI, (Tensor<T, DeviceOpenBLAS, D>, Option<FlagUpLo>): CholeskyAPI<DeviceOpenBLAS>,

type Out = <(TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, D>, Option<FlagUpLo>) as CholeskyAPI<DeviceOpenBLAS>>::Out

fn cholesky_f(self) -> Result<Self::Out>

fn cholesky(self) -> Self::Out

where Self: Sized,

impl<'a, T, D> CholeskyAPI<DeviceOpenBLAS> for TensorView<'a, T, DeviceOpenBLAS, D>

where T: BlasFloat, D: DimAPI, (TensorView<'a, T, DeviceOpenBLAS, D>, Option<FlagUpLo>): CholeskyAPI<DeviceOpenBLAS>,

type Out = <(TensorBase<Storage<DataRef<'a, <DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, D>, Option<FlagUpLo>) as CholeskyAPI<DeviceOpenBLAS>>::Out

fn cholesky_f(self) -> Result<Self::Out>

fn cholesky(self) -> Self::Out

where Self: Sized,

impl Clone for DeviceOpenBLAS

fn clone(&self) -> DeviceOpenBLAS

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DeviceOpenBLAS

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

Formats the value using the given formatter.

impl Default for DeviceOpenBLAS

fn default() -> Self

Returns the “default value” for a type.

impl<T, D, R: DataAPI<Data = Vec<T>>> DetAPI<DeviceOpenBLAS> for &TensorAny<R, T, DeviceOpenBLAS, D>

where T: BlasFloat, D: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = T

fn det_f(self) -> Result<Self::Out>

fn det(self) -> Self::Out

where Self: Sized,

impl<'a, T, D> DetAPI<DeviceOpenBLAS> for TensorMut<'a, T, DeviceOpenBLAS, D>

where T: BlasFloat, D: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = T

fn det_f(self) -> Result<Self::Out>

fn det(self) -> Self::Out

where Self: Sized,

impl<T, D> DetAPI<DeviceOpenBLAS> for Tensor<T, DeviceOpenBLAS, D>

where T: BlasFloat, D: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = T

fn det_f(self) -> Result<Self::Out>

fn det(self) -> Self::Out

where Self: Sized,

impl<T, D> DetAPI<DeviceOpenBLAS> for TensorView<'_, T, DeviceOpenBLAS, D>

where T: BlasFloat, D: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = T

fn det_f(self) -> Result<Self::Out>

fn det(self) -> Self::Out

where Self: Sized,

impl<T, D> DeviceATan2API<T, T, D> for DeviceOpenBLAS

where T: Clone + Send + Sync + Float, D: DimAPI,

type TOut = T

fn op_mutc_refa_refb( &self, c: &mut Vec<T>, lc: &Layout<D>, a: &Vec<T>, la: &Layout<D>, b: &Vec<T>, lb: &Layout<D>, ) -> Result<()>

fn op_mutc_refa_numb( &self, c: &mut Vec<T>, lc: &Layout<D>, a: &Vec<T>, la: &Layout<D>, b: T, ) -> Result<()>

fn op_mutc_numa_refb( &self, c: &mut <Self as DeviceRawAPI<Self::TOut>>::Raw, lc: &Layout<D>, a: T, b: &<Self as DeviceRawAPI<T>>::Raw, lb: &Layout<D>, ) -> Result<()>

impl<T, D> DeviceAbsAPI<T, D> for DeviceOpenBLAS

where T: Clone + Send + Sync + AbsAPI, T::Out: Send + Sync, D: DimAPI,

type TOut = <T as AbsAPI>::Out

fn op_muta_refb( &self, a: &mut Vec<T::Out>, la: &Layout<D>, b: &Vec<T>, lb: &Layout<D>, ) -> Result<()>

fn op_muta(&self, a: &mut Vec<T::Out>, la: &Layout<D>) -> Result<()>

impl<T, D> DeviceAcosAPI<T, D> for DeviceOpenBLAS

where T: Clone + Send + Sync + ComplexFloat, D: DimAPI,

type TOut = T

fn op_muta_refb( &self, a: &mut Vec<T>, la: &Layout<D>, b: &Vec<T>, lb: &Layout<D>, ) -> Result<()>

fn op_muta(&self, a: &mut Vec<T>, la: &Layout<D>) -> Result<()>

impl<T, D> DeviceAcoshAPI<T, D> for DeviceOpenBLAS

where T: Clone + Send + Sync + ComplexFloat, D: DimAPI,

type TOut = T

fn op_muta_refb( &self, a: &mut Vec<T>, la: &Layout<D>, b: &Vec<T>, lb: &Layout<D>, ) -> Result<()>

fn op_muta(&self, a: &mut Vec<T>, la: &Layout<D>) -> Result<()>

impl<TA, TB, TC, D> DeviceAddAPI<TA, TB, TC, D> for DeviceOpenBLAS

where TA: Clone + Send + Sync + Add<TB, Output = TC>, TB: Clone + Send + Sync, TC: Clone + Send + Sync, D: DimAPI,

fn op_mutc_refa_refb( &self, c: &mut Vec<TC>, lc: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<()>

fn op_mutc_refa_numb( &self, c: &mut Vec<TC>, lc: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, b: TB, ) -> Result<()>

fn op_mutc_numa_refb( &self, c: &mut Vec<TC>, lc: &Layout<D>, a: TA, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<()>

impl<TA, TB, D> DeviceAddAssignAPI<TA, TB, D> for DeviceOpenBLAS

where TA: Clone + Send + Sync + AddAssign<TB>, TB: Clone + Send + Sync, D: DimAPI,

fn op_muta_refb( &self, a: &mut Vec<TA>, la: &Layout<D>, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<()>

fn op_muta_numb(&self, a: &mut Vec<TA>, la: &Layout<D>, b: TB) -> Result<()>

impl<T, D> DeviceAsinAPI<T, D> for DeviceOpenBLAS

where T: Clone + Send + Sync + ComplexFloat, D: DimAPI,

type TOut = T

fn op_muta_refb( &self, a: &mut Vec<T>, la: &Layout<D>, b: &Vec<T>, lb: &Layout<D>, ) -> Result<()>

fn op_muta(&self, a: &mut Vec<T>, la: &Layout<D>) -> Result<()>

impl<T, D> DeviceAsinhAPI<T, D> for DeviceOpenBLAS

where T: Clone + Send + Sync + ComplexFloat, D: DimAPI,

type TOut = T

fn op_muta_refb( &self, a: &mut Vec<T>, la: &Layout<D>, b: &Vec<T>, lb: &Layout<D>, ) -> Result<()>

fn op_muta(&self, a: &mut Vec<T>, la: &Layout<D>) -> Result<()>

impl<T, D> DeviceAtanAPI<T, D> for DeviceOpenBLAS

where T: Clone + Send + Sync + ComplexFloat, D: DimAPI,

type TOut = T

fn op_muta_refb( &self, a: &mut Vec<T>, la: &Layout<D>, b: &Vec<T>, lb: &Layout<D>, ) -> Result<()>

fn op_muta(&self, a: &mut Vec<T>, la: &Layout<D>) -> Result<()>

impl<T, D> DeviceAtanhAPI<T, D> for DeviceOpenBLAS

where T: Clone + Send + Sync + ComplexFloat, D: DimAPI,

type TOut = T

fn op_muta_refb( &self, a: &mut Vec<T>, la: &Layout<D>, b: &Vec<T>, lb: &Layout<D>, ) -> Result<()>

fn op_muta(&self, a: &mut Vec<T>, la: &Layout<D>) -> Result<()>

impl DeviceBaseAPI for DeviceOpenBLAS

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

fn default_order(&self) -> FlagOrder

fn set_default_order(&mut self, order: FlagOrder)

impl<TA, TB, TC, D> DeviceBitAndAPI<TA, TB, TC, D> for DeviceOpenBLAS

where TA: Clone + Send + Sync + BitAnd<TB, Output = TC>, TB: Clone + Send + Sync, TC: Clone + Send + Sync, D: DimAPI,

fn op_mutc_refa_refb( &self, c: &mut Vec<TC>, lc: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<()>

fn op_mutc_refa_numb( &self, c: &mut Vec<TC>, lc: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, b: TB, ) -> Result<()>

fn op_mutc_numa_refb( &self, c: &mut Vec<TC>, lc: &Layout<D>, a: TA, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<()>

impl<TA, TB, D> DeviceBitAndAssignAPI<TA, TB, D> for DeviceOpenBLAS

where TA: Clone + Send + Sync + BitAndAssign<TB>, TB: Clone + Send + Sync, D: DimAPI,

fn op_muta_refb( &self, a: &mut Vec<TA>, la: &Layout<D>, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<()>

fn op_muta_numb(&self, a: &mut Vec<TA>, la: &Layout<D>, b: TB) -> Result<()>

impl<TA, TB, TC, D> DeviceBitOrAPI<TA, TB, TC, D> for DeviceOpenBLAS

where TA: Clone + Send + Sync + BitOr<TB, Output = TC>, TB: Clone + Send + Sync, TC: Clone + Send + Sync, D: DimAPI,

fn op_mutc_refa_refb( &self, c: &mut Vec<TC>, lc: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<()>

fn op_mutc_refa_numb( &self, c: &mut Vec<TC>, lc: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, b: TB, ) -> Result<()>

fn op_mutc_numa_refb( &self, c: &mut Vec<TC>, lc: &Layout<D>, a: TA, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<()>

impl<TA, TB, D> DeviceBitOrAssignAPI<TA, TB, D> for DeviceOpenBLAS

where TA: Clone + Send + Sync + BitOrAssign<TB>, TB: Clone + Send + Sync, D: DimAPI,

fn op_muta_refb( &self, a: &mut Vec<TA>, la: &Layout<D>, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<()>

fn op_muta_numb(&self, a: &mut Vec<TA>, la: &Layout<D>, b: TB) -> Result<()>

impl<TA, TB, TC, D> DeviceBitXorAPI<TA, TB, TC, D> for DeviceOpenBLAS

where TA: Clone + Send + Sync + BitXor<TB, Output = TC>, TB: Clone + Send + Sync, TC: Clone + Send + Sync, D: DimAPI,

fn op_mutc_refa_refb( &self, c: &mut Vec<TC>, lc: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<()>

fn op_mutc_refa_numb( &self, c: &mut Vec<TC>, lc: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, b: TB, ) -> Result<()>

fn op_mutc_numa_refb( &self, c: &mut Vec<TC>, lc: &Layout<D>, a: TA, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<()>

impl<TA, TB, D> DeviceBitXorAssignAPI<TA, TB, D> for DeviceOpenBLAS

where TA: Clone + Send + Sync + BitXorAssign<TB>, TB: Clone + Send + Sync, D: DimAPI,

fn op_muta_refb( &self, a: &mut Vec<TA>, la: &Layout<D>, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<()>

fn op_muta_numb(&self, a: &mut Vec<TA>, la: &Layout<D>, b: TB) -> Result<()>

impl<T, D> DeviceCeilAPI<T, D> for DeviceOpenBLAS

where T: Clone + Send + Sync + Float, D: DimAPI,

type TOut = T

fn op_muta_refb( &self, a: &mut Vec<T>, la: &Layout<D>, b: &Vec<T>, lb: &Layout<D>, ) -> Result<()>

fn op_muta(&self, a: &mut Vec<T>, la: &Layout<D>) -> Result<()>

impl<'a, R, T, D> DeviceChangeAPI<'a, DeviceCpuSerial, R, T, D> for DeviceOpenBLAS

where T: Clone + Send + Sync + 'a, D: DimAPI, R: DataCloneAPI<Data = Vec<T>>,

type Repr = R

type ReprTo = DataRef<'a, Vec<T>>

fn change_device( tensor: TensorAny<R, T, DeviceBLAS, D>, device: &DeviceCpuSerial, ) -> Result<TensorAny<Self::Repr, T, DeviceCpuSerial, D>>

fn into_device( tensor: TensorAny<R, T, DeviceBLAS, D>, device: &DeviceCpuSerial, ) -> Result<TensorAny<DataOwned<Vec<T>>, T, DeviceCpuSerial, D>>

fn to_device( tensor: &'a TensorAny<R, T, DeviceBLAS, D>, device: &DeviceCpuSerial, ) -> Result<TensorView<'a, T, DeviceCpuSerial, D>>

impl<'a, R, T, D> DeviceChangeAPI<'a, DeviceOpenBLAS, R, T, D> for DeviceCpuSerial

where T: Clone + Send + Sync + 'a, D: DimAPI, R: DataCloneAPI<Data = Vec<T>>,

type Repr = R

type ReprTo = DataRef<'a, Vec<T>>

fn change_device( tensor: TensorAny<R, T, DeviceCpuSerial, D>, device: &DeviceBLAS, ) -> Result<TensorAny<Self::Repr, T, DeviceBLAS, D>>

fn into_device( tensor: TensorAny<R, T, DeviceCpuSerial, D>, device: &DeviceBLAS, ) -> Result<TensorAny<DataOwned<Vec<T>>, T, DeviceBLAS, D>>

fn to_device( tensor: &'a TensorAny<R, T, DeviceCpuSerial, D>, device: &DeviceBLAS, ) -> Result<TensorView<'a, T, DeviceBLAS, D>>

impl<'a, R, T, D> DeviceChangeAPI<'a, DeviceOpenBLAS, R, T, D> for DeviceOpenBLAS

where T: Clone + Send + Sync + 'a, D: DimAPI, R: DataCloneAPI<Data = Vec<T>>,

type Repr = R

type ReprTo = DataRef<'a, Vec<T>>

fn change_device( tensor: TensorAny<R, T, DeviceBLAS, D>, device: &DeviceBLAS, ) -> Result<TensorAny<Self::Repr, T, DeviceBLAS, D>>

fn into_device( tensor: TensorAny<R, T, DeviceBLAS, D>, device: &DeviceBLAS, ) -> Result<TensorAny<DataOwned<Vec<T>>, T, DeviceBLAS, D>>

fn to_device( tensor: &'a TensorAny<R, T, DeviceBLAS, D>, device: &DeviceBLAS, ) -> Result<TensorView<'a, T, DeviceBLAS, D>>

impl<T, D> DeviceConjAPI<T, D> for DeviceOpenBLAS

where T: Clone + Send + Sync + ComplexFloat, D: DimAPI,

type TOut = T

fn op_muta_refb( &self, a: &mut Vec<T>, la: &Layout<D>, b: &Vec<T>, lb: &Layout<D>, ) -> Result<()>

fn op_muta(&self, a: &mut Vec<T>, la: &Layout<D>) -> Result<()>

impl<T, D> DeviceCopySignAPI<T, T, D> for DeviceOpenBLAS

where T: Clone + Send + Sync + Float, D: DimAPI,

type TOut = T

fn op_mutc_refa_refb( &self, c: &mut Vec<T>, lc: &Layout<D>, a: &Vec<T>, la: &Layout<D>, b: &Vec<T>, lb: &Layout<D>, ) -> Result<()>

fn op_mutc_refa_numb( &self, c: &mut Vec<T>, lc: &Layout<D>, a: &Vec<T>, la: &Layout<D>, b: T, ) -> Result<()>

fn op_mutc_numa_refb( &self, c: &mut <Self as DeviceRawAPI<Self::TOut>>::Raw, lc: &Layout<D>, a: T, b: &<Self as DeviceRawAPI<T>>::Raw, lb: &Layout<D>, ) -> Result<()>

impl<T, D> DeviceCosAPI<T, D> for DeviceOpenBLAS

where T: Clone + Send + Sync + ComplexFloat, D: DimAPI,

type TOut = T

fn op_muta_refb( &self, a: &mut Vec<T>, la: &Layout<D>, b: &Vec<T>, lb: &Layout<D>, ) -> Result<()>

fn op_muta(&self, a: &mut Vec<T>, la: &Layout<D>) -> Result<()>

impl<T, D> DeviceCoshAPI<T, D> for DeviceOpenBLAS

where T: Clone + Send + Sync + ComplexFloat, D: DimAPI,

type TOut = T

fn op_muta_refb( &self, a: &mut Vec<T>, la: &Layout<D>, b: &Vec<T>, lb: &Layout<D>, ) -> Result<()>

fn op_muta(&self, a: &mut Vec<T>, la: &Layout<D>) -> Result<()>

impl<T> DeviceCreationAnyAPI<T> for DeviceOpenBLAS

where Self: DeviceRawAPI<T, Raw = Vec<T>>,

unsafe fn empty_impl( &self, len: usize, ) -> Result<Storage<DataOwned<Vec<T>>, T, Self>>

Safety

fn full_impl( &self, len: usize, fill: T, ) -> Result<Storage<DataOwned<Vec<T>>, T, Self>>

where T: Clone,

fn outof_cpu_vec( &self, vec: Vec<T>, ) -> Result<Storage<DataOwned<Vec<T>>, T, Self>>

fn from_cpu_vec(&self, vec: &[T]) -> Result<Storage<DataOwned<Vec<T>>, T, Self>>

where T: Clone,

impl<T> DeviceCreationComplexFloatAPI<T> for DeviceOpenBLAS

where T: ComplexFloat + Clone + Send + Sync, Self: DeviceRawAPI<T, Raw = Vec<T>>,

fn linspace_impl( &self, start: T, end: T, n: usize, endpoint: bool, ) -> Result<Storage<DataOwned<Vec<T>>, T, Self>>

impl<T> DeviceCreationNumAPI<T> for DeviceOpenBLAS

where T: Num + Clone, Self: DeviceRawAPI<T, Raw = Vec<T>>,

fn zeros_impl(&self, len: usize) -> Result<Storage<DataOwned<Vec<T>>, T, Self>>

fn ones_impl(&self, len: usize) -> Result<Storage<DataOwned<Vec<T>>, T, Self>>

fn arange_int_impl( &self, len: usize, ) -> Result<Storage<DataOwned<Vec<T>>, T, Self>>

impl<T> DeviceCreationPartialOrdNumAPI<T> for DeviceOpenBLAS

where T: Num + PartialOrd + Clone, Self: DeviceRawAPI<T, Raw = Vec<T>>,

fn arange_impl( &self, start: T, end: T, step: T, ) -> Result<Storage<DataOwned<Vec<T>>, T, Self>>

impl<T> DeviceCreationTriAPI<T> for DeviceOpenBLAS

where T: Num + Clone, Self: DeviceRawAPI<T, Raw = Vec<T>>,

fn tril_impl<D>( &self, raw: &mut Self::Raw, layout: &Layout<D>, k: isize, ) -> Result<()>

where D: DimAPI,

fn triu_impl<D>( &self, raw: &mut Self::Raw, layout: &Layout<D>, k: isize, ) -> Result<()>

where D: DimAPI,

impl<TA, TB, TC, D> DeviceDivAPI<TA, TB, TC, D> for DeviceOpenBLAS

where TA: Clone + Send + Sync + Div<TB, Output = TC>, TB: Clone + Send + Sync, TC: Clone + Send + Sync, D: DimAPI,

fn op_mutc_refa_refb( &self, c: &mut Vec<TC>, lc: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<()>

fn op_mutc_refa_numb( &self, c: &mut Vec<TC>, lc: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, b: TB, ) -> Result<()>

fn op_mutc_numa_refb( &self, c: &mut Vec<TC>, lc: &Layout<D>, a: TA, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<()>

impl<TA, TB, D> DeviceDivAssignAPI<TA, TB, D> for DeviceOpenBLAS

where TA: Clone + Send + Sync + DivAssign<TB>, TB: Clone + Send + Sync, D: DimAPI,

fn op_muta_refb( &self, a: &mut Vec<TA>, la: &Layout<D>, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<()>

fn op_muta_numb(&self, a: &mut Vec<TA>, la: &Layout<D>, b: TB) -> Result<()>

impl<T, D> DeviceEqualAPI<T, T, D> for DeviceOpenBLAS

where T: Clone + Send + Sync + PartialEq, D: DimAPI,

type TOut = bool

fn op_mutc_refa_refb( &self, c: &mut Vec<bool>, lc: &Layout<D>, a: &Vec<T>, la: &Layout<D>, b: &Vec<T>, lb: &Layout<D>, ) -> Result<()>

fn op_mutc_refa_numb( &self, c: &mut Vec<bool>, lc: &Layout<D>, a: &Vec<T>, la: &Layout<D>, b: T, ) -> Result<()>

fn op_mutc_numa_refb( &self, c: &mut <Self as DeviceRawAPI<Self::TOut>>::Raw, lc: &Layout<D>, a: T, b: &<Self as DeviceRawAPI<T>>::Raw, lb: &Layout<D>, ) -> Result<()>

impl<T, D> DeviceExpAPI<T, D> for DeviceOpenBLAS

where T: Clone + Send + Sync + ComplexFloat, D: DimAPI,

type TOut = T

fn op_muta_refb( &self, a: &mut Vec<T>, la: &Layout<D>, b: &Vec<T>, lb: &Layout<D>, ) -> Result<()>

fn op_muta(&self, a: &mut Vec<T>, la: &Layout<D>) -> Result<()>

impl<T, D> DeviceExpm1API<T, D> for DeviceOpenBLAS

where T: Clone + Send + Sync + Float, D: DimAPI,

type TOut = T

fn op_muta_refb( &self, a: &mut Vec<T>, la: &Layout<D>, b: &Vec<T>, lb: &Layout<D>, ) -> Result<()>

fn op_muta(&self, a: &mut Vec<T>, la: &Layout<D>) -> Result<()>

impl<T, D> DeviceFloorAPI<T, D> for DeviceOpenBLAS

where T: Clone + Send + Sync + Float, D: DimAPI,

type TOut = T

fn op_muta_refb( &self, a: &mut Vec<T>, la: &Layout<D>, b: &Vec<T>, lb: &Layout<D>, ) -> Result<()>

fn op_muta(&self, a: &mut Vec<T>, la: &Layout<D>) -> Result<()>

impl<T, D> DeviceFloorDivideAPI<T, T, D> for DeviceOpenBLAS

where T: Clone + Send + Sync + FloorDivideAPI, D: DimAPI,

type TOut = T

fn op_mutc_refa_refb( &self, c: &mut Vec<T>, lc: &Layout<D>, a: &Vec<T>, la: &Layout<D>, b: &Vec<T>, lb: &Layout<D>, ) -> Result<()>

fn op_mutc_refa_numb( &self, c: &mut Vec<T>, lc: &Layout<D>, a: &Vec<T>, la: &Layout<D>, b: T, ) -> Result<()>

fn op_mutc_numa_refb( &self, c: &mut <Self as DeviceRawAPI<Self::TOut>>::Raw, lc: &Layout<D>, a: T, b: &<Self as DeviceRawAPI<T>>::Raw, lb: &Layout<D>, ) -> Result<()>

impl<T, D> DeviceGreaterAPI<T, T, D> for DeviceOpenBLAS

where T: Clone + Send + Sync + PartialOrd, D: DimAPI,

type TOut = bool

fn op_mutc_refa_refb( &self, c: &mut Vec<bool>, lc: &Layout<D>, a: &Vec<T>, la: &Layout<D>, b: &Vec<T>, lb: &Layout<D>, ) -> Result<()>

fn op_mutc_refa_numb( &self, c: &mut Vec<bool>, lc: &Layout<D>, a: &Vec<T>, la: &Layout<D>, b: T, ) -> Result<()>

fn op_mutc_numa_refb( &self, c: &mut <Self as DeviceRawAPI<Self::TOut>>::Raw, lc: &Layout<D>, a: T, b: &<Self as DeviceRawAPI<T>>::Raw, lb: &Layout<D>, ) -> Result<()>

impl<T, D> DeviceGreaterEqualAPI<T, T, D> for DeviceOpenBLAS

where T: Clone + Send + Sync + PartialOrd, D: DimAPI,

type TOut = bool

fn op_mutc_refa_refb( &self, c: &mut Vec<bool>, lc: &Layout<D>, a: &Vec<T>, la: &Layout<D>, b: &Vec<T>, lb: &Layout<D>, ) -> Result<()>

fn op_mutc_refa_numb( &self, c: &mut Vec<bool>, lc: &Layout<D>, a: &Vec<T>, la: &Layout<D>, b: T, ) -> Result<()>

fn op_mutc_numa_refb( &self, c: &mut <Self as DeviceRawAPI<Self::TOut>>::Raw, lc: &Layout<D>, a: T, b: &<Self as DeviceRawAPI<T>>::Raw, lb: &Layout<D>, ) -> Result<()>

impl<T, D> DeviceHypotAPI<T, T, D> for DeviceOpenBLAS

where T: Clone + Send + Sync + Float, D: DimAPI,

type TOut = T

fn op_mutc_refa_refb( &self, c: &mut Vec<T>, lc: &Layout<D>, a: &Vec<T>, la: &Layout<D>, b: &Vec<T>, lb: &Layout<D>, ) -> Result<()>

fn op_mutc_refa_numb( &self, c: &mut Vec<T>, lc: &Layout<D>, a: &Vec<T>, la: &Layout<D>, b: T, ) -> Result<()>

fn op_mutc_numa_refb( &self, c: &mut <Self as DeviceRawAPI<Self::TOut>>::Raw, lc: &Layout<D>, a: T, b: &<Self as DeviceRawAPI<T>>::Raw, lb: &Layout<D>, ) -> Result<()>

impl<T, D> DeviceImagAPI<T, D> for DeviceOpenBLAS

where T: Clone + Send + Sync + ReImAPI, T::Out: Send + Sync, D: DimAPI,

type TOut = <T as ReImAPI>::Out

fn op_muta_refb( &self, a: &mut Vec<T::Out>, la: &Layout<D>, b: &Vec<T>, lb: &Layout<D>, ) -> Result<()>

fn op_muta(&self, a: &mut Vec<T::Out>, la: &Layout<D>) -> Result<()>

impl<T, D> DeviceIndexSelectAPI<T, D> for DeviceOpenBLAS

where T: Clone + Send + Sync, D: DimAPI + DimSmallerOneAPI, D::SmallerOne: DimAPI,

fn index_select( &self, c: &mut <Self as DeviceRawAPI<T>>::Raw, lc: &Layout<D>, a: &<Self as DeviceRawAPI<T>>::Raw, la: &Layout<D>, axis: usize, indices: &[usize], ) -> Result<()>

Index select on one axis.

impl<T, D> DeviceInvAPI<T, D> for DeviceOpenBLAS

where T: Clone + Send + Sync + ComplexFloat, D: DimAPI,

type TOut = T

fn op_muta_refb( &self, a: &mut Vec<T>, la: &Layout<D>, b: &Vec<T>, lb: &Layout<D>, ) -> Result<()>

fn op_muta(&self, a: &mut Vec<T>, la: &Layout<D>) -> Result<()>

impl<T, D> DeviceIsFiniteAPI<T, D> for DeviceOpenBLAS

where T: Clone + Send + Sync + ComplexFloat, D: DimAPI,

type TOut = bool

fn op_muta_refb( &self, a: &mut Vec<bool>, la: &Layout<D>, b: &Vec<T>, lb: &Layout<D>, ) -> Result<()>

fn op_muta(&self, _a: &mut Vec<bool>, _la: &Layout<D>) -> Result<()>

impl<T, D> DeviceIsInfAPI<T, D> for DeviceOpenBLAS

where T: Clone + Send + Sync + ComplexFloat, D: DimAPI,

type TOut = bool

fn op_muta_refb( &self, a: &mut Vec<bool>, la: &Layout<D>, b: &Vec<T>, lb: &Layout<D>, ) -> Result<()>

fn op_muta(&self, _a: &mut Vec<bool>, _la: &Layout<D>) -> Result<()>

impl<T, D> DeviceIsNanAPI<T, D> for DeviceOpenBLAS

where T: Clone + Send + Sync + ComplexFloat, D: DimAPI,

type TOut = bool

fn op_muta_refb( &self, a: &mut Vec<bool>, la: &Layout<D>, b: &Vec<T>, lb: &Layout<D>, ) -> Result<()>

fn op_muta(&self, _a: &mut Vec<bool>, _la: &Layout<D>) -> Result<()>

impl<TA, TB, D> DeviceLConsumeAddAPI<TA, TB, D> for DeviceOpenBLAS

where TA: Clone + Send + Sync + Add<TB, Output = TA>, TB: Clone + Send + Sync, D: DimAPI,

fn op_muta_refb( &self, a: &mut Vec<TA>, la: &Layout<D>, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<()>

fn op_muta_numb(&self, a: &mut Vec<TA>, la: &Layout<D>, b: TB) -> Result<()>

impl<TA, TB, D> DeviceLConsumeBitAndAPI<TA, TB, D> for DeviceOpenBLAS

where TA: Clone + Send + Sync + BitAnd<TB, Output = TA>, TB: Clone + Send + Sync, D: DimAPI,

fn op_muta_refb( &self, a: &mut Vec<TA>, la: &Layout<D>, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<()>

fn op_muta_numb(&self, a: &mut Vec<TA>, la: &Layout<D>, b: TB) -> Result<()>

impl<TA, TB, D> DeviceLConsumeBitOrAPI<TA, TB, D> for DeviceOpenBLAS

where TA: Clone + Send + Sync + BitOr<TB, Output = TA>, TB: Clone + Send + Sync, D: DimAPI,

fn op_muta_refb( &self, a: &mut Vec<TA>, la: &Layout<D>, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<()>

fn op_muta_numb(&self, a: &mut Vec<TA>, la: &Layout<D>, b: TB) -> Result<()>

impl<TA, TB, D> DeviceLConsumeBitXorAPI<TA, TB, D> for DeviceOpenBLAS

where TA: Clone + Send + Sync + BitXor<TB, Output = TA>, TB: Clone + Send + Sync, D: DimAPI,

fn op_muta_refb( &self, a: &mut Vec<TA>, la: &Layout<D>, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<()>

fn op_muta_numb(&self, a: &mut Vec<TA>, la: &Layout<D>, b: TB) -> Result<()>

impl<TA, TB, D> DeviceLConsumeDivAPI<TA, TB, D> for DeviceOpenBLAS

where TA: Clone + Send + Sync + Div<TB, Output = TA>, TB: Clone + Send + Sync, D: DimAPI,

fn op_muta_refb( &self, a: &mut Vec<TA>, la: &Layout<D>, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<()>

fn op_muta_numb(&self, a: &mut Vec<TA>, la: &Layout<D>, b: TB) -> Result<()>

impl<TA, TB, D> DeviceLConsumeMulAPI<TA, TB, D> for DeviceOpenBLAS

where TA: Clone + Send + Sync + Mul<TB, Output = TA>, TB: Clone + Send + Sync, D: DimAPI,

fn op_muta_refb( &self, a: &mut Vec<TA>, la: &Layout<D>, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<()>

fn op_muta_numb(&self, a: &mut Vec<TA>, la: &Layout<D>, b: TB) -> Result<()>

impl<TA, TB, D> DeviceLConsumeRemAPI<TA, TB, D> for DeviceOpenBLAS

where TA: Clone + Send + Sync + Rem<TB, Output = TA>, TB: Clone + Send + Sync, D: DimAPI,

fn op_muta_refb( &self, a: &mut Vec<TA>, la: &Layout<D>, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<()>

fn op_muta_numb(&self, a: &mut Vec<TA>, la: &Layout<D>, b: TB) -> Result<()>

impl<TA, TB, D> DeviceLConsumeShlAPI<TA, TB, D> for DeviceOpenBLAS

where TA: Clone + Send + Sync + Shl<TB, Output = TA>, TB: Clone + Send + Sync, D: DimAPI,

fn op_muta_refb( &self, a: &mut Vec<TA>, la: &Layout<D>, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<()>

fn op_muta_numb(&self, a: &mut Vec<TA>, la: &Layout<D>, b: TB) -> Result<()>

impl<TA, TB, D> DeviceLConsumeShrAPI<TA, TB, D> for DeviceOpenBLAS

where TA: Clone + Send + Sync + Shr<TB, Output = TA>, TB: Clone + Send + Sync, D: DimAPI,

fn op_muta_refb( &self, a: &mut Vec<TA>, la: &Layout<D>, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<()>

fn op_muta_numb(&self, a: &mut Vec<TA>, la: &Layout<D>, b: TB) -> Result<()>

impl<TA, TB, D> DeviceLConsumeSubAPI<TA, TB, D> for DeviceOpenBLAS

where TA: Clone + Send + Sync + Sub<TB, Output = TA>, TB: Clone + Send + Sync, D: DimAPI,

fn op_muta_refb( &self, a: &mut Vec<TA>, la: &Layout<D>, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<()>

fn op_muta_numb(&self, a: &mut Vec<TA>, la: &Layout<D>, b: TB) -> Result<()>

impl<T, D> DeviceLessAPI<T, T, D> for DeviceOpenBLAS

where T: Clone + Send + Sync + PartialOrd, D: DimAPI,

type TOut = bool

fn op_mutc_refa_refb( &self, c: &mut Vec<bool>, lc: &Layout<D>, a: &Vec<T>, la: &Layout<D>, b: &Vec<T>, lb: &Layout<D>, ) -> Result<()>

fn op_mutc_refa_numb( &self, c: &mut Vec<bool>, lc: &Layout<D>, a: &Vec<T>, la: &Layout<D>, b: T, ) -> Result<()>

fn op_mutc_numa_refb( &self, c: &mut <Self as DeviceRawAPI<Self::TOut>>::Raw, lc: &Layout<D>, a: T, b: &<Self as DeviceRawAPI<T>>::Raw, lb: &Layout<D>, ) -> Result<()>

impl<T, D> DeviceLessEqualAPI<T, T, D> for DeviceOpenBLAS

where T: Clone + Send + Sync + PartialOrd, D: DimAPI,

type TOut = bool

fn op_mutc_refa_refb( &self, c: &mut Vec<bool>, lc: &Layout<D>, a: &Vec<T>, la: &Layout<D>, b: &Vec<T>, lb: &Layout<D>, ) -> Result<()>

fn op_mutc_refa_numb( &self, c: &mut Vec<bool>, lc: &Layout<D>, a: &Vec<T>, la: &Layout<D>, b: T, ) -> Result<()>

fn op_mutc_numa_refb( &self, c: &mut <Self as DeviceRawAPI<Self::TOut>>::Raw, lc: &Layout<D>, a: T, b: &<Self as DeviceRawAPI<T>>::Raw, lb: &Layout<D>, ) -> Result<()>

impl<T, D> DeviceLog10API<T, D> for DeviceOpenBLAS

where T: Clone + Send + Sync + ComplexFloat, D: DimAPI,

type TOut = T

fn op_muta_refb( &self, a: &mut Vec<T>, la: &Layout<D>, b: &Vec<T>, lb: &Layout<D>, ) -> Result<()>

fn op_muta(&self, a: &mut Vec<T>, la: &Layout<D>) -> Result<()>

impl<T, D> DeviceLog2API<T, D> for DeviceOpenBLAS

where T: Clone + Send + Sync + ComplexFloat, D: DimAPI,

type TOut = T

fn op_muta_refb( &self, a: &mut Vec<T>, la: &Layout<D>, b: &Vec<T>, lb: &Layout<D>, ) -> Result<()>

fn op_muta(&self, a: &mut Vec<T>, la: &Layout<D>) -> Result<()>

impl<T, D> DeviceLogAPI<T, D> for DeviceOpenBLAS

where T: Clone + Send + Sync + ComplexFloat, D: DimAPI,

type TOut = T

fn op_muta_refb( &self, a: &mut Vec<T>, la: &Layout<D>, b: &Vec<T>, lb: &Layout<D>, ) -> Result<()>

fn op_muta(&self, a: &mut Vec<T>, la: &Layout<D>) -> Result<()>

impl<T, D> DeviceLogAddExpAPI<T, T, D> for DeviceOpenBLAS

where T: Clone + Send + Sync + ComplexFloat, D: DimAPI,

type TOut = T

fn op_mutc_refa_refb( &self, c: &mut Vec<T>, lc: &Layout<D>, a: &Vec<T>, la: &Layout<D>, b: &Vec<T>, lb: &Layout<D>, ) -> Result<()>

fn op_mutc_refa_numb( &self, c: &mut Vec<T>, lc: &Layout<D>, a: &Vec<T>, la: &Layout<D>, b: T, ) -> Result<()>

fn op_mutc_numa_refb( &self, c: &mut <Self as DeviceRawAPI<Self::TOut>>::Raw, lc: &Layout<D>, a: T, b: &<Self as DeviceRawAPI<T>>::Raw, lb: &Layout<D>, ) -> Result<()>

impl<TA, TB, TC, DA, DB, DC> DeviceMatMulAPI<TA, TB, TC, DA, DB, DC> for DeviceOpenBLAS

where TA: Clone + Send + Sync + 'static + Mul<TB, Output = TC>, TB: Clone + Send + Sync + 'static + Mul<TA, Output = TC>, TC: Clone + Send + Sync + 'static + Mul<TC, Output = TC> + Add<TC, Output = TC> + Zero + PartialEq, DA: DimAPI, DB: DimAPI, DC: DimAPI,

fn matmul( &self, c: &mut Vec<TC>, lc: &Layout<DC>, a: &Vec<TA>, la: &Layout<DA>, b: &Vec<TB>, lb: &Layout<DB>, alpha: TC, beta: TC, ) -> Result<()>

impl<T, D> DeviceMaximumAPI<T, T, D> for DeviceOpenBLAS

where T: Clone + Send + Sync + MinMaxAPI, D: DimAPI,

type TOut = T

fn op_mutc_refa_refb( &self, c: &mut Vec<T>, lc: &Layout<D>, a: &Vec<T>, la: &Layout<D>, b: &Vec<T>, lb: &Layout<D>, ) -> Result<()>

fn op_mutc_refa_numb( &self, c: &mut Vec<T>, lc: &Layout<D>, a: &Vec<T>, la: &Layout<D>, b: T, ) -> Result<()>

fn op_mutc_numa_refb( &self, c: &mut <Self as DeviceRawAPI<Self::TOut>>::Raw, lc: &Layout<D>, a: T, b: &<Self as DeviceRawAPI<T>>::Raw, lb: &Layout<D>, ) -> Result<()>

impl<T, D> DeviceMinimumAPI<T, T, D> for DeviceOpenBLAS

where T: Clone + Send + Sync + MinMaxAPI, D: DimAPI,

type TOut = T

fn op_mutc_refa_refb( &self, c: &mut Vec<T>, lc: &Layout<D>, a: &Vec<T>, la: &Layout<D>, b: &Vec<T>, lb: &Layout<D>, ) -> Result<()>

fn op_mutc_refa_numb( &self, c: &mut Vec<T>, lc: &Layout<D>, a: &Vec<T>, la: &Layout<D>, b: T, ) -> Result<()>

fn op_mutc_numa_refb( &self, c: &mut <Self as DeviceRawAPI<Self::TOut>>::Raw, lc: &Layout<D>, a: T, b: &<Self as DeviceRawAPI<T>>::Raw, lb: &Layout<D>, ) -> Result<()>

impl<TA, TB, TC, D> DeviceMulAPI<TA, TB, TC, D> for DeviceOpenBLAS

where TA: Clone + Send + Sync + Mul<TB, Output = TC>, TB: Clone + Send + Sync, TC: Clone + Send + Sync, D: DimAPI,

fn op_mutc_refa_refb( &self, c: &mut Vec<TC>, lc: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<()>

fn op_mutc_refa_numb( &self, c: &mut Vec<TC>, lc: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, b: TB, ) -> Result<()>

fn op_mutc_numa_refb( &self, c: &mut Vec<TC>, lc: &Layout<D>, a: TA, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<()>

impl<TA, TB, D> DeviceMulAssignAPI<TA, TB, D> for DeviceOpenBLAS

where TA: Clone + Send + Sync + MulAssign<TB>, TB: Clone + Send + Sync, D: DimAPI,

fn op_muta_refb( &self, a: &mut Vec<TA>, la: &Layout<D>, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<()>

fn op_muta_numb(&self, a: &mut Vec<TA>, la: &Layout<D>, b: TB) -> Result<()>

impl<TA, TB, D> DeviceNegAPI<TA, TB, D> for DeviceOpenBLAS

where TA: Clone + Send + Sync, TB: Clone + Send + Sync, D: DimAPI,

fn op_muta_refb( &self, a: &mut Vec<TA>, la: &Layout<D>, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<()>

where TB: Neg<Output = TA>,

fn op_muta(&self, a: &mut Vec<TA>, la: &Layout<D>) -> Result<()>

where TA: Neg<Output = TA>,

impl<TA, TB, D> DeviceNotAPI<TA, TB, D> for DeviceOpenBLAS

where TA: Clone + Send + Sync, TB: Clone + Send + Sync, D: DimAPI,

fn op_muta_refb( &self, a: &mut Vec<TA>, la: &Layout<D>, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<()>

where TB: Not<Output = TA>,

fn op_muta(&self, a: &mut Vec<TA>, la: &Layout<D>) -> Result<()>

where TA: Not<Output = TA>,

impl<T, D> DeviceNotEqualAPI<T, T, D> for DeviceOpenBLAS

where T: Clone + Send + Sync + PartialEq, D: DimAPI,

type TOut = bool

fn op_mutc_refa_refb( &self, c: &mut Vec<bool>, lc: &Layout<D>, a: &Vec<T>, la: &Layout<D>, b: &Vec<T>, lb: &Layout<D>, ) -> Result<()>

fn op_mutc_refa_numb( &self, c: &mut Vec<bool>, lc: &Layout<D>, a: &Vec<T>, la: &Layout<D>, b: T, ) -> Result<()>

fn op_mutc_numa_refb( &self, c: &mut <Self as DeviceRawAPI<Self::TOut>>::Raw, lc: &Layout<D>, a: T, b: &<Self as DeviceRawAPI<T>>::Raw, lb: &Layout<D>, ) -> Result<()>

impl<T> DeviceOpPackTriAPI<T> for DeviceOpenBLAS

where T: Clone + Send + Sync,

fn pack_tri( &self, a: &mut Vec<T>, la: &Layout<IxD>, b: &Vec<T>, lb: &Layout<IxD>, uplo: FlagUpLo, ) -> Result<()>

impl<T> DeviceOpUnpackTriAPI<T> for DeviceOpenBLAS

where T: ComplexFloat + Send + Sync,

fn unpack_tri( &self, a: &mut Vec<T>, la: &Layout<IxD>, b: &Vec<T>, lb: &Layout<IxD>, uplo: FlagUpLo, symm: FlagSymm, ) -> Result<()>

impl<T, D, F> DeviceOp_MutA_API<T, D, F> for DeviceOpenBLAS

where T: Clone + Send + Sync, D: DimAPI, F: Fn(&mut T) + ?Sized + Send + Sync,

fn op_muta_func(&self, a: &mut Vec<T>, la: &Layout<D>, f: &mut F) -> Result<()>

impl<TA, TB, D, F> DeviceOp_MutA_NumB_API<TA, TB, D, F> for DeviceOpenBLAS

where TA: Clone + Send + Sync, TB: Clone + Send + Sync, D: DimAPI, F: Fn(&mut TA, &TB) + ?Sized + Send + Sync,

fn op_muta_numb_func( &self, a: &mut Vec<TA>, la: &Layout<D>, b: TB, f: &mut F, ) -> Result<()>

impl<TA, TB, D, F> DeviceOp_MutA_RefB_API<TA, TB, D, F> for DeviceOpenBLAS

where TA: Clone + Send + Sync, TB: Clone + Send + Sync, D: DimAPI, F: Fn(&mut TA, &TB) + ?Sized + Send + Sync,

fn op_muta_refb_func( &self, a: &mut Vec<TA>, la: &Layout<D>, b: &Vec<TB>, lb: &Layout<D>, f: &mut F, ) -> Result<()>

impl<TA, TB, TC, D, F> DeviceOp_MutC_NumA_RefB_API<TA, TB, TC, D, F> for DeviceOpenBLAS

where TA: Clone + Send + Sync, TB: Clone + Send + Sync, TC: Clone + Send + Sync, D: DimAPI, F: Fn(&mut TC, &TA, &TB) + ?Sized + Send + Sync,

fn op_mutc_numa_refb_func( &self, c: &mut Vec<TC>, lc: &Layout<D>, a: TA, b: &Vec<TB>, lb: &Layout<D>, f: &mut F, ) -> Result<()>

impl<TA, TB, TC, D, F> DeviceOp_MutC_RefA_NumB_API<TA, TB, TC, D, F> for DeviceOpenBLAS

where TA: Clone + Send + Sync, TB: Clone + Send + Sync, TC: Clone + Send + Sync, D: DimAPI, F: Fn(&mut TC, &TA, &TB) + ?Sized + Send + Sync,

fn op_mutc_refa_numb_func( &self, c: &mut Vec<TC>, lc: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, b: TB, f: &mut F, ) -> Result<()>

impl<TA, TB, TC, D, F> DeviceOp_MutC_RefA_RefB_API<TA, TB, TC, D, F> for DeviceOpenBLAS

where TA: Clone + Send + Sync, TB: Clone + Send + Sync, TC: Clone + Send + Sync, D: DimAPI, F: Fn(&mut TC, &TA, &TB) + ?Sized + Send + Sync,

fn op_mutc_refa_refb_func( &self, c: &mut Vec<TC>, lc: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, b: &Vec<TB>, lb: &Layout<D>, f: &mut F, ) -> Result<()>

impl<TA, TB, D> DevicePowAPI<TA, TB, D> for DeviceOpenBLAS

where TA: Clone + Send + Sync + Pow<TB>, TB: Clone + Send + Sync, TA::Output: Clone + Send + Sync, D: DimAPI,

type TOut = <TA as Pow<TB>>::Output

fn op_mutc_refa_refb( &self, c: &mut Vec<Self::TOut>, lc: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<()>

fn op_mutc_refa_numb( &self, c: &mut Vec<Self::TOut>, lc: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, b: TB, ) -> Result<()>

fn op_mutc_numa_refb( &self, c: &mut <Self as DeviceRawAPI<Self::TOut>>::Raw, lc: &Layout<D>, a: TA, b: &<Self as DeviceRawAPI<TB>>::Raw, lb: &Layout<D>, ) -> Result<()>

impl<TA, TB, D> DeviceRConsumeAddAPI<TA, TB, D> for DeviceOpenBLAS

where TA: Clone + Send + Sync + Add<TB, Output = TB>, TB: Clone + Send + Sync, D: DimAPI,

fn op_muta_refb( &self, b: &mut Vec<TB>, lb: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, ) -> Result<()>

fn op_muta_numb(&self, b: &mut Vec<TB>, lb: &Layout<D>, a: TA) -> Result<()>

impl<TA, TB, D> DeviceRConsumeBitAndAPI<TA, TB, D> for DeviceOpenBLAS

where TA: Clone + Send + Sync + BitAnd<TB, Output = TB>, TB: Clone + Send + Sync, D: DimAPI,

fn op_muta_refb( &self, b: &mut Vec<TB>, lb: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, ) -> Result<()>

fn op_muta_numb(&self, b: &mut Vec<TB>, lb: &Layout<D>, a: TA) -> Result<()>

impl<TA, TB, D> DeviceRConsumeBitOrAPI<TA, TB, D> for DeviceOpenBLAS

where TA: Clone + Send + Sync + BitOr<TB, Output = TB>, TB: Clone + Send + Sync, D: DimAPI,

fn op_muta_refb( &self, b: &mut Vec<TB>, lb: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, ) -> Result<()>

fn op_muta_numb(&self, b: &mut Vec<TB>, lb: &Layout<D>, a: TA) -> Result<()>

impl<TA, TB, D> DeviceRConsumeBitXorAPI<TA, TB, D> for DeviceOpenBLAS

where TA: Clone + Send + Sync + BitXor<TB, Output = TB>, TB: Clone + Send + Sync, D: DimAPI,

fn op_muta_refb( &self, b: &mut Vec<TB>, lb: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, ) -> Result<()>

fn op_muta_numb(&self, b: &mut Vec<TB>, lb: &Layout<D>, a: TA) -> Result<()>

impl<TA, TB, D> DeviceRConsumeDivAPI<TA, TB, D> for DeviceOpenBLAS

where TA: Clone + Send + Sync + Div<TB, Output = TB>, TB: Clone + Send + Sync, D: DimAPI,

fn op_muta_refb( &self, b: &mut Vec<TB>, lb: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, ) -> Result<()>

fn op_muta_numb(&self, b: &mut Vec<TB>, lb: &Layout<D>, a: TA) -> Result<()>

impl<TA, TB, D> DeviceRConsumeMulAPI<TA, TB, D> for DeviceOpenBLAS

where TA: Clone + Send + Sync + Mul<TB, Output = TB>, TB: Clone + Send + Sync, D: DimAPI,

fn op_muta_refb( &self, b: &mut Vec<TB>, lb: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, ) -> Result<()>

fn op_muta_numb(&self, b: &mut Vec<TB>, lb: &Layout<D>, a: TA) -> Result<()>

impl<TA, TB, D> DeviceRConsumeRemAPI<TA, TB, D> for DeviceOpenBLAS

where TA: Clone + Send + Sync + Rem<TB, Output = TB>, TB: Clone + Send + Sync, D: DimAPI,

fn op_muta_refb( &self, b: &mut Vec<TB>, lb: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, ) -> Result<()>

fn op_muta_numb(&self, b: &mut Vec<TB>, lb: &Layout<D>, a: TA) -> Result<()>

impl<TA, TB, D> DeviceRConsumeShlAPI<TA, TB, D> for DeviceOpenBLAS

where TA: Clone + Send + Sync + Shl<TB, Output = TB>, TB: Clone + Send + Sync, D: DimAPI,

fn op_muta_refb( &self, b: &mut Vec<TB>, lb: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, ) -> Result<()>

fn op_muta_numb(&self, b: &mut Vec<TB>, lb: &Layout<D>, a: TA) -> Result<()>

impl<TA, TB, D> DeviceRConsumeShrAPI<TA, TB, D> for DeviceOpenBLAS

where TA: Clone + Send + Sync + Shr<TB, Output = TB>, TB: Clone + Send + Sync, D: DimAPI,

fn op_muta_refb( &self, b: &mut Vec<TB>, lb: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, ) -> Result<()>

fn op_muta_numb(&self, b: &mut Vec<TB>, lb: &Layout<D>, a: TA) -> Result<()>

impl<TA, TB, D> DeviceRConsumeSubAPI<TA, TB, D> for DeviceOpenBLAS

where TA: Clone + Send + Sync + Sub<TB, Output = TB>, TB: Clone + Send + Sync, D: DimAPI,

fn op_muta_refb( &self, b: &mut Vec<TB>, lb: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, ) -> Result<()>

fn op_muta_numb(&self, b: &mut Vec<TB>, lb: &Layout<D>, a: TA) -> Result<()>

impl<T> DeviceRawAPI<T> for DeviceOpenBLAS

type Raw = Vec<T>

impl DeviceRayonAPI for DeviceOpenBLAS

fn set_num_threads(&mut self, num_threads: usize)

Set the number of threads for the device.

fn get_num_threads(&self) -> usize

Get the number of threads for the device.

fn get_pool(&self) -> &ThreadPool

Get the thread pool for the device.

fn get_current_pool(&self) -> Option<&ThreadPool>

Get the current thread pool for the device.

impl<T, D> DeviceRealAPI<T, D> for DeviceOpenBLAS

where T: Clone + Send + Sync + ReImAPI, T::Out: Send + Sync, D: DimAPI,

type TOut = <T as ReImAPI>::Out

fn op_muta_refb( &self, a: &mut Vec<T::Out>, la: &Layout<D>, b: &Vec<T>, lb: &Layout<D>, ) -> Result<()>

fn op_muta(&self, a: &mut Vec<T::Out>, la: &Layout<D>) -> Result<()>

impl<TA, TB, TC, D> DeviceRemAPI<TA, TB, TC, D> for DeviceOpenBLAS

where TA: Clone + Send + Sync + Rem<TB, Output = TC>, TB: Clone + Send + Sync, TC: Clone + Send + Sync, D: DimAPI,

fn op_mutc_refa_refb( &self, c: &mut Vec<TC>, lc: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<()>

fn op_mutc_refa_numb( &self, c: &mut Vec<TC>, lc: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, b: TB, ) -> Result<()>

fn op_mutc_numa_refb( &self, c: &mut Vec<TC>, lc: &Layout<D>, a: TA, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<()>

impl<TA, TB, D> DeviceRemAssignAPI<TA, TB, D> for DeviceOpenBLAS

where TA: Clone + Send + Sync + RemAssign<TB>, TB: Clone + Send + Sync, D: DimAPI,

fn op_muta_refb( &self, a: &mut Vec<TA>, la: &Layout<D>, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<()>

fn op_muta_numb(&self, a: &mut Vec<TA>, la: &Layout<D>, b: TB) -> Result<()>

impl<T, D> DeviceRoundAPI<T, D> for DeviceOpenBLAS

where T: Clone + Send + Sync + Float, D: DimAPI,

type TOut = T

fn op_muta_refb( &self, a: &mut Vec<T>, la: &Layout<D>, b: &Vec<T>, lb: &Layout<D>, ) -> Result<()>

fn op_muta(&self, a: &mut Vec<T>, la: &Layout<D>) -> Result<()>

impl<TA, TB, TC, D> DeviceShlAPI<TA, TB, TC, D> for DeviceOpenBLAS

where TA: Clone + Send + Sync + Shl<TB, Output = TC>, TB: Clone + Send + Sync, TC: Clone + Send + Sync, D: DimAPI,

fn op_mutc_refa_refb( &self, c: &mut Vec<TC>, lc: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<()>

fn op_mutc_refa_numb( &self, c: &mut Vec<TC>, lc: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, b: TB, ) -> Result<()>

fn op_mutc_numa_refb( &self, c: &mut Vec<TC>, lc: &Layout<D>, a: TA, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<()>

impl<TA, TB, D> DeviceShlAssignAPI<TA, TB, D> for DeviceOpenBLAS

where TA: Clone + Send + Sync + ShlAssign<TB>, TB: Clone + Send + Sync, D: DimAPI,

fn op_muta_refb( &self, a: &mut Vec<TA>, la: &Layout<D>, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<()>

fn op_muta_numb(&self, a: &mut Vec<TA>, la: &Layout<D>, b: TB) -> Result<()>

impl<TA, TB, TC, D> DeviceShrAPI<TA, TB, TC, D> for DeviceOpenBLAS

where TA: Clone + Send + Sync + Shr<TB, Output = TC>, TB: Clone + Send + Sync, TC: Clone + Send + Sync, D: DimAPI,

fn op_mutc_refa_refb( &self, c: &mut Vec<TC>, lc: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<()>

fn op_mutc_refa_numb( &self, c: &mut Vec<TC>, lc: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, b: TB, ) -> Result<()>

fn op_mutc_numa_refb( &self, c: &mut Vec<TC>, lc: &Layout<D>, a: TA, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<()>

impl<TA, TB, D> DeviceShrAssignAPI<TA, TB, D> for DeviceOpenBLAS

where TA: Clone + Send + Sync + ShrAssign<TB>, TB: Clone + Send + Sync, D: DimAPI,

fn op_muta_refb( &self, a: &mut Vec<TA>, la: &Layout<D>, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<()>

fn op_muta_numb(&self, a: &mut Vec<TA>, la: &Layout<D>, b: TB) -> Result<()>

impl<T, D> DeviceSignAPI<T, D> for DeviceOpenBLAS

where T: Clone + Send + Sync + ComplexFloat + Div<T::Real, Output = T>, D: DimAPI,

type TOut = T

fn op_muta_refb( &self, a: &mut Vec<T>, la: &Layout<D>, b: &Vec<T>, lb: &Layout<D>, ) -> Result<()>

fn op_muta(&self, a: &mut Vec<T>, la: &Layout<D>) -> Result<()>

impl<T, D> DeviceSignBitAPI<T, D> for DeviceOpenBLAS

where T: Clone + Send + Sync + Signed, D: DimAPI,

type TOut = bool

fn op_muta_refb( &self, a: &mut Vec<bool>, la: &Layout<D>, b: &Vec<T>, lb: &Layout<D>, ) -> Result<()>

fn op_muta(&self, _a: &mut Vec<bool>, _la: &Layout<D>) -> Result<()>

impl<T, D> DeviceSinAPI<T, D> for DeviceOpenBLAS

where T: Clone + Send + Sync + ComplexFloat, D: DimAPI,

type TOut = T

fn op_muta_refb( &self, a: &mut Vec<T>, la: &Layout<D>, b: &Vec<T>, lb: &Layout<D>, ) -> Result<()>

fn op_muta(&self, a: &mut Vec<T>, la: &Layout<D>) -> Result<()>

impl<T, D> DeviceSinhAPI<T, D> for DeviceOpenBLAS

where T: Clone + Send + Sync + ComplexFloat, D: DimAPI,

type TOut = T

fn op_muta_refb( &self, a: &mut Vec<T>, la: &Layout<D>, b: &Vec<T>, lb: &Layout<D>, ) -> Result<()>

fn op_muta(&self, a: &mut Vec<T>, la: &Layout<D>) -> Result<()>

impl<T, D> DeviceSqrtAPI<T, D> for DeviceOpenBLAS

where T: Clone + Send + Sync + ComplexFloat, D: DimAPI,

type TOut = T

fn op_muta_refb( &self, a: &mut Vec<T>, la: &Layout<D>, b: &Vec<T>, lb: &Layout<D>, ) -> Result<()>

fn op_muta(&self, a: &mut Vec<T>, la: &Layout<D>) -> Result<()>

impl<T, D> DeviceSquareAPI<T, D> for DeviceOpenBLAS

where T: Clone + Send + Sync + Num, D: DimAPI,

type TOut = T

fn op_muta_refb( &self, a: &mut Vec<T>, la: &Layout<D>, b: &Vec<T>, lb: &Layout<D>, ) -> Result<()>

fn op_muta(&self, a: &mut Vec<T>, la: &Layout<D>) -> Result<()>

impl<T> DeviceStorageAPI<T> for DeviceOpenBLAS

fn len<R>(storage: &Storage<R, T, Self>) -> usize

where R: DataAPI<Data = Self::Raw>,

fn to_cpu_vec<R>(storage: &Storage<R, T, Self>) -> Result<Vec<T>>

where Self::Raw: Clone, R: DataAPI<Data = Self::Raw>,

fn into_cpu_vec<R>(storage: Storage<R, T, Self>) -> Result<Vec<T>>

where Self::Raw: Clone, R: DataCloneAPI<Data = Self::Raw>,

fn get_index<R>(storage: &Storage<R, T, Self>, index: usize) -> T

where T: Clone, R: DataAPI<Data = Self::Raw>,

fn get_index_ptr<R>(storage: &Storage<R, T, Self>, index: usize) -> *const T

where R: DataAPI<Data = Self::Raw>,

fn get_index_mut_ptr<R>( storage: &mut Storage<R, T, Self>, index: usize, ) -> *mut T

where R: DataMutAPI<Data = Self::Raw>,

fn set_index<R>(storage: &mut Storage<R, T, Self>, index: usize, value: T)

where R: DataMutAPI<Data = Self::Raw>,

fn is_empty<R>(storage: &Storage<R, T, Self>) -> bool

where R: DataAPI<Data = Self::Raw>,

impl<TA, TB, TC, D> DeviceSubAPI<TA, TB, TC, D> for DeviceOpenBLAS

where TA: Clone + Send + Sync + Sub<TB, Output = TC>, TB: Clone + Send + Sync, TC: Clone + Send + Sync, D: DimAPI,

fn op_mutc_refa_refb( &self, c: &mut Vec<TC>, lc: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<()>

fn op_mutc_refa_numb( &self, c: &mut Vec<TC>, lc: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, b: TB, ) -> Result<()>

fn op_mutc_numa_refb( &self, c: &mut Vec<TC>, lc: &Layout<D>, a: TA, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<()>

impl<TA, TB, D> DeviceSubAssignAPI<TA, TB, D> for DeviceOpenBLAS

where TA: Clone + Send + Sync + SubAssign<TB>, TB: Clone + Send + Sync, D: DimAPI,

fn op_muta_refb( &self, a: &mut Vec<TA>, la: &Layout<D>, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<()>

fn op_muta_numb(&self, a: &mut Vec<TA>, la: &Layout<D>, b: TB) -> Result<()>

impl<T, D> DeviceTanAPI<T, D> for DeviceOpenBLAS

where T: Clone + Send + Sync + ComplexFloat, D: DimAPI,

type TOut = T

fn op_muta_refb( &self, a: &mut Vec<T>, la: &Layout<D>, b: &Vec<T>, lb: &Layout<D>, ) -> Result<()>

fn op_muta(&self, a: &mut Vec<T>, la: &Layout<D>) -> Result<()>

impl<T, D> DeviceTanhAPI<T, D> for DeviceOpenBLAS

where T: Clone + Send + Sync + ComplexFloat, D: DimAPI,

type TOut = T

fn op_muta_refb( &self, a: &mut Vec<T>, la: &Layout<D>, b: &Vec<T>, lb: &Layout<D>, ) -> Result<()>

fn op_muta(&self, a: &mut Vec<T>, la: &Layout<D>) -> Result<()>

impl<T, D> DeviceTruncAPI<T, D> for DeviceOpenBLAS

where T: Clone + Send + Sync + Float, D: DimAPI,

type TOut = T

fn op_muta_refb( &self, a: &mut Vec<T>, la: &Layout<D>, b: &Vec<T>, lb: &Layout<D>, ) -> Result<()>

fn op_muta(&self, a: &mut Vec<T>, la: &Layout<D>) -> Result<()>

impl<T, D, R: DataAPI<Data = Vec<T>>> EighAPI<DeviceOpenBLAS> for &TensorAny<R, T, DeviceOpenBLAS, D>

where T: BlasFloat, D: DimAPI + DimSmallerOneAPI, D::SmallerOne: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = EighResult<TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<<T as ComplexFloat>::Real>>::Raw>, <T as ComplexFloat>::Real, DeviceOpenBLAS>, <D as DimSmallerOneAPI>::SmallerOne>, TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, D>>

fn eigh_f(self) -> Result<Self::Out>

fn eigh(self) -> Self::Out

where Self: Sized,

impl<T, D, R: DataAPI<Data = Vec<T>>> EighAPI<DeviceOpenBLAS> for (&TensorAny<R, T, DeviceOpenBLAS, D>, FlagUpLo)

where T: BlasFloat, D: DimAPI + DimSmallerOneAPI, D::SmallerOne: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = EighResult<TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<<T as ComplexFloat>::Real>>::Raw>, <T as ComplexFloat>::Real, DeviceOpenBLAS>, <D as DimSmallerOneAPI>::SmallerOne>, TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, D>>

fn eigh_f(self) -> Result<Self::Out>

fn eigh(self) -> Self::Out

where Self: Sized,

impl<T, D, R: DataAPI<Data = Vec<T>>> EighAPI<DeviceOpenBLAS> for (&TensorAny<R, T, DeviceOpenBLAS, D>, TensorView<'_, T, DeviceOpenBLAS, D>)

where T: BlasFloat, D: DimAPI + DimSmallerOneAPI, D::SmallerOne: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = EighResult<TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<<T as ComplexFloat>::Real>>::Raw>, <T as ComplexFloat>::Real, DeviceOpenBLAS>, <D as DimSmallerOneAPI>::SmallerOne>, TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, D>>

fn eigh_f(self) -> Result<Self::Out>

fn eigh(self) -> Self::Out

where Self: Sized,

impl<T, D, R: DataAPI<Data = Vec<T>>> EighAPI<DeviceOpenBLAS> for (&TensorAny<R, T, DeviceOpenBLAS, D>, TensorView<'_, T, DeviceOpenBLAS, D>, FlagUpLo)

where T: BlasFloat, D: DimAPI + DimSmallerOneAPI, D::SmallerOne: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = EighResult<TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<<T as ComplexFloat>::Real>>::Raw>, <T as ComplexFloat>::Real, DeviceOpenBLAS>, <D as DimSmallerOneAPI>::SmallerOne>, TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, D>>

fn eigh_f(self) -> Result<Self::Out>

fn eigh(self) -> Self::Out

where Self: Sized,

impl<T, D, R: DataAPI<Data = Vec<T>>> EighAPI<DeviceOpenBLAS> for (&TensorAny<R, T, DeviceOpenBLAS, D>, TensorView<'_, T, DeviceOpenBLAS, D>, FlagUpLo, i32)

where T: BlasFloat, D: DimAPI + DimSmallerOneAPI, D::SmallerOne: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = EighResult<TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<<T as ComplexFloat>::Real>>::Raw>, <T as ComplexFloat>::Real, DeviceOpenBLAS>, <D as DimSmallerOneAPI>::SmallerOne>, TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, D>>

fn eigh_f(self) -> Result<Self::Out>

fn eigh(self) -> Self::Out

where Self: Sized,

impl<T, D, Ra: DataAPI<Data = Vec<T>>, Rb: DataAPI<Data = Vec<T>>> EighAPI<DeviceOpenBLAS> for (&TensorAny<Ra, T, DeviceOpenBLAS, D>, &TensorAny<Rb, T, DeviceOpenBLAS, D>)

where T: BlasFloat, D: DimAPI + DimSmallerOneAPI, D::SmallerOne: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = EighResult<TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<<T as ComplexFloat>::Real>>::Raw>, <T as ComplexFloat>::Real, DeviceOpenBLAS>, <D as DimSmallerOneAPI>::SmallerOne>, TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, D>>

fn eigh_f(self) -> Result<Self::Out>

fn eigh(self) -> Self::Out

where Self: Sized,

impl<T, D, Ra: DataAPI<Data = Vec<T>>, Rb: DataAPI<Data = Vec<T>>> EighAPI<DeviceOpenBLAS> for (&TensorAny<Ra, T, DeviceOpenBLAS, D>, &TensorAny<Rb, T, DeviceOpenBLAS, D>, FlagUpLo)

where T: BlasFloat, D: DimAPI + DimSmallerOneAPI, D::SmallerOne: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = EighResult<TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<<T as ComplexFloat>::Real>>::Raw>, <T as ComplexFloat>::Real, DeviceOpenBLAS>, <D as DimSmallerOneAPI>::SmallerOne>, TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, D>>

fn eigh_f(self) -> Result<Self::Out>

fn eigh(self) -> Self::Out

where Self: Sized,

impl<T, D, Ra: DataAPI<Data = Vec<T>>, Rb: DataAPI<Data = Vec<T>>> EighAPI<DeviceOpenBLAS> for (&TensorAny<Ra, T, DeviceOpenBLAS, D>, &TensorAny<Rb, T, DeviceOpenBLAS, D>, FlagUpLo, i32)

where T: BlasFloat, D: DimAPI + DimSmallerOneAPI, D::SmallerOne: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = EighResult<TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<<T as ComplexFloat>::Real>>::Raw>, <T as ComplexFloat>::Real, DeviceOpenBLAS>, <D as DimSmallerOneAPI>::SmallerOne>, TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, D>>

fn eigh_f(self) -> Result<Self::Out>

fn eigh(self) -> Self::Out

where Self: Sized,

impl<'a, T, D> EighAPI<DeviceOpenBLAS> for (TensorMut<'a, T, DeviceOpenBLAS, D>, FlagUpLo)

where T: BlasFloat, D: DimAPI + DimSmallerOneAPI, D::SmallerOne: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = EighResult<TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<<T as ComplexFloat>::Real>>::Raw>, <T as ComplexFloat>::Real, DeviceOpenBLAS>, <D as DimSmallerOneAPI>::SmallerOne>, TensorBase<Storage<DataMut<'a, <DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, D>>

fn eigh_f(self) -> Result<Self::Out>

fn eigh(self) -> Self::Out

where Self: Sized,

impl<T, D> EighAPI<DeviceOpenBLAS> for (Tensor<T, DeviceOpenBLAS, D>, FlagUpLo)

where T: BlasFloat, D: DimAPI + DimSmallerOneAPI, D::SmallerOne: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = EighResult<TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<<T as ComplexFloat>::Real>>::Raw>, <T as ComplexFloat>::Real, DeviceOpenBLAS>, <D as DimSmallerOneAPI>::SmallerOne>, TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, D>>

fn eigh_f(self) -> Result<Self::Out>

fn eigh(self) -> Self::Out

where Self: Sized,

impl<T, D, R: DataAPI<Data = Vec<T>>> EighAPI<DeviceOpenBLAS> for (TensorView<'_, T, DeviceOpenBLAS, D>, &TensorAny<R, T, DeviceOpenBLAS, D>)

where T: BlasFloat, D: DimAPI + DimSmallerOneAPI, D::SmallerOne: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = EighResult<TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<<T as ComplexFloat>::Real>>::Raw>, <T as ComplexFloat>::Real, DeviceOpenBLAS>, <D as DimSmallerOneAPI>::SmallerOne>, TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, D>>

fn eigh_f(self) -> Result<Self::Out>

fn eigh(self) -> Self::Out

where Self: Sized,

impl<T, D, R: DataAPI<Data = Vec<T>>> EighAPI<DeviceOpenBLAS> for (TensorView<'_, T, DeviceOpenBLAS, D>, &TensorAny<R, T, DeviceOpenBLAS, D>, FlagUpLo)

where T: BlasFloat, D: DimAPI + DimSmallerOneAPI, D::SmallerOne: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = EighResult<TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<<T as ComplexFloat>::Real>>::Raw>, <T as ComplexFloat>::Real, DeviceOpenBLAS>, <D as DimSmallerOneAPI>::SmallerOne>, TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, D>>

fn eigh_f(self) -> Result<Self::Out>

fn eigh(self) -> Self::Out

where Self: Sized,

impl<T, D, R: DataAPI<Data = Vec<T>>> EighAPI<DeviceOpenBLAS> for (TensorView<'_, T, DeviceOpenBLAS, D>, &TensorAny<R, T, DeviceOpenBLAS, D>, FlagUpLo, i32)

where T: BlasFloat, D: DimAPI + DimSmallerOneAPI, D::SmallerOne: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = EighResult<TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<<T as ComplexFloat>::Real>>::Raw>, <T as ComplexFloat>::Real, DeviceOpenBLAS>, <D as DimSmallerOneAPI>::SmallerOne>, TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, D>>

fn eigh_f(self) -> Result<Self::Out>

fn eigh(self) -> Self::Out

where Self: Sized,

impl<T, D> EighAPI<DeviceOpenBLAS> for (TensorView<'_, T, DeviceOpenBLAS, D>, FlagUpLo)

where T: BlasFloat, D: DimAPI + DimSmallerOneAPI, D::SmallerOne: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = EighResult<TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<<T as ComplexFloat>::Real>>::Raw>, <T as ComplexFloat>::Real, DeviceOpenBLAS>, <D as DimSmallerOneAPI>::SmallerOne>, TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, D>>

fn eigh_f(self) -> Result<Self::Out>

fn eigh(self) -> Self::Out

where Self: Sized,

impl<T, D> EighAPI<DeviceOpenBLAS> for (TensorView<'_, T, DeviceOpenBLAS, D>, TensorView<'_, T, DeviceOpenBLAS, D>)

where T: BlasFloat, D: DimAPI + DimSmallerOneAPI, D::SmallerOne: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = EighResult<TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<<T as ComplexFloat>::Real>>::Raw>, <T as ComplexFloat>::Real, DeviceOpenBLAS>, <D as DimSmallerOneAPI>::SmallerOne>, TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, D>>

fn eigh_f(self) -> Result<Self::Out>

fn eigh(self) -> Self::Out

where Self: Sized,

impl<T, D> EighAPI<DeviceOpenBLAS> for (TensorView<'_, T, DeviceOpenBLAS, D>, TensorView<'_, T, DeviceOpenBLAS, D>, FlagUpLo)

where T: BlasFloat, D: DimAPI + DimSmallerOneAPI, D::SmallerOne: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = EighResult<TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<<T as ComplexFloat>::Real>>::Raw>, <T as ComplexFloat>::Real, DeviceOpenBLAS>, <D as DimSmallerOneAPI>::SmallerOne>, TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, D>>

fn eigh_f(self) -> Result<Self::Out>

fn eigh(self) -> Self::Out

where Self: Sized,

impl<T, D> EighAPI<DeviceOpenBLAS> for (TensorView<'_, T, DeviceOpenBLAS, D>, TensorView<'_, T, DeviceOpenBLAS, D>, FlagUpLo, i32)

where T: BlasFloat, D: DimAPI + DimSmallerOneAPI, D::SmallerOne: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = EighResult<TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<<T as ComplexFloat>::Real>>::Raw>, <T as ComplexFloat>::Real, DeviceOpenBLAS>, <D as DimSmallerOneAPI>::SmallerOne>, TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, D>>

fn eigh_f(self) -> Result<Self::Out>

fn eigh(self) -> Self::Out

where Self: Sized,

impl<'a, 'b, T> EighAPI<DeviceOpenBLAS> for EighArgs_<'a, 'b, DeviceOpenBLAS, T>

where T: BlasFloat, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = EighResult<TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<<T as ComplexFloat>::Real>>::Raw>, <T as ComplexFloat>::Real, DeviceOpenBLAS>, [usize; 1]>, TensorMutable<'a, T, DeviceOpenBLAS, [usize; 2]>>

fn eigh_f(self) -> Result<Self::Out>

fn eigh(self) -> Self::Out

where Self: Sized,

impl<'a, 'b, T> EighAPI<DeviceOpenBLAS> for EighArgs<'a, 'b, DeviceOpenBLAS, T>

where T: BlasFloat, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = EighResult<TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<<T as ComplexFloat>::Real>>::Raw>, <T as ComplexFloat>::Real, DeviceOpenBLAS>, [usize; 1]>, TensorMutable<'a, T, DeviceOpenBLAS, [usize; 2]>>

fn eigh_f(self) -> Result<Self::Out>

fn eigh(self) -> Self::Out

where Self: Sized,

impl<'a, T, D> EighAPI<DeviceOpenBLAS> for TensorMut<'a, T, DeviceOpenBLAS, D>

where T: BlasFloat, D: DimAPI + DimSmallerOneAPI, D::SmallerOne: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = EighResult<TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<<T as ComplexFloat>::Real>>::Raw>, <T as ComplexFloat>::Real, DeviceOpenBLAS>, <D as DimSmallerOneAPI>::SmallerOne>, TensorBase<Storage<DataMut<'a, <DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, D>>

fn eigh_f(self) -> Result<Self::Out>

fn eigh(self) -> Self::Out

where Self: Sized,

impl<T, D> EighAPI<DeviceOpenBLAS> for Tensor<T, DeviceOpenBLAS, D>

where T: BlasFloat, D: DimAPI + DimSmallerOneAPI, D::SmallerOne: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = EighResult<TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<<T as ComplexFloat>::Real>>::Raw>, <T as ComplexFloat>::Real, DeviceOpenBLAS>, <D as DimSmallerOneAPI>::SmallerOne>, TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, D>>

fn eigh_f(self) -> Result<Self::Out>

fn eigh(self) -> Self::Out

where Self: Sized,

impl<T, D> EighAPI<DeviceOpenBLAS> for TensorView<'_, T, DeviceOpenBLAS, D>

where T: BlasFloat, D: DimAPI + DimSmallerOneAPI, D::SmallerOne: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = EighResult<TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<<T as ComplexFloat>::Real>>::Raw>, <T as ComplexFloat>::Real, DeviceOpenBLAS>, <D as DimSmallerOneAPI>::SmallerOne>, TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, D>>

fn eigh_f(self) -> Result<Self::Out>

fn eigh(self) -> Self::Out

where Self: Sized,

impl<T, D, R: DataAPI<Data = Vec<T>>> EigvalshAPI<DeviceOpenBLAS> for &TensorAny<R, T, DeviceOpenBLAS, D>

where T: BlasFloat, D: DimAPI + DimSmallerOneAPI, D::SmallerOne: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<<T as ComplexFloat>::Real>>::Raw>, <T as ComplexFloat>::Real, DeviceOpenBLAS>, <D as DimSmallerOneAPI>::SmallerOne>

fn eigvalsh_f(self) -> Result<Self::Out>

fn eigvalsh(self) -> Self::Out

where Self: Sized,

impl<T, D, R: DataAPI<Data = Vec<T>>> EigvalshAPI<DeviceOpenBLAS> for (&TensorAny<R, T, DeviceOpenBLAS, D>, FlagUpLo)

where T: BlasFloat, D: DimAPI + DimSmallerOneAPI, D::SmallerOne: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<<T as ComplexFloat>::Real>>::Raw>, <T as ComplexFloat>::Real, DeviceOpenBLAS>, <D as DimSmallerOneAPI>::SmallerOne>

fn eigvalsh_f(self) -> Result<Self::Out>

fn eigvalsh(self) -> Self::Out

where Self: Sized,

impl<T, D, R: DataAPI<Data = Vec<T>>> EigvalshAPI<DeviceOpenBLAS> for (&TensorAny<R, T, DeviceOpenBLAS, D>, TensorView<'_, T, DeviceOpenBLAS, D>)

where T: BlasFloat, D: DimAPI + DimSmallerOneAPI, D::SmallerOne: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<<T as ComplexFloat>::Real>>::Raw>, <T as ComplexFloat>::Real, DeviceOpenBLAS>, <D as DimSmallerOneAPI>::SmallerOne>

fn eigvalsh_f(self) -> Result<Self::Out>

fn eigvalsh(self) -> Self::Out

where Self: Sized,

impl<T, D, R: DataAPI<Data = Vec<T>>> EigvalshAPI<DeviceOpenBLAS> for (&TensorAny<R, T, DeviceOpenBLAS, D>, TensorView<'_, T, DeviceOpenBLAS, D>, FlagUpLo)

where T: BlasFloat, D: DimAPI + DimSmallerOneAPI, D::SmallerOne: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<<T as ComplexFloat>::Real>>::Raw>, <T as ComplexFloat>::Real, DeviceOpenBLAS>, <D as DimSmallerOneAPI>::SmallerOne>

fn eigvalsh_f(self) -> Result<Self::Out>

fn eigvalsh(self) -> Self::Out

where Self: Sized,

impl<T, D, R: DataAPI<Data = Vec<T>>> EigvalshAPI<DeviceOpenBLAS> for (&TensorAny<R, T, DeviceOpenBLAS, D>, TensorView<'_, T, DeviceOpenBLAS, D>, FlagUpLo, i32)

where T: BlasFloat, D: DimAPI + DimSmallerOneAPI, D::SmallerOne: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<<T as ComplexFloat>::Real>>::Raw>, <T as ComplexFloat>::Real, DeviceOpenBLAS>, <D as DimSmallerOneAPI>::SmallerOne>

fn eigvalsh_f(self) -> Result<Self::Out>

fn eigvalsh(self) -> Self::Out

where Self: Sized,

impl<T, D, Ra: DataAPI<Data = Vec<T>>, Rb: DataAPI<Data = Vec<T>>> EigvalshAPI<DeviceOpenBLAS> for (&TensorAny<Ra, T, DeviceOpenBLAS, D>, &TensorAny<Rb, T, DeviceOpenBLAS, D>)

where T: BlasFloat, D: DimAPI + DimSmallerOneAPI, D::SmallerOne: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<<T as ComplexFloat>::Real>>::Raw>, <T as ComplexFloat>::Real, DeviceOpenBLAS>, <D as DimSmallerOneAPI>::SmallerOne>

fn eigvalsh_f(self) -> Result<Self::Out>

fn eigvalsh(self) -> Self::Out

where Self: Sized,

impl<T, D, Ra: DataAPI<Data = Vec<T>>, Rb: DataAPI<Data = Vec<T>>> EigvalshAPI<DeviceOpenBLAS> for (&TensorAny<Ra, T, DeviceOpenBLAS, D>, &TensorAny<Rb, T, DeviceOpenBLAS, D>, FlagUpLo)

where T: BlasFloat, D: DimAPI + DimSmallerOneAPI, D::SmallerOne: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<<T as ComplexFloat>::Real>>::Raw>, <T as ComplexFloat>::Real, DeviceOpenBLAS>, <D as DimSmallerOneAPI>::SmallerOne>

fn eigvalsh_f(self) -> Result<Self::Out>

fn eigvalsh(self) -> Self::Out

where Self: Sized,

impl<T, D, Ra: DataAPI<Data = Vec<T>>, Rb: DataAPI<Data = Vec<T>>> EigvalshAPI<DeviceOpenBLAS> for (&TensorAny<Ra, T, DeviceOpenBLAS, D>, &TensorAny<Rb, T, DeviceOpenBLAS, D>, FlagUpLo, i32)

where T: BlasFloat, D: DimAPI + DimSmallerOneAPI, D::SmallerOne: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<<T as ComplexFloat>::Real>>::Raw>, <T as ComplexFloat>::Real, DeviceOpenBLAS>, <D as DimSmallerOneAPI>::SmallerOne>

fn eigvalsh_f(self) -> Result<Self::Out>

fn eigvalsh(self) -> Self::Out

where Self: Sized,

impl<'a, T, D> EigvalshAPI<DeviceOpenBLAS> for (TensorMut<'a, T, DeviceOpenBLAS, D>, FlagUpLo)

where T: BlasFloat, D: DimAPI + DimSmallerOneAPI, D::SmallerOne: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<<T as ComplexFloat>::Real>>::Raw>, <T as ComplexFloat>::Real, DeviceOpenBLAS>, <D as DimSmallerOneAPI>::SmallerOne>

fn eigvalsh_f(self) -> Result<Self::Out>

fn eigvalsh(self) -> Self::Out

where Self: Sized,

impl<T, D> EigvalshAPI<DeviceOpenBLAS> for (Tensor<T, DeviceOpenBLAS, D>, FlagUpLo)

where T: BlasFloat, D: DimAPI + DimSmallerOneAPI, D::SmallerOne: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<<T as ComplexFloat>::Real>>::Raw>, <T as ComplexFloat>::Real, DeviceOpenBLAS>, <D as DimSmallerOneAPI>::SmallerOne>

fn eigvalsh_f(self) -> Result<Self::Out>

fn eigvalsh(self) -> Self::Out

where Self: Sized,

impl<T, D, R: DataAPI<Data = Vec<T>>> EigvalshAPI<DeviceOpenBLAS> for (TensorView<'_, T, DeviceOpenBLAS, D>, &TensorAny<R, T, DeviceOpenBLAS, D>)

where T: BlasFloat, D: DimAPI + DimSmallerOneAPI, D::SmallerOne: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<<T as ComplexFloat>::Real>>::Raw>, <T as ComplexFloat>::Real, DeviceOpenBLAS>, <D as DimSmallerOneAPI>::SmallerOne>

fn eigvalsh_f(self) -> Result<Self::Out>

fn eigvalsh(self) -> Self::Out

where Self: Sized,

impl<T, D, R: DataAPI<Data = Vec<T>>> EigvalshAPI<DeviceOpenBLAS> for (TensorView<'_, T, DeviceOpenBLAS, D>, &TensorAny<R, T, DeviceOpenBLAS, D>, FlagUpLo)

where T: BlasFloat, D: DimAPI + DimSmallerOneAPI, D::SmallerOne: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<<T as ComplexFloat>::Real>>::Raw>, <T as ComplexFloat>::Real, DeviceOpenBLAS>, <D as DimSmallerOneAPI>::SmallerOne>

fn eigvalsh_f(self) -> Result<Self::Out>

fn eigvalsh(self) -> Self::Out

where Self: Sized,

impl<T, D, R: DataAPI<Data = Vec<T>>> EigvalshAPI<DeviceOpenBLAS> for (TensorView<'_, T, DeviceOpenBLAS, D>, &TensorAny<R, T, DeviceOpenBLAS, D>, FlagUpLo, i32)

where T: BlasFloat, D: DimAPI + DimSmallerOneAPI, D::SmallerOne: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<<T as ComplexFloat>::Real>>::Raw>, <T as ComplexFloat>::Real, DeviceOpenBLAS>, <D as DimSmallerOneAPI>::SmallerOne>

fn eigvalsh_f(self) -> Result<Self::Out>

fn eigvalsh(self) -> Self::Out

where Self: Sized,

impl<T, D> EigvalshAPI<DeviceOpenBLAS> for (TensorView<'_, T, DeviceOpenBLAS, D>, FlagUpLo)

where T: BlasFloat, D: DimAPI + DimSmallerOneAPI, D::SmallerOne: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<<T as ComplexFloat>::Real>>::Raw>, <T as ComplexFloat>::Real, DeviceOpenBLAS>, <D as DimSmallerOneAPI>::SmallerOne>

fn eigvalsh_f(self) -> Result<Self::Out>

fn eigvalsh(self) -> Self::Out

where Self: Sized,

impl<T, D> EigvalshAPI<DeviceOpenBLAS> for (TensorView<'_, T, DeviceOpenBLAS, D>, TensorView<'_, T, DeviceOpenBLAS, D>)

where T: BlasFloat, D: DimAPI + DimSmallerOneAPI, D::SmallerOne: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<<T as ComplexFloat>::Real>>::Raw>, <T as ComplexFloat>::Real, DeviceOpenBLAS>, <D as DimSmallerOneAPI>::SmallerOne>

fn eigvalsh_f(self) -> Result<Self::Out>

fn eigvalsh(self) -> Self::Out

where Self: Sized,

impl<T, D> EigvalshAPI<DeviceOpenBLAS> for (TensorView<'_, T, DeviceOpenBLAS, D>, TensorView<'_, T, DeviceOpenBLAS, D>, FlagUpLo)

where T: BlasFloat, D: DimAPI + DimSmallerOneAPI, D::SmallerOne: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<<T as ComplexFloat>::Real>>::Raw>, <T as ComplexFloat>::Real, DeviceOpenBLAS>, <D as DimSmallerOneAPI>::SmallerOne>

fn eigvalsh_f(self) -> Result<Self::Out>

fn eigvalsh(self) -> Self::Out

where Self: Sized,

impl<T, D> EigvalshAPI<DeviceOpenBLAS> for (TensorView<'_, T, DeviceOpenBLAS, D>, TensorView<'_, T, DeviceOpenBLAS, D>, FlagUpLo, i32)

where T: BlasFloat, D: DimAPI + DimSmallerOneAPI, D::SmallerOne: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<<T as ComplexFloat>::Real>>::Raw>, <T as ComplexFloat>::Real, DeviceOpenBLAS>, <D as DimSmallerOneAPI>::SmallerOne>

fn eigvalsh_f(self) -> Result<Self::Out>

fn eigvalsh(self) -> Self::Out

where Self: Sized,

impl<'a, 'b, T> EigvalshAPI<DeviceOpenBLAS> for EighArgs_<'a, 'b, DeviceOpenBLAS, T>

where T: BlasFloat, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<<T as ComplexFloat>::Real>>::Raw>, <T as ComplexFloat>::Real, DeviceOpenBLAS>, [usize; 1]>

fn eigvalsh_f(self) -> Result<Self::Out>

fn eigvalsh(self) -> Self::Out

where Self: Sized,

impl<'a, 'b, T> EigvalshAPI<DeviceOpenBLAS> for EighArgs<'a, 'b, DeviceOpenBLAS, T>

where T: BlasFloat, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<<T as ComplexFloat>::Real>>::Raw>, <T as ComplexFloat>::Real, DeviceOpenBLAS>, [usize; 1]>

fn eigvalsh_f(self) -> Result<Self::Out>

fn eigvalsh(self) -> Self::Out

where Self: Sized,

impl<'a, T, D> EigvalshAPI<DeviceOpenBLAS> for TensorMut<'a, T, DeviceOpenBLAS, D>

where T: BlasFloat, D: DimAPI + DimSmallerOneAPI, D::SmallerOne: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<<T as ComplexFloat>::Real>>::Raw>, <T as ComplexFloat>::Real, DeviceOpenBLAS>, <D as DimSmallerOneAPI>::SmallerOne>

fn eigvalsh_f(self) -> Result<Self::Out>

fn eigvalsh(self) -> Self::Out

where Self: Sized,

impl<T, D> EigvalshAPI<DeviceOpenBLAS> for Tensor<T, DeviceOpenBLAS, D>

where T: BlasFloat, D: DimAPI + DimSmallerOneAPI, D::SmallerOne: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<<T as ComplexFloat>::Real>>::Raw>, <T as ComplexFloat>::Real, DeviceOpenBLAS>, <D as DimSmallerOneAPI>::SmallerOne>

fn eigvalsh_f(self) -> Result<Self::Out>

fn eigvalsh(self) -> Self::Out

where Self: Sized,

impl<T, D> EigvalshAPI<DeviceOpenBLAS> for TensorView<'_, T, DeviceOpenBLAS, D>

where T: BlasFloat, D: DimAPI + DimSmallerOneAPI, D::SmallerOne: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<<T as ComplexFloat>::Real>>::Raw>, <T as ComplexFloat>::Real, DeviceOpenBLAS>, <D as DimSmallerOneAPI>::SmallerOne>

fn eigvalsh_f(self) -> Result<Self::Out>

fn eigvalsh(self) -> Self::Out

where Self: Sized,

impl GEMMDriverAPI<Complex<f32>> for DeviceOpenBLAS

unsafe fn driver_gemm( order: FlagOrder, transa: FlagTrans, transb: FlagTrans, m: usize, n: usize, k: usize, alpha: Complex<f32>, a: *const Complex<f32>, lda: usize, b: *const Complex<f32>, ldb: usize, beta: Complex<f32>, c: *mut Complex<f32>, ldc: usize, )

impl GEMMDriverAPI<Complex<f64>> for DeviceOpenBLAS

unsafe fn driver_gemm( order: FlagOrder, transa: FlagTrans, transb: FlagTrans, m: usize, n: usize, k: usize, alpha: Complex<f64>, a: *const Complex<f64>, lda: usize, b: *const Complex<f64>, ldb: usize, beta: Complex<f64>, c: *mut Complex<f64>, ldc: usize, )

impl GEMMDriverAPI<f32> for DeviceOpenBLAS

unsafe fn driver_gemm( order: FlagOrder, transa: FlagTrans, transb: FlagTrans, m: usize, n: usize, k: usize, alpha: f32, a: *const f32, lda: usize, b: *const f32, ldb: usize, beta: f32, c: *mut f32, ldc: usize, )

impl GEMMDriverAPI<f64> for DeviceOpenBLAS

unsafe fn driver_gemm( order: FlagOrder, transa: FlagTrans, transb: FlagTrans, m: usize, n: usize, k: usize, alpha: f64, a: *const f64, lda: usize, b: *const f64, ldb: usize, beta: f64, c: *mut f64, ldc: usize, )

impl GESDDDriverAPI<Complex<f32>> for DeviceOpenBLAS

unsafe fn driver_gesdd( order: FlagOrder, jobz: char, m: usize, n: usize, a: *mut Complex<f32>, lda: usize, s: *mut <Complex<f32> as ComplexFloat>::Real, u: *mut Complex<f32>, ldu: usize, vt: *mut Complex<f32>, ldvt: usize, ) -> blas_int

impl GESDDDriverAPI<Complex<f64>> for DeviceOpenBLAS

unsafe fn driver_gesdd( order: FlagOrder, jobz: char, m: usize, n: usize, a: *mut Complex<f64>, lda: usize, s: *mut <Complex<f64> as ComplexFloat>::Real, u: *mut Complex<f64>, ldu: usize, vt: *mut Complex<f64>, ldvt: usize, ) -> blas_int

impl GESDDDriverAPI<f32> for DeviceOpenBLAS

unsafe fn driver_gesdd( order: FlagOrder, jobz: char, m: usize, n: usize, a: *mut f32, lda: usize, s: *mut f32, u: *mut f32, ldu: usize, vt: *mut f32, ldvt: usize, ) -> blas_int

impl GESDDDriverAPI<f64> for DeviceOpenBLAS

unsafe fn driver_gesdd( order: FlagOrder, jobz: char, m: usize, n: usize, a: *mut f64, lda: usize, s: *mut f64, u: *mut f64, ldu: usize, vt: *mut f64, ldvt: usize, ) -> blas_int

impl GESVDDriverAPI<Complex<f32>> for DeviceOpenBLAS

unsafe fn driver_gesvd( order: FlagOrder, jobu: char, jobvt: char, m: usize, n: usize, a: *mut Complex<f32>, lda: usize, s: *mut <Complex<f32> as ComplexFloat>::Real, u: *mut Complex<f32>, ldu: usize, vt: *mut Complex<f32>, ldvt: usize, superb: *mut <Complex<f32> as ComplexFloat>::Real, ) -> blas_int

impl GESVDDriverAPI<Complex<f64>> for DeviceOpenBLAS

unsafe fn driver_gesvd( order: FlagOrder, jobu: char, jobvt: char, m: usize, n: usize, a: *mut Complex<f64>, lda: usize, s: *mut <Complex<f64> as ComplexFloat>::Real, u: *mut Complex<f64>, ldu: usize, vt: *mut Complex<f64>, ldvt: usize, superb: *mut <Complex<f64> as ComplexFloat>::Real, ) -> blas_int

impl GESVDDriverAPI<f32> for DeviceOpenBLAS

unsafe fn driver_gesvd( order: FlagOrder, jobu: char, jobvt: char, m: usize, n: usize, a: *mut f32, lda: usize, s: *mut f32, u: *mut f32, ldu: usize, vt: *mut f32, ldvt: usize, superb: *mut f32, ) -> blas_int

impl GESVDDriverAPI<f64> for DeviceOpenBLAS

unsafe fn driver_gesvd( order: FlagOrder, jobu: char, jobvt: char, m: usize, n: usize, a: *mut f64, lda: usize, s: *mut f64, u: *mut f64, ldu: usize, vt: *mut f64, ldvt: usize, superb: *mut f64, ) -> blas_int

impl GESVDriverAPI<Complex<f32>> for DeviceOpenBLAS

unsafe fn driver_gesv( order: FlagOrder, n: usize, nrhs: usize, a: *mut Complex<f32>, lda: usize, ipiv: *mut blas_int, b: *mut Complex<f32>, ldb: usize, ) -> blas_int

impl GESVDriverAPI<Complex<f64>> for DeviceOpenBLAS

unsafe fn driver_gesv( order: FlagOrder, n: usize, nrhs: usize, a: *mut Complex<f64>, lda: usize, ipiv: *mut blas_int, b: *mut Complex<f64>, ldb: usize, ) -> blas_int

impl GESVDriverAPI<f32> for DeviceOpenBLAS

unsafe fn driver_gesv( order: FlagOrder, n: usize, nrhs: usize, a: *mut f32, lda: usize, ipiv: *mut blas_int, b: *mut f32, ldb: usize, ) -> blas_int

impl GESVDriverAPI<f64> for DeviceOpenBLAS

unsafe fn driver_gesv( order: FlagOrder, n: usize, nrhs: usize, a: *mut f64, lda: usize, ipiv: *mut blas_int, b: *mut f64, ldb: usize, ) -> blas_int

impl GETRFDriverAPI<Complex<f32>> for DeviceOpenBLAS

unsafe fn driver_getrf( order: FlagOrder, m: usize, n: usize, a: *mut Complex<f32>, lda: usize, ipiv: *mut blas_int, ) -> blas_int

impl GETRFDriverAPI<Complex<f64>> for DeviceOpenBLAS

unsafe fn driver_getrf( order: FlagOrder, m: usize, n: usize, a: *mut Complex<f64>, lda: usize, ipiv: *mut blas_int, ) -> blas_int

impl GETRFDriverAPI<f32> for DeviceOpenBLAS

unsafe fn driver_getrf( order: FlagOrder, m: usize, n: usize, a: *mut f32, lda: usize, ipiv: *mut blas_int, ) -> blas_int

impl GETRFDriverAPI<f64> for DeviceOpenBLAS

unsafe fn driver_getrf( order: FlagOrder, m: usize, n: usize, a: *mut f64, lda: usize, ipiv: *mut blas_int, ) -> blas_int

impl GETRIDriverAPI<Complex<f32>> for DeviceOpenBLAS

unsafe fn driver_getri( order: FlagOrder, n: usize, a: *mut Complex<f32>, lda: usize, ipiv: *mut blas_int, ) -> blas_int

impl GETRIDriverAPI<Complex<f64>> for DeviceOpenBLAS

unsafe fn driver_getri( order: FlagOrder, n: usize, a: *mut Complex<f64>, lda: usize, ipiv: *mut blas_int, ) -> blas_int

impl GETRIDriverAPI<f32> for DeviceOpenBLAS

unsafe fn driver_getri( order: FlagOrder, n: usize, a: *mut f32, lda: usize, ipiv: *mut blas_int, ) -> blas_int

impl GETRIDriverAPI<f64> for DeviceOpenBLAS

unsafe fn driver_getri( order: FlagOrder, n: usize, a: *mut f64, lda: usize, ipiv: *mut blas_int, ) -> blas_int

impl<T, D, R: DataAPI<Data = Vec<T>>> InvAPI<DeviceOpenBLAS> for &TensorAny<R, T, DeviceOpenBLAS, D>

where T: BlasFloat, D: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, D>

fn inv_f(self) -> Result<Self::Out>

fn inv(self) -> Self::Out

where Self: Sized,

impl<'a, T, D> InvAPI<DeviceOpenBLAS> for TensorMut<'a, T, DeviceOpenBLAS, D>

where T: BlasFloat, D: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = TensorBase<Storage<DataMut<'a, <DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, D>

fn inv_f(self) -> Result<Self::Out>

fn inv(self) -> Self::Out

where Self: Sized,

impl<T, D> InvAPI<DeviceOpenBLAS> for Tensor<T, DeviceOpenBLAS, D>

where T: BlasFloat, D: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, D>

fn inv_f(self) -> Result<Self::Out>

fn inv(self) -> Self::Out

where Self: Sized,

impl<T, D> InvAPI<DeviceOpenBLAS> for TensorView<'_, T, DeviceOpenBLAS, D>

where T: BlasFloat, D: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, D>

fn inv_f(self) -> Result<Self::Out>

fn inv(self) -> Self::Out

where Self: Sized,

impl<T, D> OpArgMaxAPI<T, D> for DeviceOpenBLAS

where T: Clone + PartialOrd + Send + Sync, D: DimAPI,

type TOut = usize

fn argmax_axes( &self, a: &Vec<T>, la: &Layout<D>, axes: &[isize], ) -> Result<(Storage<DataOwned<Vec<usize>>, Self::TOut, Self>, Layout<IxD>)>

fn argmax_all(&self, a: &Vec<T>, la: &Layout<D>) -> Result<Self::TOut>

impl<T, D> OpArgMinAPI<T, D> for DeviceOpenBLAS

where T: Clone + PartialOrd + Send + Sync, D: DimAPI,

type TOut = usize

fn argmin_axes( &self, a: &Vec<T>, la: &Layout<D>, axes: &[isize], ) -> Result<(Storage<DataOwned<Vec<usize>>, Self::TOut, Self>, Layout<IxD>)>

fn argmin_all(&self, a: &Vec<T>, la: &Layout<D>) -> Result<Self::TOut>

impl<T, D> OpAssignAPI<T, D> for DeviceOpenBLAS

where T: Clone + Send + Sync, D: DimAPI,

fn assign( &self, c: &mut Vec<T>, lc: &Layout<D>, a: &Vec<T>, la: &Layout<D>, ) -> Result<()>

Element-wise assignment for same layout arrays.

fn fill(&self, c: &mut Vec<T>, lc: &Layout<D>, fill: T) -> Result<()>

impl<T, DC, DA> OpAssignArbitaryAPI<T, DC, DA> for DeviceOpenBLAS

where T: Clone + Send + Sync, DC: DimAPI, DA: DimAPI,

fn assign_arbitary( &self, c: &mut Vec<T>, lc: &Layout<DC>, a: &Vec<T>, la: &Layout<DA>, ) -> Result<()>

Element-wise assignment in col-major order, without no promise that input layouts are broadcastable.

impl<T, D> OpL2NormAPI<T, D> for DeviceOpenBLAS

where T: Clone + Send + Sync + ComplexFloat + FromPrimitive, T::Real: Clone + Send + Sync + ComplexFloat + FromPrimitive, D: DimAPI,

type TOut = <T as ComplexFloat>::Real

fn l2_norm_all(&self, a: &Vec<T>, la: &Layout<D>) -> Result<T::Real>

fn l2_norm_axes( &self, a: &Vec<T>, la: &Layout<D>, axes: &[isize], ) -> Result<(Storage<DataOwned<Vec<T::Real>>, T::Real, Self>, Layout<IxD>)>

impl<T, D> OpMaxAPI<T, D> for DeviceOpenBLAS

where T: Clone + Send + Sync + MinMaxAPI + Bounded, D: DimAPI,

type TOut = T

fn max_all(&self, a: &Vec<T>, la: &Layout<D>) -> Result<T>

fn max_axes( &self, a: &Vec<T>, la: &Layout<D>, axes: &[isize], ) -> Result<(Storage<DataOwned<Vec<T>>, T, Self>, Layout<IxD>)>

impl<T, D> OpMeanAPI<T, D> for DeviceOpenBLAS

where T: Clone + Send + Sync + ComplexFloat + FromPrimitive, D: DimAPI,

type TOut = T

fn mean_all(&self, a: &Vec<T>, la: &Layout<D>) -> Result<T>

fn mean_axes( &self, a: &Vec<T>, la: &Layout<D>, axes: &[isize], ) -> Result<(Storage<DataOwned<Vec<T>>, T, Self>, Layout<IxD>)>

impl<T, D> OpMinAPI<T, D> for DeviceOpenBLAS

where T: Clone + Send + Sync + MinMaxAPI + Bounded, D: DimAPI,

type TOut = T

fn min_all(&self, a: &Vec<T>, la: &Layout<D>) -> Result<T>

fn min_axes( &self, a: &Vec<T>, la: &Layout<D>, axes: &[isize], ) -> Result<(Storage<DataOwned<Vec<T>>, T, Self>, Layout<IxD>)>

impl<T, D> OpProdAPI<T, D> for DeviceOpenBLAS

where T: Clone + Send + Sync + One + Mul<Output = T>, D: DimAPI,

type TOut = T

fn prod_all(&self, a: &Vec<T>, la: &Layout<D>) -> Result<T>

fn prod_axes( &self, a: &Vec<T>, la: &Layout<D>, axes: &[isize], ) -> Result<(Storage<DataOwned<Vec<T>>, T, Self>, Layout<IxD>)>

impl<T, D> OpStdAPI<T, D> for DeviceOpenBLAS

where T: Clone + Send + Sync + ComplexFloat + FromPrimitive, T::Real: Clone + Send + Sync + ComplexFloat + FromPrimitive, D: DimAPI,

type TOut = <T as ComplexFloat>::Real

fn std_all(&self, a: &Vec<T>, la: &Layout<D>) -> Result<T::Real>

fn std_axes( &self, a: &Vec<T>, la: &Layout<D>, axes: &[isize], ) -> Result<(Storage<DataOwned<Vec<T::Real>>, T::Real, Self>, Layout<IxD>)>

impl<T, D> OpSumAPI<T, D> for DeviceOpenBLAS

where T: Clone + Send + Sync + Zero + Add<Output = T>, D: DimAPI,

type TOut = T

fn sum_all(&self, a: &Vec<T>, la: &Layout<D>) -> Result<T>

fn sum_axes( &self, a: &Vec<T>, la: &Layout<D>, axes: &[isize], ) -> Result<(Storage<DataOwned<Vec<T>>, T, Self>, Layout<IxD>)>

impl<D> OpSumBoolAPI<D> for DeviceOpenBLAS

where D: DimAPI,

fn sum_all(&self, a: &Vec<bool>, la: &Layout<D>) -> Result<usize>

fn sum_axes( &self, a: &Vec<bool>, la: &Layout<D>, axes: &[isize], ) -> Result<(Storage<DataOwned<Vec<usize>>, usize, Self>, Layout<IxD>)>

impl<T, D> OpUnraveledArgMaxAPI<T, D> for DeviceOpenBLAS

where T: Clone + PartialOrd + Send + Sync, D: DimAPI,

fn unraveled_argmax_axes( &self, a: &Vec<T>, la: &Layout<D>, axes: &[isize], ) -> Result<(Storage<DataOwned<Vec<IxD>>, IxD, Self>, Layout<IxD>)>

fn unraveled_argmax_all( &self, a: &<Self as DeviceRawAPI<T>>::Raw, la: &Layout<D>, ) -> Result<D>

impl<T, D> OpUnraveledArgMinAPI<T, D> for DeviceOpenBLAS

where T: Clone + PartialOrd + Send + Sync, D: DimAPI,

fn unraveled_argmin_axes( &self, a: &Vec<T>, la: &Layout<D>, axes: &[isize], ) -> Result<(Storage<DataOwned<Vec<IxD>>, IxD, Self>, Layout<IxD>)>

fn unraveled_argmin_all( &self, a: &<Self as DeviceRawAPI<T>>::Raw, la: &Layout<D>, ) -> Result<D>

impl<T, D> OpVarAPI<T, D> for DeviceOpenBLAS

where T: Clone + Send + Sync + ComplexFloat + FromPrimitive, T::Real: Clone + Send + Sync + ComplexFloat + FromPrimitive, D: DimAPI,

type TOut = <T as ComplexFloat>::Real

fn var_all(&self, a: &Vec<T>, la: &Layout<D>) -> Result<T::Real>

fn var_axes( &self, a: &Vec<T>, la: &Layout<D>, axes: &[isize], ) -> Result<(Storage<DataOwned<Vec<T::Real>>, T::Real, Self>, Layout<IxD>)>

impl POTRFDriverAPI<Complex<f32>> for DeviceOpenBLAS

unsafe fn driver_potrf( order: FlagOrder, uplo: FlagUpLo, n: usize, a: *mut Complex<f32>, lda: usize, ) -> blas_int

impl POTRFDriverAPI<Complex<f64>> for DeviceOpenBLAS

unsafe fn driver_potrf( order: FlagOrder, uplo: FlagUpLo, n: usize, a: *mut Complex<f64>, lda: usize, ) -> blas_int

impl POTRFDriverAPI<f32> for DeviceOpenBLAS

unsafe fn driver_potrf( order: FlagOrder, uplo: FlagUpLo, n: usize, a: *mut f32, lda: usize, ) -> blas_int

impl POTRFDriverAPI<f64> for DeviceOpenBLAS

unsafe fn driver_potrf( order: FlagOrder, uplo: FlagUpLo, n: usize, a: *mut f64, lda: usize, ) -> blas_int

impl<T, D, R> PinvAPI<DeviceOpenBLAS> for &TensorAny<R, T, DeviceOpenBLAS, D>

where R: DataAPI<Data = Vec<T>>, T: BlasFloat, T::Real: FromPrimitive, D: DimAPI + DimSmallerOneAPI, D::SmallerOne: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = PinvResult<TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, D>>

fn pinv_f(self) -> Result<Self::Out>

fn pinv(self) -> Self::Out

where Self: Sized,

impl<T, D, R> PinvAPI<DeviceOpenBLAS> for (&TensorAny<R, T, DeviceOpenBLAS, D>, T::Real, T::Real)

where R: DataAPI<Data = Vec<T>>, T: BlasFloat, T::Real: FromPrimitive, D: DimAPI + DimSmallerOneAPI, D::SmallerOne: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = PinvResult<TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, D>>

fn pinv_f(self) -> Result<Self::Out>

fn pinv(self) -> Self::Out

where Self: Sized,

impl<T, D> PinvAPI<DeviceOpenBLAS> for (Tensor<T, DeviceOpenBLAS, D>, T::Real, T::Real)

where T: BlasFloat, T::Real: FromPrimitive, D: DimAPI + DimSmallerOneAPI, D::SmallerOne: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = PinvResult<TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, D>>

fn pinv_f(self) -> Result<Self::Out>

fn pinv(self) -> Self::Out

where Self: Sized,

impl<T, D> PinvAPI<DeviceOpenBLAS> for (TensorView<'_, T, DeviceOpenBLAS, D>, T::Real, T::Real)

where T: BlasFloat, T::Real: FromPrimitive, D: DimAPI + DimSmallerOneAPI, D::SmallerOne: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = PinvResult<TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, D>>

fn pinv_f(self) -> Result<Self::Out>

fn pinv(self) -> Self::Out

where Self: Sized,

impl<T, D> PinvAPI<DeviceOpenBLAS> for Tensor<T, DeviceOpenBLAS, D>

where T: BlasFloat, T::Real: FromPrimitive, D: DimAPI + DimSmallerOneAPI, D::SmallerOne: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = PinvResult<TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, D>>

fn pinv_f(self) -> Result<Self::Out>

fn pinv(self) -> Self::Out

where Self: Sized,

impl<T, D> PinvAPI<DeviceOpenBLAS> for TensorView<'_, T, DeviceOpenBLAS, D>

where T: BlasFloat, T::Real: FromPrimitive, D: DimAPI + DimSmallerOneAPI, D::SmallerOne: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = PinvResult<TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, D>>

fn pinv_f(self) -> Result<Self::Out>

fn pinv(self) -> Self::Out

where Self: Sized,

impl<T, D, R: DataAPI<Data = Vec<T>>> SLogDetAPI<DeviceOpenBLAS> for &TensorAny<R, T, DeviceOpenBLAS, D>

where T: BlasFloat, D: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = SLogDetResult<T>

fn slogdet_f(self) -> Result<Self::Out>

fn slogdet(self) -> Self::Out

where Self: Sized,

impl<'a, T, D> SLogDetAPI<DeviceOpenBLAS> for TensorMut<'a, T, DeviceOpenBLAS, D>

where T: BlasFloat, D: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = SLogDetResult<T>

fn slogdet_f(self) -> Result<Self::Out>

fn slogdet(self) -> Self::Out

where Self: Sized,

impl<T, D> SLogDetAPI<DeviceOpenBLAS> for Tensor<T, DeviceOpenBLAS, D>

where T: BlasFloat, D: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = SLogDetResult<T>

fn slogdet_f(self) -> Result<Self::Out>

fn slogdet(self) -> Self::Out

where Self: Sized,

impl<T, D> SLogDetAPI<DeviceOpenBLAS> for TensorView<'_, T, DeviceOpenBLAS, D>

where T: BlasFloat, D: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = SLogDetResult<T>

fn slogdet_f(self) -> Result<Self::Out>

fn slogdet(self) -> Self::Out

where Self: Sized,

impl<'a, T, D, R: DataAPI<Data = Vec<T>>> SVDAPI<DeviceOpenBLAS> for &'a TensorAny<R, T, DeviceOpenBLAS, D>

where T: BlasFloat, D: DimAPI, (&'a TensorAny<R, T, DeviceOpenBLAS, D>, bool): SVDAPI<DeviceOpenBLAS>,

type Out = <(&'a TensorBase<Storage<R, T, DeviceOpenBLAS>, D>, bool) as SVDAPI<DeviceOpenBLAS>>::Out

fn svd_f(self) -> Result<Self::Out>

fn svd(self) -> Self::Out

where Self: Sized,

impl<T, D, R> SVDAPI<DeviceOpenBLAS> for (&TensorAny<R, T, DeviceOpenBLAS, D>, bool)

where R: DataAPI<Data = Vec<T>>, T: BlasFloat, D: DimAPI + DimSmallerOneAPI, D::SmallerOne: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = SVDResult<TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, D>, TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<<T as ComplexFloat>::Real>>::Raw>, <T as ComplexFloat>::Real, DeviceOpenBLAS>, <D as DimSmallerOneAPI>::SmallerOne>, TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, D>>

fn svd_f(self) -> Result<Self::Out>

fn svd(self) -> Self::Out

where Self: Sized,

impl<T, D> SVDAPI<DeviceOpenBLAS> for (Tensor<T, DeviceOpenBLAS, D>, bool)

where T: BlasFloat, D: DimAPI + DimSmallerOneAPI, D::SmallerOne: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = SVDResult<TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, D>, TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<<T as ComplexFloat>::Real>>::Raw>, <T as ComplexFloat>::Real, DeviceOpenBLAS>, <D as DimSmallerOneAPI>::SmallerOne>, TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, D>>

fn svd_f(self) -> Result<Self::Out>

fn svd(self) -> Self::Out

where Self: Sized,

impl<T, D> SVDAPI<DeviceOpenBLAS> for (TensorView<'_, T, DeviceOpenBLAS, D>, bool)

where T: BlasFloat, D: DimAPI + DimSmallerOneAPI, D::SmallerOne: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = SVDResult<TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, D>, TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<<T as ComplexFloat>::Real>>::Raw>, <T as ComplexFloat>::Real, DeviceOpenBLAS>, <D as DimSmallerOneAPI>::SmallerOne>, TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, D>>

fn svd_f(self) -> Result<Self::Out>

fn svd(self) -> Self::Out

where Self: Sized,

impl<'a, T> SVDAPI<DeviceOpenBLAS> for SVDArgs_<'a, DeviceOpenBLAS, T>

where T: BlasFloat, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = SVDResult<TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, [usize; 2]>, TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<<T as ComplexFloat>::Real>>::Raw>, <T as ComplexFloat>::Real, DeviceOpenBLAS>, [usize; 1]>, TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, [usize; 2]>>

fn svd_f(self) -> Result<Self::Out>

fn svd(self) -> Self::Out

where Self: Sized,

impl<'a, T> SVDAPI<DeviceOpenBLAS> for SVDArgs<'a, DeviceOpenBLAS, T>

where T: BlasFloat, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = SVDResult<TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, [usize; 2]>, TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<<T as ComplexFloat>::Real>>::Raw>, <T as ComplexFloat>::Real, DeviceOpenBLAS>, [usize; 1]>, TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, [usize; 2]>>

fn svd_f(self) -> Result<Self::Out>

fn svd(self) -> Self::Out

where Self: Sized,

impl<T, D> SVDAPI<DeviceOpenBLAS> for Tensor<T, DeviceOpenBLAS, D>

where T: BlasFloat, D: DimAPI, (Tensor<T, DeviceOpenBLAS, D>, bool): SVDAPI<DeviceOpenBLAS>,

type Out = <(TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, D>, bool) as SVDAPI<DeviceOpenBLAS>>::Out

fn svd_f(self) -> Result<Self::Out>

fn svd(self) -> Self::Out

where Self: Sized,

impl<'a, T, D> SVDAPI<DeviceOpenBLAS> for TensorView<'a, T, DeviceOpenBLAS, D>

where T: BlasFloat, D: DimAPI, (TensorView<'a, T, DeviceOpenBLAS, D>, bool): SVDAPI<DeviceOpenBLAS>,

type Out = <(TensorBase<Storage<DataRef<'a, <DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, D>, bool) as SVDAPI<DeviceOpenBLAS>>::Out

fn svd_f(self) -> Result<Self::Out>

fn svd(self) -> Self::Out

where Self: Sized,

impl<T, D, R> SVDvalsAPI<DeviceOpenBLAS> for &TensorAny<R, T, DeviceOpenBLAS, D>

where R: DataAPI<Data = Vec<T>>, T: BlasFloat, D: DimAPI + DimSmallerOneAPI, D::SmallerOne: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<<T as ComplexFloat>::Real>>::Raw>, <T as ComplexFloat>::Real, DeviceOpenBLAS>, <D as DimSmallerOneAPI>::SmallerOne>

fn svdvals_f(self) -> Result<Self::Out>

fn svdvals(self) -> Self::Out

where Self: Sized,

impl<'a, T> SVDvalsAPI<DeviceOpenBLAS> for SVDArgs_<'a, DeviceOpenBLAS, T>

where T: BlasFloat, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<<T as ComplexFloat>::Real>>::Raw>, <T as ComplexFloat>::Real, DeviceOpenBLAS>, [usize; 1]>

fn svdvals_f(self) -> Result<Self::Out>

fn svdvals(self) -> Self::Out

where Self: Sized,

impl<'a, T> SVDvalsAPI<DeviceOpenBLAS> for SVDArgs<'a, DeviceOpenBLAS, T>

where T: BlasFloat, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<<T as ComplexFloat>::Real>>::Raw>, <T as ComplexFloat>::Real, DeviceOpenBLAS>, [usize; 1]>

fn svdvals_f(self) -> Result<Self::Out>

fn svdvals(self) -> Self::Out

where Self: Sized,

impl<T, D> SVDvalsAPI<DeviceOpenBLAS> for Tensor<T, DeviceOpenBLAS, D>

where T: BlasFloat, D: DimAPI + DimSmallerOneAPI, D::SmallerOne: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<<T as ComplexFloat>::Real>>::Raw>, <T as ComplexFloat>::Real, DeviceOpenBLAS>, <D as DimSmallerOneAPI>::SmallerOne>

fn svdvals_f(self) -> Result<Self::Out>

fn svdvals(self) -> Self::Out

where Self: Sized,

impl<T, D> SVDvalsAPI<DeviceOpenBLAS> for TensorView<'_, T, DeviceOpenBLAS, D>

where T: BlasFloat, D: DimAPI + DimSmallerOneAPI, D::SmallerOne: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<<T as ComplexFloat>::Real>>::Raw>, <T as ComplexFloat>::Real, DeviceOpenBLAS>, <D as DimSmallerOneAPI>::SmallerOne>

fn svdvals_f(self) -> Result<Self::Out>

fn svdvals(self) -> Self::Out

where Self: Sized,

impl SYEVDDriverAPI<Complex<f32>> for DeviceOpenBLAS

unsafe fn driver_syevd( order: FlagOrder, jobz: char, uplo: FlagUpLo, n: usize, a: *mut Complex<f32>, lda: usize, w: *mut <Complex<f32> as ComplexFloat>::Real, ) -> blas_int

impl SYEVDDriverAPI<Complex<f64>> for DeviceOpenBLAS

unsafe fn driver_syevd( order: FlagOrder, jobz: char, uplo: FlagUpLo, n: usize, a: *mut Complex<f64>, lda: usize, w: *mut <Complex<f64> as ComplexFloat>::Real, ) -> blas_int

impl SYEVDDriverAPI<f32> for DeviceOpenBLAS

unsafe fn driver_syevd( order: FlagOrder, jobz: char, uplo: FlagUpLo, n: usize, a: *mut f32, lda: usize, w: *mut f32, ) -> blas_int

impl SYEVDDriverAPI<f64> for DeviceOpenBLAS

unsafe fn driver_syevd( order: FlagOrder, jobz: char, uplo: FlagUpLo, n: usize, a: *mut f64, lda: usize, w: *mut f64, ) -> blas_int

impl SYEVDriverAPI<Complex<f32>> for DeviceOpenBLAS

unsafe fn driver_syev( order: FlagOrder, jobz: char, uplo: FlagUpLo, n: usize, a: *mut Complex<f32>, lda: usize, w: *mut <Complex<f32> as ComplexFloat>::Real, ) -> blas_int

impl SYEVDriverAPI<Complex<f64>> for DeviceOpenBLAS

unsafe fn driver_syev( order: FlagOrder, jobz: char, uplo: FlagUpLo, n: usize, a: *mut Complex<f64>, lda: usize, w: *mut <Complex<f64> as ComplexFloat>::Real, ) -> blas_int

impl SYEVDriverAPI<f32> for DeviceOpenBLAS

unsafe fn driver_syev( order: FlagOrder, jobz: char, uplo: FlagUpLo, n: usize, a: *mut f32, lda: usize, w: *mut f32, ) -> blas_int

impl SYEVDriverAPI<f64> for DeviceOpenBLAS

unsafe fn driver_syev( order: FlagOrder, jobz: char, uplo: FlagUpLo, n: usize, a: *mut f64, lda: usize, w: *mut f64, ) -> blas_int

impl SYGVDDriverAPI<Complex<f32>> for DeviceOpenBLAS

unsafe fn driver_sygvd( order: FlagOrder, itype: blas_int, jobz: char, uplo: FlagUpLo, n: usize, a: *mut Complex<f32>, lda: usize, b: *mut Complex<f32>, ldb: usize, w: *mut <Complex<f32> as ComplexFloat>::Real, ) -> blas_int

impl SYGVDDriverAPI<Complex<f64>> for DeviceOpenBLAS

unsafe fn driver_sygvd( order: FlagOrder, itype: blas_int, jobz: char, uplo: FlagUpLo, n: usize, a: *mut Complex<f64>, lda: usize, b: *mut Complex<f64>, ldb: usize, w: *mut <Complex<f64> as ComplexFloat>::Real, ) -> blas_int

impl SYGVDDriverAPI<f32> for DeviceOpenBLAS

unsafe fn driver_sygvd( order: FlagOrder, itype: blas_int, jobz: char, uplo: FlagUpLo, n: usize, a: *mut f32, lda: usize, b: *mut f32, ldb: usize, w: *mut f32, ) -> blas_int

impl SYGVDDriverAPI<f64> for DeviceOpenBLAS

unsafe fn driver_sygvd( order: FlagOrder, itype: blas_int, jobz: char, uplo: FlagUpLo, n: usize, a: *mut f64, lda: usize, b: *mut f64, ldb: usize, w: *mut f64, ) -> blas_int

impl SYGVDriverAPI<Complex<f32>> for DeviceOpenBLAS

unsafe fn driver_sygv( order: FlagOrder, itype: blas_int, jobz: char, uplo: FlagUpLo, n: usize, a: *mut Complex<f32>, lda: usize, b: *mut Complex<f32>, ldb: usize, w: *mut <Complex<f32> as ComplexFloat>::Real, ) -> blas_int

impl SYGVDriverAPI<Complex<f64>> for DeviceOpenBLAS

unsafe fn driver_sygv( order: FlagOrder, itype: blas_int, jobz: char, uplo: FlagUpLo, n: usize, a: *mut Complex<f64>, lda: usize, b: *mut Complex<f64>, ldb: usize, w: *mut <Complex<f64> as ComplexFloat>::Real, ) -> blas_int

impl SYGVDriverAPI<f32> for DeviceOpenBLAS

unsafe fn driver_sygv( order: FlagOrder, itype: blas_int, jobz: char, uplo: FlagUpLo, n: usize, a: *mut f32, lda: usize, b: *mut f32, ldb: usize, w: *mut f32, ) -> blas_int

impl SYGVDriverAPI<f64> for DeviceOpenBLAS

unsafe fn driver_sygv( order: FlagOrder, itype: blas_int, jobz: char, uplo: FlagUpLo, n: usize, a: *mut f64, lda: usize, b: *mut f64, ldb: usize, w: *mut f64, ) -> blas_int

impl SYHEMMDriverAPI<Complex<f32>, false> for DeviceOpenBLAS

unsafe fn driver_syhemm( order: FlagOrder, side: FlagSide, uplo: FlagUpLo, m: usize, n: usize, alpha: Complex<f32>, a: *const Complex<f32>, lda: usize, b: *const Complex<f32>, ldb: usize, beta: Complex<f32>, c: *mut Complex<f32>, ldc: usize, )

impl SYHEMMDriverAPI<Complex<f32>, true> for DeviceOpenBLAS

unsafe fn driver_syhemm( order: FlagOrder, side: FlagSide, uplo: FlagUpLo, m: usize, n: usize, alpha: Complex<f32>, a: *const Complex<f32>, lda: usize, b: *const Complex<f32>, ldb: usize, beta: Complex<f32>, c: *mut Complex<f32>, ldc: usize, )

impl SYHEMMDriverAPI<Complex<f64>, false> for DeviceOpenBLAS

unsafe fn driver_syhemm( order: FlagOrder, side: FlagSide, uplo: FlagUpLo, m: usize, n: usize, alpha: Complex<f64>, a: *const Complex<f64>, lda: usize, b: *const Complex<f64>, ldb: usize, beta: Complex<f64>, c: *mut Complex<f64>, ldc: usize, )

impl SYHEMMDriverAPI<Complex<f64>, true> for DeviceOpenBLAS

unsafe fn driver_syhemm( order: FlagOrder, side: FlagSide, uplo: FlagUpLo, m: usize, n: usize, alpha: Complex<f64>, a: *const Complex<f64>, lda: usize, b: *const Complex<f64>, ldb: usize, beta: Complex<f64>, c: *mut Complex<f64>, ldc: usize, )

impl<const HERMI: bool> SYHEMMDriverAPI<f32, HERMI> for DeviceOpenBLAS

unsafe fn driver_syhemm( order: FlagOrder, side: FlagSide, uplo: FlagUpLo, m: usize, n: usize, alpha: f32, a: *const f32, lda: usize, b: *const f32, ldb: usize, beta: f32, c: *mut f32, ldc: usize, )

impl<const HERMI: bool> SYHEMMDriverAPI<f64, HERMI> for DeviceOpenBLAS

unsafe fn driver_syhemm( order: FlagOrder, side: FlagSide, uplo: FlagUpLo, m: usize, n: usize, alpha: f64, a: *const f64, lda: usize, b: *const f64, ldb: usize, beta: f64, c: *mut f64, ldc: usize, )

impl SYSVDriverAPI<Complex<f32>, false> for DeviceOpenBLAS

unsafe fn driver_sysv( order: FlagOrder, uplo: FlagUpLo, n: usize, nrhs: usize, a: *mut Complex<f32>, lda: usize, ipiv: *mut blas_int, b: *mut Complex<f32>, ldb: usize, ) -> blas_int

impl SYSVDriverAPI<Complex<f32>, true> for DeviceOpenBLAS

unsafe fn driver_sysv( order: FlagOrder, uplo: FlagUpLo, n: usize, nrhs: usize, a: *mut Complex<f32>, lda: usize, ipiv: *mut blas_int, b: *mut Complex<f32>, ldb: usize, ) -> blas_int

impl SYSVDriverAPI<Complex<f64>, false> for DeviceOpenBLAS

unsafe fn driver_sysv( order: FlagOrder, uplo: FlagUpLo, n: usize, nrhs: usize, a: *mut Complex<f64>, lda: usize, ipiv: *mut blas_int, b: *mut Complex<f64>, ldb: usize, ) -> blas_int

impl SYSVDriverAPI<Complex<f64>, true> for DeviceOpenBLAS

unsafe fn driver_sysv( order: FlagOrder, uplo: FlagUpLo, n: usize, nrhs: usize, a: *mut Complex<f64>, lda: usize, ipiv: *mut blas_int, b: *mut Complex<f64>, ldb: usize, ) -> blas_int

impl<const HERMI: bool> SYSVDriverAPI<f32, HERMI> for DeviceOpenBLAS

unsafe fn driver_sysv( order: FlagOrder, uplo: FlagUpLo, n: usize, nrhs: usize, a: *mut f32, lda: usize, ipiv: *mut blas_int, b: *mut f32, ldb: usize, ) -> blas_int

impl<const HERMI: bool> SYSVDriverAPI<f64, HERMI> for DeviceOpenBLAS

unsafe fn driver_sysv( order: FlagOrder, uplo: FlagUpLo, n: usize, nrhs: usize, a: *mut f64, lda: usize, ipiv: *mut blas_int, b: *mut f64, ldb: usize, ) -> blas_int

impl<'b, T, DA, DB, R: DataAPI<Data = Vec<T>>> SolveGeneralAPI<DeviceOpenBLAS> for (&TensorAny<R, T, DeviceOpenBLAS, DA>, TensorMut<'b, T, DeviceOpenBLAS, DB>)

where T: BlasFloat, DA: DimAPI, DB: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = TensorBase<Storage<DataMut<'b, <DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, DB>

fn solve_general_f(self) -> Result<Self::Out>

fn solve_general(self) -> Self::Out

where Self: Sized,

impl<T, DA, DB, R: DataAPI<Data = Vec<T>>> SolveGeneralAPI<DeviceOpenBLAS> for (&TensorAny<R, T, DeviceOpenBLAS, DA>, Tensor<T, DeviceOpenBLAS, DB>)

where T: BlasFloat, DA: DimAPI, DB: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, DB>

fn solve_general_f(self) -> Result<Self::Out>

fn solve_general(self) -> Self::Out

where Self: Sized,

impl<T, DA, DB, R: DataAPI<Data = Vec<T>>> SolveGeneralAPI<DeviceOpenBLAS> for (&TensorAny<R, T, DeviceOpenBLAS, DA>, TensorView<'_, T, DeviceOpenBLAS, DB>)

where T: BlasFloat, DA: DimAPI, DB: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, DB>

fn solve_general_f(self) -> Result<Self::Out>

fn solve_general(self) -> Self::Out

where Self: Sized,

impl<T, DA, DB, Ra: DataAPI<Data = Vec<T>>, Rb: DataAPI<Data = Vec<T>>> SolveGeneralAPI<DeviceOpenBLAS> for (&TensorAny<Ra, T, DeviceOpenBLAS, DA>, &TensorAny<Rb, T, DeviceOpenBLAS, DB>)

where T: BlasFloat, DA: DimAPI, DB: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, DB>

fn solve_general_f(self) -> Result<Self::Out>

fn solve_general(self) -> Self::Out

where Self: Sized,

impl<T, DA, DB, R: DataAPI<Data = Vec<T>>> SolveGeneralAPI<DeviceOpenBLAS> for (TensorMut<'_, T, DeviceOpenBLAS, DA>, &TensorAny<R, T, DeviceOpenBLAS, DB>)

where T: BlasFloat, DA: DimAPI, DB: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, DB>

fn solve_general_f(self) -> Result<Self::Out>

fn solve_general(self) -> Self::Out

where Self: Sized,

impl<'b, T, DA, DB> SolveGeneralAPI<DeviceOpenBLAS> for (TensorMut<'_, T, DeviceOpenBLAS, DA>, TensorMut<'b, T, DeviceOpenBLAS, DB>)

where T: BlasFloat, DA: DimAPI, DB: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = TensorBase<Storage<DataMut<'b, <DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, DB>

fn solve_general_f(self) -> Result<Self::Out>

fn solve_general(self) -> Self::Out

where Self: Sized,

impl<T, DA, DB> SolveGeneralAPI<DeviceOpenBLAS> for (TensorMut<'_, T, DeviceOpenBLAS, DA>, Tensor<T, DeviceOpenBLAS, DB>)

where T: BlasFloat, DA: DimAPI, DB: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, DB>

fn solve_general_f(self) -> Result<Self::Out>

fn solve_general(self) -> Self::Out

where Self: Sized,

impl<T, DA, DB> SolveGeneralAPI<DeviceOpenBLAS> for (TensorMut<'_, T, DeviceOpenBLAS, DA>, TensorView<'_, T, DeviceOpenBLAS, DB>)

where T: BlasFloat, DA: DimAPI, DB: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, DB>

fn solve_general_f(self) -> Result<Self::Out>

fn solve_general(self) -> Self::Out

where Self: Sized,

impl<T, DA, DB, R: DataAPI<Data = Vec<T>>> SolveGeneralAPI<DeviceOpenBLAS> for (Tensor<T, DeviceOpenBLAS, DA>, &TensorAny<R, T, DeviceOpenBLAS, DB>)

where T: BlasFloat, DA: DimAPI, DB: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, DB>

fn solve_general_f(self) -> Result<Self::Out>

fn solve_general(self) -> Self::Out

where Self: Sized,

impl<'b, T, DA, DB> SolveGeneralAPI<DeviceOpenBLAS> for (Tensor<T, DeviceOpenBLAS, DA>, TensorMut<'b, T, DeviceOpenBLAS, DB>)

where T: BlasFloat, DA: DimAPI, DB: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = TensorBase<Storage<DataMut<'b, <DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, DB>

fn solve_general_f(self) -> Result<Self::Out>

fn solve_general(self) -> Self::Out

where Self: Sized,

impl<T, DA, DB> SolveGeneralAPI<DeviceOpenBLAS> for (Tensor<T, DeviceOpenBLAS, DA>, Tensor<T, DeviceOpenBLAS, DB>)

where T: BlasFloat, DA: DimAPI, DB: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, DB>

fn solve_general_f(self) -> Result<Self::Out>

fn solve_general(self) -> Self::Out

where Self: Sized,

impl<T, DA, DB> SolveGeneralAPI<DeviceOpenBLAS> for (Tensor<T, DeviceOpenBLAS, DA>, TensorView<'_, T, DeviceOpenBLAS, DB>)

where T: BlasFloat, DA: DimAPI, DB: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, DB>

fn solve_general_f(self) -> Result<Self::Out>

fn solve_general(self) -> Self::Out

where Self: Sized,

impl<T, DA, DB, R: DataAPI<Data = Vec<T>>> SolveGeneralAPI<DeviceOpenBLAS> for (TensorView<'_, T, DeviceOpenBLAS, DA>, &TensorAny<R, T, DeviceOpenBLAS, DB>)

where T: BlasFloat, DA: DimAPI, DB: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, DB>

fn solve_general_f(self) -> Result<Self::Out>

fn solve_general(self) -> Self::Out

where Self: Sized,

impl<'b, T, DA, DB> SolveGeneralAPI<DeviceOpenBLAS> for (TensorView<'_, T, DeviceOpenBLAS, DA>, TensorMut<'b, T, DeviceOpenBLAS, DB>)

where T: BlasFloat, DA: DimAPI, DB: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = TensorBase<Storage<DataMut<'b, <DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, DB>

fn solve_general_f(self) -> Result<Self::Out>

fn solve_general(self) -> Self::Out

where Self: Sized,

impl<T, DA, DB> SolveGeneralAPI<DeviceOpenBLAS> for (TensorView<'_, T, DeviceOpenBLAS, DA>, Tensor<T, DeviceOpenBLAS, DB>)

where T: BlasFloat, DA: DimAPI, DB: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, DB>

fn solve_general_f(self) -> Result<Self::Out>

fn solve_general(self) -> Self::Out

where Self: Sized,

impl<T, DA, DB> SolveGeneralAPI<DeviceOpenBLAS> for (TensorView<'_, T, DeviceOpenBLAS, DA>, TensorView<'_, T, DeviceOpenBLAS, DB>)

where T: BlasFloat, DA: DimAPI, DB: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, DB>

fn solve_general_f(self) -> Result<Self::Out>

fn solve_general(self) -> Self::Out

where Self: Sized,

impl<'b, T, DA, DB, R: DataAPI<Data = Vec<T>>> SolveSymmetricAPI<DeviceOpenBLAS> for (&TensorAny<R, T, DeviceOpenBLAS, DA>, TensorMut<'b, T, DeviceOpenBLAS, DB>, bool, Option<FlagUpLo>)

where T: BlasFloat, DA: DimAPI, DB: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = TensorBase<Storage<DataMut<'b, <DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, DB>

fn solve_symmetric_f(self) -> Result<Self::Out>

fn solve_symmetric(self) -> Self::Out

where Self: Sized,

impl<T, DA, DB, R: DataAPI<Data = Vec<T>>> SolveSymmetricAPI<DeviceOpenBLAS> for (&TensorAny<R, T, DeviceOpenBLAS, DA>, Tensor<T, DeviceOpenBLAS, DB>, bool, Option<FlagUpLo>)

where T: BlasFloat, DA: DimAPI, DB: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, DB>

fn solve_symmetric_f(self) -> Result<Self::Out>

fn solve_symmetric(self) -> Self::Out

where Self: Sized,

impl<T, DA, DB, R: DataAPI<Data = Vec<T>>> SolveSymmetricAPI<DeviceOpenBLAS> for (&TensorAny<R, T, DeviceOpenBLAS, DA>, TensorView<'_, T, DeviceOpenBLAS, DB>, bool, Option<FlagUpLo>)

where T: BlasFloat, DA: DimAPI, DB: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, DB>

fn solve_symmetric_f(self) -> Result<Self::Out>

fn solve_symmetric(self) -> Self::Out

where Self: Sized,

impl<T, DA, DB, Ra: DataAPI<Data = Vec<T>>, Rb: DataAPI<Data = Vec<T>>> SolveSymmetricAPI<DeviceOpenBLAS> for (&TensorAny<Ra, T, DeviceOpenBLAS, DA>, &TensorAny<Rb, T, DeviceOpenBLAS, DB>, bool, Option<FlagUpLo>)

where T: BlasFloat, DA: DimAPI, DB: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, DB>

fn solve_symmetric_f(self) -> Result<Self::Out>

fn solve_symmetric(self) -> Self::Out

where Self: Sized,

impl<T, DA, DB, R: DataAPI<Data = Vec<T>>> SolveSymmetricAPI<DeviceOpenBLAS> for (TensorMut<'_, T, DeviceOpenBLAS, DA>, &TensorAny<R, T, DeviceOpenBLAS, DB>, bool, Option<FlagUpLo>)

where T: BlasFloat, DA: DimAPI, DB: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, DB>

fn solve_symmetric_f(self) -> Result<Self::Out>

fn solve_symmetric(self) -> Self::Out

where Self: Sized,

impl<'b, T, DA, DB> SolveSymmetricAPI<DeviceOpenBLAS> for (TensorMut<'_, T, DeviceOpenBLAS, DA>, TensorMut<'b, T, DeviceOpenBLAS, DB>, bool, Option<FlagUpLo>)

where T: BlasFloat, DA: DimAPI, DB: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = TensorBase<Storage<DataMut<'b, <DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, DB>

fn solve_symmetric_f(self) -> Result<Self::Out>

fn solve_symmetric(self) -> Self::Out

where Self: Sized,

impl<T, DA, DB> SolveSymmetricAPI<DeviceOpenBLAS> for (TensorMut<'_, T, DeviceOpenBLAS, DA>, Tensor<T, DeviceOpenBLAS, DB>, bool, Option<FlagUpLo>)

where T: BlasFloat, DA: DimAPI, DB: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, DB>

fn solve_symmetric_f(self) -> Result<Self::Out>

fn solve_symmetric(self) -> Self::Out

where Self: Sized,

impl<T, DA, DB> SolveSymmetricAPI<DeviceOpenBLAS> for (TensorMut<'_, T, DeviceOpenBLAS, DA>, TensorView<'_, T, DeviceOpenBLAS, DB>, bool, Option<FlagUpLo>)

where T: BlasFloat, DA: DimAPI, DB: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, DB>

fn solve_symmetric_f(self) -> Result<Self::Out>

fn solve_symmetric(self) -> Self::Out

where Self: Sized,

impl<T, DA, DB, R: DataAPI<Data = Vec<T>>> SolveSymmetricAPI<DeviceOpenBLAS> for (Tensor<T, DeviceOpenBLAS, DA>, &TensorAny<R, T, DeviceOpenBLAS, DB>, bool, Option<FlagUpLo>)

where T: BlasFloat, DA: DimAPI, DB: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, DB>

fn solve_symmetric_f(self) -> Result<Self::Out>

fn solve_symmetric(self) -> Self::Out

where Self: Sized,

impl<'b, T, DA, DB> SolveSymmetricAPI<DeviceOpenBLAS> for (Tensor<T, DeviceOpenBLAS, DA>, TensorMut<'b, T, DeviceOpenBLAS, DB>, bool, Option<FlagUpLo>)

where T: BlasFloat, DA: DimAPI, DB: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = TensorBase<Storage<DataMut<'b, <DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, DB>

fn solve_symmetric_f(self) -> Result<Self::Out>

fn solve_symmetric(self) -> Self::Out

where Self: Sized,

impl<T, DA, DB> SolveSymmetricAPI<DeviceOpenBLAS> for (Tensor<T, DeviceOpenBLAS, DA>, Tensor<T, DeviceOpenBLAS, DB>, bool, Option<FlagUpLo>)

where T: BlasFloat, DA: DimAPI, DB: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, DB>

fn solve_symmetric_f(self) -> Result<Self::Out>

fn solve_symmetric(self) -> Self::Out

where Self: Sized,

impl<T, DA, DB> SolveSymmetricAPI<DeviceOpenBLAS> for (Tensor<T, DeviceOpenBLAS, DA>, TensorView<'_, T, DeviceOpenBLAS, DB>, bool, Option<FlagUpLo>)

where T: BlasFloat, DA: DimAPI, DB: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, DB>

fn solve_symmetric_f(self) -> Result<Self::Out>

fn solve_symmetric(self) -> Self::Out

where Self: Sized,

impl<T, DA, DB, R: DataAPI<Data = Vec<T>>> SolveSymmetricAPI<DeviceOpenBLAS> for (TensorView<'_, T, DeviceOpenBLAS, DA>, &TensorAny<R, T, DeviceOpenBLAS, DB>, bool, Option<FlagUpLo>)

where T: BlasFloat, DA: DimAPI, DB: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, DB>

fn solve_symmetric_f(self) -> Result<Self::Out>

fn solve_symmetric(self) -> Self::Out

where Self: Sized,

impl<'b, T, DA, DB> SolveSymmetricAPI<DeviceOpenBLAS> for (TensorView<'_, T, DeviceOpenBLAS, DA>, TensorMut<'b, T, DeviceOpenBLAS, DB>, bool, Option<FlagUpLo>)

where T: BlasFloat, DA: DimAPI, DB: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = TensorBase<Storage<DataMut<'b, <DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, DB>

fn solve_symmetric_f(self) -> Result<Self::Out>

fn solve_symmetric(self) -> Self::Out

where Self: Sized,

impl<T, DA, DB> SolveSymmetricAPI<DeviceOpenBLAS> for (TensorView<'_, T, DeviceOpenBLAS, DA>, Tensor<T, DeviceOpenBLAS, DB>, bool, Option<FlagUpLo>)

where T: BlasFloat, DA: DimAPI, DB: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, DB>

fn solve_symmetric_f(self) -> Result<Self::Out>

fn solve_symmetric(self) -> Self::Out

where Self: Sized,

impl<T, DA, DB> SolveSymmetricAPI<DeviceOpenBLAS> for (TensorView<'_, T, DeviceOpenBLAS, DA>, TensorView<'_, T, DeviceOpenBLAS, DB>, bool, Option<FlagUpLo>)

where T: BlasFloat, DA: DimAPI, DB: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, DB>

fn solve_symmetric_f(self) -> Result<Self::Out>

fn solve_symmetric(self) -> Self::Out

where Self: Sized,

impl<TrA, TrB> SolveSymmetricAPI<DeviceOpenBLAS> for (TrA, TrB)

where (TrA, TrB, bool, Option<FlagUpLo>): SolveSymmetricAPI<DeviceOpenBLAS>,

type Out = <(TrA, TrB, bool, Option<FlagUpLo>) as SolveSymmetricAPI<DeviceOpenBLAS>>::Out

fn solve_symmetric_f(self) -> Result<Self::Out>

fn solve_symmetric(self) -> Self::Out

where Self: Sized,

impl<TrA, TrB> SolveSymmetricAPI<DeviceOpenBLAS> for (TrA, TrB, FlagUpLo)

where (TrA, TrB, bool, Option<FlagUpLo>): SolveSymmetricAPI<DeviceOpenBLAS>,

type Out = <(TrA, TrB, bool, Option<FlagUpLo>) as SolveSymmetricAPI<DeviceOpenBLAS>>::Out

fn solve_symmetric_f(self) -> Result<Self::Out>

fn solve_symmetric(self) -> Self::Out

where Self: Sized,

impl<TrA, TrB> SolveSymmetricAPI<DeviceOpenBLAS> for (TrA, TrB, bool)

where (TrA, TrB, bool, Option<FlagUpLo>): SolveSymmetricAPI<DeviceOpenBLAS>,

type Out = <(TrA, TrB, bool, Option<FlagUpLo>) as SolveSymmetricAPI<DeviceOpenBLAS>>::Out

fn solve_symmetric_f(self) -> Result<Self::Out>

fn solve_symmetric(self) -> Self::Out

where Self: Sized,

impl<TrA, TrB> SolveSymmetricAPI<DeviceOpenBLAS> for (TrA, TrB, bool, FlagUpLo)

where (TrA, TrB, bool, Option<FlagUpLo>): SolveSymmetricAPI<DeviceOpenBLAS>,

type Out = <(TrA, TrB, bool, Option<FlagUpLo>) as SolveSymmetricAPI<DeviceOpenBLAS>>::Out

fn solve_symmetric_f(self) -> Result<Self::Out>

fn solve_symmetric(self) -> Self::Out

where Self: Sized,

impl<'b, T, DA, DB, R: DataAPI<Data = Vec<T>>> SolveTriangularAPI<DeviceOpenBLAS> for (&TensorAny<R, T, DeviceOpenBLAS, DA>, TensorMut<'b, T, DeviceOpenBLAS, DB>, Option<FlagUpLo>)

where T: BlasFloat, DA: DimAPI, DB: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = TensorBase<Storage<DataMut<'b, <DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, DB>

fn solve_triangular_f(self) -> Result<Self::Out>

fn solve_triangular(self) -> Self::Out

where Self: Sized,

impl<T, DA, DB, R: DataAPI<Data = Vec<T>>> SolveTriangularAPI<DeviceOpenBLAS> for (&TensorAny<R, T, DeviceOpenBLAS, DA>, Tensor<T, DeviceOpenBLAS, DB>, Option<FlagUpLo>)

where T: BlasFloat, DA: DimAPI, DB: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, DB>

fn solve_triangular_f(self) -> Result<Self::Out>

fn solve_triangular(self) -> Self::Out

where Self: Sized,

impl<T, DA, DB, R: DataAPI<Data = Vec<T>>> SolveTriangularAPI<DeviceOpenBLAS> for (&TensorAny<R, T, DeviceOpenBLAS, DA>, TensorView<'_, T, DeviceOpenBLAS, DB>, Option<FlagUpLo>)

where T: BlasFloat, DA: DimAPI, DB: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, DB>

fn solve_triangular_f(self) -> Result<Self::Out>

fn solve_triangular(self) -> Self::Out

where Self: Sized,

impl<T, DA, DB, Ra: DataAPI<Data = Vec<T>>, Rb: DataAPI<Data = Vec<T>>> SolveTriangularAPI<DeviceOpenBLAS> for (&TensorAny<Ra, T, DeviceOpenBLAS, DA>, &TensorAny<Rb, T, DeviceOpenBLAS, DB>, Option<FlagUpLo>)

where T: BlasFloat, DA: DimAPI, DB: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, DB>

fn solve_triangular_f(self) -> Result<Self::Out>

fn solve_triangular(self) -> Self::Out

where Self: Sized,

impl<T, DA, DB, R: DataAPI<Data = Vec<T>>> SolveTriangularAPI<DeviceOpenBLAS> for (TensorMut<'_, T, DeviceOpenBLAS, DA>, &TensorAny<R, T, DeviceOpenBLAS, DB>, Option<FlagUpLo>)

where T: BlasFloat, DA: DimAPI, DB: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, DB>

fn solve_triangular_f(self) -> Result<Self::Out>

fn solve_triangular(self) -> Self::Out

where Self: Sized,

impl<'b, T, DA, DB> SolveTriangularAPI<DeviceOpenBLAS> for (TensorMut<'_, T, DeviceOpenBLAS, DA>, TensorMut<'b, T, DeviceOpenBLAS, DB>, Option<FlagUpLo>)

where T: BlasFloat, DA: DimAPI, DB: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = TensorBase<Storage<DataMut<'b, <DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, DB>

fn solve_triangular_f(self) -> Result<Self::Out>

fn solve_triangular(self) -> Self::Out

where Self: Sized,

impl<T, DA, DB> SolveTriangularAPI<DeviceOpenBLAS> for (TensorMut<'_, T, DeviceOpenBLAS, DA>, Tensor<T, DeviceOpenBLAS, DB>, Option<FlagUpLo>)

where T: BlasFloat, DA: DimAPI, DB: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, DB>

fn solve_triangular_f(self) -> Result<Self::Out>

fn solve_triangular(self) -> Self::Out

where Self: Sized,

impl<T, DA, DB> SolveTriangularAPI<DeviceOpenBLAS> for (TensorMut<'_, T, DeviceOpenBLAS, DA>, TensorView<'_, T, DeviceOpenBLAS, DB>, Option<FlagUpLo>)

where T: BlasFloat, DA: DimAPI, DB: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, DB>

fn solve_triangular_f(self) -> Result<Self::Out>

fn solve_triangular(self) -> Self::Out

where Self: Sized,

impl<T, DA, DB, R: DataAPI<Data = Vec<T>>> SolveTriangularAPI<DeviceOpenBLAS> for (Tensor<T, DeviceOpenBLAS, DA>, &TensorAny<R, T, DeviceOpenBLAS, DB>, Option<FlagUpLo>)

where T: BlasFloat, DA: DimAPI, DB: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, DB>

fn solve_triangular_f(self) -> Result<Self::Out>

fn solve_triangular(self) -> Self::Out

where Self: Sized,

impl<'b, T, DA, DB> SolveTriangularAPI<DeviceOpenBLAS> for (Tensor<T, DeviceOpenBLAS, DA>, TensorMut<'b, T, DeviceOpenBLAS, DB>, Option<FlagUpLo>)

where T: BlasFloat, DA: DimAPI, DB: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = TensorBase<Storage<DataMut<'b, <DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, DB>

fn solve_triangular_f(self) -> Result<Self::Out>

fn solve_triangular(self) -> Self::Out

where Self: Sized,

impl<T, DA, DB> SolveTriangularAPI<DeviceOpenBLAS> for (Tensor<T, DeviceOpenBLAS, DA>, Tensor<T, DeviceOpenBLAS, DB>, Option<FlagUpLo>)

where T: BlasFloat, DA: DimAPI, DB: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, DB>

fn solve_triangular_f(self) -> Result<Self::Out>

fn solve_triangular(self) -> Self::Out

where Self: Sized,

impl<T, DA, DB> SolveTriangularAPI<DeviceOpenBLAS> for (Tensor<T, DeviceOpenBLAS, DA>, TensorView<'_, T, DeviceOpenBLAS, DB>, Option<FlagUpLo>)

where T: BlasFloat, DA: DimAPI, DB: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, DB>

fn solve_triangular_f(self) -> Result<Self::Out>

fn solve_triangular(self) -> Self::Out

where Self: Sized,

impl<T, DA, DB, R: DataAPI<Data = Vec<T>>> SolveTriangularAPI<DeviceOpenBLAS> for (TensorView<'_, T, DeviceOpenBLAS, DA>, &TensorAny<R, T, DeviceOpenBLAS, DB>, Option<FlagUpLo>)

where T: BlasFloat, DA: DimAPI, DB: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, DB>

fn solve_triangular_f(self) -> Result<Self::Out>

fn solve_triangular(self) -> Self::Out

where Self: Sized,

impl<'b, T, DA, DB> SolveTriangularAPI<DeviceOpenBLAS> for (TensorView<'_, T, DeviceOpenBLAS, DA>, TensorMut<'b, T, DeviceOpenBLAS, DB>, Option<FlagUpLo>)

where T: BlasFloat, DA: DimAPI, DB: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = TensorBase<Storage<DataMut<'b, <DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, DB>

fn solve_triangular_f(self) -> Result<Self::Out>

fn solve_triangular(self) -> Self::Out

where Self: Sized,

impl<T, DA, DB> SolveTriangularAPI<DeviceOpenBLAS> for (TensorView<'_, T, DeviceOpenBLAS, DA>, Tensor<T, DeviceOpenBLAS, DB>, Option<FlagUpLo>)

where T: BlasFloat, DA: DimAPI, DB: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, DB>

fn solve_triangular_f(self) -> Result<Self::Out>

fn solve_triangular(self) -> Self::Out

where Self: Sized,

impl<T, DA, DB> SolveTriangularAPI<DeviceOpenBLAS> for (TensorView<'_, T, DeviceOpenBLAS, DA>, TensorView<'_, T, DeviceOpenBLAS, DB>, Option<FlagUpLo>)

where T: BlasFloat, DA: DimAPI, DB: DimAPI, DeviceOpenBLAS: LapackDriverAPI<T>,

type Out = TensorBase<Storage<DataOwned<<DeviceOpenBLAS as DeviceRawAPI<T>>::Raw>, T, DeviceOpenBLAS>, DB>

fn solve_triangular_f(self) -> Result<Self::Out>

fn solve_triangular(self) -> Self::Out

where Self: Sized,

impl<TrA, TrB> SolveTriangularAPI<DeviceOpenBLAS> for (TrA, TrB)

where (TrA, TrB, Option<FlagUpLo>): SolveTriangularAPI<DeviceOpenBLAS>,

type Out = <(TrA, TrB, Option<FlagUpLo>) as SolveTriangularAPI<DeviceOpenBLAS>>::Out

fn solve_triangular_f(self) -> Result<Self::Out>

fn solve_triangular(self) -> Self::Out

where Self: Sized,

impl<TrA, TrB> SolveTriangularAPI<DeviceOpenBLAS> for (TrA, TrB, FlagUpLo)

where (TrA, TrB, Option<FlagUpLo>): SolveTriangularAPI<DeviceOpenBLAS>,

type Out = <(TrA, TrB, Option<FlagUpLo>) as SolveTriangularAPI<DeviceOpenBLAS>>::Out

fn solve_triangular_f(self) -> Result<Self::Out>

fn solve_triangular(self) -> Self::Out

where Self: Sized,

impl TRSMDriverAPI<Complex<f32>> for DeviceOpenBLAS

unsafe fn driver_trsm( order: FlagOrder, side: FlagSide, uplo: FlagUpLo, transa: FlagTrans, diag: FlagDiag, m: usize, n: usize, alpha: Complex<f32>, a: *const Complex<f32>, lda: usize, b: *mut Complex<f32>, ldb: usize, )

impl TRSMDriverAPI<Complex<f64>> for DeviceOpenBLAS

unsafe fn driver_trsm( order: FlagOrder, side: FlagSide, uplo: FlagUpLo, transa: FlagTrans, diag: FlagDiag, m: usize, n: usize, alpha: Complex<f64>, a: *const Complex<f64>, lda: usize, b: *mut Complex<f64>, ldb: usize, )

impl TRSMDriverAPI<f32> for DeviceOpenBLAS

unsafe fn driver_trsm( order: FlagOrder, side: FlagSide, uplo: FlagUpLo, transa: FlagTrans, diag: FlagDiag, m: usize, n: usize, alpha: f32, a: *const f32, lda: usize, b: *mut f32, ldb: usize, )

impl TRSMDriverAPI<f64> for DeviceOpenBLAS

unsafe fn driver_trsm( order: FlagOrder, side: FlagSide, uplo: FlagUpLo, transa: FlagTrans, diag: FlagDiag, m: usize, n: usize, alpha: f64, a: *const f64, lda: usize, b: *mut f64, ldb: usize, )

impl BlasDriverAPI<Complex<f32>> for DeviceOpenBLAS

impl BlasDriverAPI<Complex<f64>> for DeviceOpenBLAS

impl BlasDriverAPI<f32> for DeviceOpenBLAS

impl BlasDriverAPI<f64> for DeviceOpenBLAS

impl<T> BlasDriverBaseAPI<T> for DeviceOpenBLAS

where T: BlasFloat, T::Real: BlasFloat + MinMaxAPI + Bounded,

impl<T> DeviceAPI<T> for DeviceOpenBLAS

impl<T, D> DeviceComplexFloatAPI<T, D> for DeviceOpenBLAS

where T: ComplexFloat + Send + Sync, T::Real: Send + Sync, D: DimAPI,

impl<T, D> DeviceNumAPI<T, D> for DeviceOpenBLAS

where T: Clone + Num + Send + Sync, D: DimAPI,

impl LapackDriverAPI<Complex<f32>> for DeviceOpenBLAS

impl LapackDriverAPI<Complex<f64>> for DeviceOpenBLAS

impl LapackDriverAPI<f32> for DeviceOpenBLAS

impl LapackDriverAPI<f64> for DeviceOpenBLAS