Struct PlusTimes 

pub struct PlusTimes;

+.×, the matrix product, at i64, f32 and f64, and complex numbers with parts of either type. Native float steps use fused multiply-add where the target has one; Accelerate computes them on macOS. Nonfinite complex results need not match scalar arithmetic. Native complex products form each part from two real products of the parts, as scalar multiplication does. A small imaginary part beside a large real part keeps its own relative accuracy.

Trait Implementations

impl Default for PlusTimes

fn default() -> Self

Returns the “default value” for a type.

impl Inner<Complex<f32>> for PlusTimes

type Out = Complex<f32>

The type of each result.

fn inner_ops( &self, a: &[Complex<f32>], b: &[Complex<f32>], [oa, ob]: [Orientation; 2], [m, k, n]: [usize; 3], ) -> Vec<Complex<f32>>

inner of the matrices that a and b give in the orientations given, with size [m, k, n] for those matrices. A transposed a holds a k×m matrix, row-major, and gives its m×k transpose. This default copies a transposed operand into its orientation. Float and complex PlusTimes read it in place.

fn inner_into( &self, a: &[Complex<f32>], b: &[Complex<f32>], [m, k, n]: [usize; 3], c: &mut [Complex<f32>], )

The m×n inner product of a, an m×k matrix, and b, a k×n matrix, both row-major, written row-major into out, which holds m×n items. size is [m, k, n]. Where k is 0, each result is the identity of f. An integer result that doesn’t fit its type panics, where checked_into gives false.

fn inner_mapped_into( &self, a: Mapped<'_, Complex<f32>>, b: Mapped<'_, Complex<f32>>, orientations: [Orientation; 2], size: [usize; 3], out: &mut [Complex<f32>], )

inner_into of operands whose items come through mappings, as Mapped describes. This default reads each operand whole and copies transposed operands into their orientations. Float and complex PlusTimes read an operand that isn’t held in order one block of its stored rows at a time and multiply each block as it’s read. Only one block of that operand then exists at once.

fn inner(&self, a: &[T], b: &[T], size: [usize; 3]) -> Vec<Self::Out>

inner_into’s results, as a new row-major matrix.

fn checked_into( &self, a: &[T], b: &[T], size: [usize; 3], out: &mut [Self::Out], ) -> bool

inner_into, or false where an integer result doesn’t fit its type, for callers that keep integers exact or report overflow. Where it gives true, out holds the exact results. Floats always give true.

fn inner_mapped( &self, a: Mapped<'_, T>, b: Mapped<'_, T>, orientations: [Orientation; 2], size: [usize; 3], ) -> Vec<Self::Out>

where T: Element,

inner_mapped_into’s results, as a new row-major matrix.

impl Inner<Complex<f64>> for PlusTimes

type Out = Complex<f64>

The type of each result.

fn inner_ops( &self, a: &[Complex<f64>], b: &[Complex<f64>], [oa, ob]: [Orientation; 2], [m, k, n]: [usize; 3], ) -> Vec<Complex<f64>>

inner of the matrices that a and b give in the orientations given, with size [m, k, n] for those matrices. A transposed a holds a k×m matrix, row-major, and gives its m×k transpose. This default copies a transposed operand into its orientation. Float and complex PlusTimes read it in place.

fn inner_into( &self, a: &[Complex<f64>], b: &[Complex<f64>], [m, k, n]: [usize; 3], c: &mut [Complex<f64>], )

The m×n inner product of a, an m×k matrix, and b, a k×n matrix, both row-major, written row-major into out, which holds m×n items. size is [m, k, n]. Where k is 0, each result is the identity of f. An integer result that doesn’t fit its type panics, where checked_into gives false.

fn inner_mapped_into( &self, a: Mapped<'_, Complex<f64>>, b: Mapped<'_, Complex<f64>>, orientations: [Orientation; 2], size: [usize; 3], out: &mut [Complex<f64>], )

inner_into of operands whose items come through mappings, as Mapped describes. This default reads each operand whole and copies transposed operands into their orientations. Float and complex PlusTimes read an operand that isn’t held in order one block of its stored rows at a time and multiply each block as it’s read. Only one block of that operand then exists at once.

fn inner(&self, a: &[T], b: &[T], size: [usize; 3]) -> Vec<Self::Out>

inner_into’s results, as a new row-major matrix.

fn checked_into( &self, a: &[T], b: &[T], size: [usize; 3], out: &mut [Self::Out], ) -> bool

inner_into, or false where an integer result doesn’t fit its type, for callers that keep integers exact or report overflow. Where it gives true, out holds the exact results. Floats always give true.

fn inner_mapped( &self, a: Mapped<'_, T>, b: Mapped<'_, T>, orientations: [Orientation; 2], size: [usize; 3], ) -> Vec<Self::Out>

where T: Element,

inner_mapped_into’s results, as a new row-major matrix.

impl Inner<f16> for PlusTimes

+.× of f16 matrices, summed and returned at f32. rustymath’s own kernels convert each item to f32 as they pack it, so neither operand is copied whole. Accelerate has no f16 product, so where it serves the process, both operands convert to f32 copies for its f32 product.

type Out = f32

The type of each result.

fn inner_into(&self, a: &[f16], b: &[f16], size: [usize; 3], c: &mut [f32])

The m×n inner product of a, an m×k matrix, and b, a k×n matrix, both row-major, written row-major into out, which holds m×n items. size is [m, k, n]. Where k is 0, each result is the identity of f. An integer result that doesn’t fit its type panics, where checked_into gives false.

fn inner(&self, a: &[T], b: &[T], size: [usize; 3]) -> Vec<Self::Out>

inner_into’s results, as a new row-major matrix.

fn checked_into( &self, a: &[T], b: &[T], size: [usize; 3], out: &mut [Self::Out], ) -> bool

inner_into, or false where an integer result doesn’t fit its type, for callers that keep integers exact or report overflow. Where it gives true, out holds the exact results. Floats always give true.

fn inner_ops( &self, a: &[T], b: &[T], [oa, ob]: [Orientation; 2], [m, k, n]: [usize; 3], ) -> Vec<Self::Out>

where T: Copy,

inner of the matrices that a and b give in the orientations given, with size [m, k, n] for those matrices. A transposed a holds a k×m matrix, row-major, and gives its m×k transpose. This default copies a transposed operand into its orientation. Float and complex PlusTimes read it in place.

fn inner_mapped( &self, a: Mapped<'_, T>, b: Mapped<'_, T>, orientations: [Orientation; 2], size: [usize; 3], ) -> Vec<Self::Out>

where T: Element,

inner_mapped_into’s results, as a new row-major matrix.

fn inner_mapped_into( &self, a: Mapped<'_, T>, b: Mapped<'_, T>, [oa, ob]: [Orientation; 2], size: [usize; 3], out: &mut [Self::Out], )

where T: Element,

inner_into of operands whose items come through mappings, as Mapped describes. This default reads each operand whole and copies transposed operands into their orientations. Float and complex PlusTimes read an operand that isn’t held in order one block of its stored rows at a time and multiply each block as it’s read. Only one block of that operand then exists at once.

impl Inner<f32> for PlusTimes

type Out = f32

The type of each result.

fn inner_ops( &self, a: &[f32], b: &[f32], [oa, ob]: [Orientation; 2], [m, k, n]: [usize; 3], ) -> Vec<f32>

inner of the matrices that a and b give in the orientations given, with size [m, k, n] for those matrices. A transposed a holds a k×m matrix, row-major, and gives its m×k transpose. This default copies a transposed operand into its orientation. Float and complex PlusTimes read it in place.

fn inner_into(&self, a: &[f32], b: &[f32], [m, k, n]: [usize; 3], c: &mut [f32])

The m×n inner product of a, an m×k matrix, and b, a k×n matrix, both row-major, written row-major into out, which holds m×n items. size is [m, k, n]. Where k is 0, each result is the identity of f. An integer result that doesn’t fit its type panics, where checked_into gives false.

fn inner_mapped_into( &self, a: Mapped<'_, f32>, b: Mapped<'_, f32>, orientations: [Orientation; 2], size: [usize; 3], out: &mut [f32], )

inner_into of operands whose items come through mappings, as Mapped describes. This default reads each operand whole and copies transposed operands into their orientations. Float and complex PlusTimes read an operand that isn’t held in order one block of its stored rows at a time and multiply each block as it’s read. Only one block of that operand then exists at once.

fn inner(&self, a: &[T], b: &[T], size: [usize; 3]) -> Vec<Self::Out>

inner_into’s results, as a new row-major matrix.

fn checked_into( &self, a: &[T], b: &[T], size: [usize; 3], out: &mut [Self::Out], ) -> bool

inner_into, or false where an integer result doesn’t fit its type, for callers that keep integers exact or report overflow. Where it gives true, out holds the exact results. Floats always give true.

fn inner_mapped( &self, a: Mapped<'_, T>, b: Mapped<'_, T>, orientations: [Orientation; 2], size: [usize; 3], ) -> Vec<Self::Out>

where T: Element,

inner_mapped_into’s results, as a new row-major matrix.

impl Inner<f64> for PlusTimes

type Out = f64

The type of each result.

fn inner_ops( &self, a: &[f64], b: &[f64], [oa, ob]: [Orientation; 2], [m, k, n]: [usize; 3], ) -> Vec<f64>

inner of the matrices that a and b give in the orientations given, with size [m, k, n] for those matrices. A transposed a holds a k×m matrix, row-major, and gives its m×k transpose. This default copies a transposed operand into its orientation. Float and complex PlusTimes read it in place.

fn inner_into(&self, a: &[f64], b: &[f64], [m, k, n]: [usize; 3], c: &mut [f64])

The m×n inner product of a, an m×k matrix, and b, a k×n matrix, both row-major, written row-major into out, which holds m×n items. size is [m, k, n]. Where k is 0, each result is the identity of f. An integer result that doesn’t fit its type panics, where checked_into gives false.

fn inner_mapped_into( &self, a: Mapped<'_, f64>, b: Mapped<'_, f64>, orientations: [Orientation; 2], size: [usize; 3], out: &mut [f64], )

inner_into of operands whose items come through mappings, as Mapped describes. This default reads each operand whole and copies transposed operands into their orientations. Float and complex PlusTimes read an operand that isn’t held in order one block of its stored rows at a time and multiply each block as it’s read. Only one block of that operand then exists at once.

fn inner(&self, a: &[T], b: &[T], size: [usize; 3]) -> Vec<Self::Out>

inner_into’s results, as a new row-major matrix.

fn checked_into( &self, a: &[T], b: &[T], size: [usize; 3], out: &mut [Self::Out], ) -> bool

inner_into, or false where an integer result doesn’t fit its type, for callers that keep integers exact or report overflow. Where it gives true, out holds the exact results. Floats always give true.

fn inner_mapped( &self, a: Mapped<'_, T>, b: Mapped<'_, T>, orientations: [Orientation; 2], size: [usize; 3], ) -> Vec<Self::Out>

where T: Element,

inner_mapped_into’s results, as a new row-major matrix.

impl Inner<i64> for PlusTimes

type Out = i64

The type of each result.

fn inner_into(&self, a: &[i64], b: &[i64], size: [usize; 3], out: &mut [i64])

The m×n inner product of a, an m×k matrix, and b, a k×n matrix, both row-major, written row-major into out, which holds m×n items. size is [m, k, n]. Where k is 0, each result is the identity of f. An integer result that doesn’t fit its type panics, where checked_into gives false.

fn checked_into( &self, a: &[i64], b: &[i64], size: [usize; 3], out: &mut [i64], ) -> bool

inner_into, or false where an integer result doesn’t fit its type, for callers that keep integers exact or report overflow. Where it gives true, out holds the exact results. Floats always give true.

fn inner(&self, a: &[T], b: &[T], size: [usize; 3]) -> Vec<Self::Out>

inner_into’s results, as a new row-major matrix.

fn inner_ops( &self, a: &[T], b: &[T], [oa, ob]: [Orientation; 2], [m, k, n]: [usize; 3], ) -> Vec<Self::Out>

where T: Copy,

inner of the matrices that a and b give in the orientations given, with size [m, k, n] for those matrices. A transposed a holds a k×m matrix, row-major, and gives its m×k transpose. This default copies a transposed operand into its orientation. Float and complex PlusTimes read it in place.

fn inner_mapped( &self, a: Mapped<'_, T>, b: Mapped<'_, T>, orientations: [Orientation; 2], size: [usize; 3], ) -> Vec<Self::Out>

where T: Element,

inner_mapped_into’s results, as a new row-major matrix.

fn inner_mapped_into( &self, a: Mapped<'_, T>, b: Mapped<'_, T>, [oa, ob]: [Orientation; 2], size: [usize; 3], out: &mut [Self::Out], )

where T: Element,

inner_into of operands whose items come through mappings, as Mapped describes. This default reads each operand whole and copies transposed operands into their orientations. Float and complex PlusTimes read an operand that isn’t held in order one block of its stored rows at a time and multiply each block as it’s read. Only one block of that operand then exists at once.