Struct FaerVec 

pub struct FaerVec<T: FaerScalar> { /* private fields */ }

A batched vector, stored as one column per batch.

Invariant: data.ncols() == context.nbatch() and data.nrows() == len(). Note that faer pads its column stride for alignment, so the batches are not contiguous with each other; only a single column is.

Implementations

impl<T: FaerScalar> FaerVec<T>

pub fn check_for_nan(&self, label: &str) -> bool

Trait Implementations

impl<T: FaerScalar> Add for FaerVec<T>

type Output = FaerVec<T>

The resulting type after applying the + operator.

fn add(self, rhs: FaerVec<T>) -> Self::Output

Performs the + operation.

impl<T: FaerScalar> Add<&FaerVec<T>> for FaerVec<T>

type Output = FaerVec<T>

The resulting type after applying the + operator.

fn add(self, rhs: &FaerVec<T>) -> Self::Output

Performs the + operation.

impl<T: FaerScalar> Add<&FaerVec<T>> for FaerVecRef<'_, T>

type Output = FaerVec<T>

The resulting type after applying the + operator.

fn add(self, rhs: &FaerVec<T>) -> Self::Output

Performs the + operation.

impl<T: FaerScalar> Add<&FaerVec<T>> for &FaerVec<T>

type Output = FaerVec<T>

The resulting type after applying the + operator.

fn add(self, rhs: &FaerVec<T>) -> Self::Output

Performs the + operation.

impl<T: FaerScalar> Add<&FaerVecRef<'_, T>> for FaerVec<T>

type Output = FaerVec<T>

The resulting type after applying the + operator.

fn add(self, rhs: &FaerVecRef<'_, T>) -> Self::Output

Performs the + operation.

impl<T: FaerScalar> Add<&FaerVecRef<'_, T>> for &FaerVec<T>

type Output = FaerVec<T>

The resulting type after applying the + operator.

fn add(self, rhs: &FaerVecRef<'_, T>) -> Self::Output

Performs the + operation.

impl<T: FaerScalar> Add<FaerVec<T>> for FaerVecRef<'_, T>

type Output = FaerVec<T>

The resulting type after applying the + operator.

fn add(self, rhs: FaerVec<T>) -> Self::Output

Performs the + operation.

impl<T: FaerScalar> Add<FaerVec<T>> for &FaerVec<T>

type Output = FaerVec<T>

The resulting type after applying the + operator.

fn add(self, rhs: FaerVec<T>) -> Self::Output

Performs the + operation.

impl<T: FaerScalar> Add<FaerVecRef<'_, T>> for FaerVec<T>

type Output = FaerVec<T>

The resulting type after applying the + operator.

fn add(self, rhs: FaerVecRef<'_, T>) -> Self::Output

Performs the + operation.

impl<T: FaerScalar> Add<FaerVecRef<'_, T>> for &FaerVec<T>

type Output = FaerVec<T>

The resulting type after applying the + operator.

fn add(self, rhs: FaerVecRef<'_, T>) -> Self::Output

Performs the + operation.

impl<T: FaerScalar> AddAssign for FaerVec<T>

fn add_assign(&mut self, rhs: FaerVec<T>)

Performs the += operation.

impl<T: FaerScalar> AddAssign<&FaerVec<T>> for FaerVec<T>

fn add_assign(&mut self, rhs: &FaerVec<T>)

Performs the += operation.

impl<T: FaerScalar> AddAssign<&FaerVec<T>> for FaerVecMut<'_, T>

fn add_assign(&mut self, rhs: &FaerVec<T>)

Performs the += operation.

impl<T: FaerScalar> AddAssign<&FaerVecRef<'_, T>> for FaerVec<T>

fn add_assign(&mut self, rhs: &FaerVecRef<'_, T>)

Performs the += operation.

impl<T: FaerScalar> AddAssign<FaerVec<T>> for FaerVecMut<'_, T>

fn add_assign(&mut self, rhs: FaerVec<T>)

Performs the += operation.

impl<T: FaerScalar> AddAssign<FaerVecRef<'_, T>> for FaerVec<T>

fn add_assign(&mut self, rhs: FaerVecRef<'_, T>)

Performs the += operation.

impl<T: Clone + FaerScalar> Clone for FaerVec<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug + FaerScalar> Debug for FaerVec<T>

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

Formats the value using the given formatter.

impl<T: FaerScalar> DefaultDenseMatrix for FaerVec<T>

type M = FaerMat<T>

impl<T: FaerScalar> Div<Scale<T>> for FaerVec<T>

type Output = FaerVec<T>

The resulting type after applying the / operator.

fn div(self, rhs: Scale<T>) -> Self

Performs the / operation.

impl<T: FaerScalar> From<Col<Own<T>>> for FaerVec<T>

fn from(data: Col<T>) -> Self

Converts to this type from the input type.

impl<T: FaerScalar> Index<usize> for FaerVec<T>

type Output = T

The returned type after indexing.

fn index(&self, i: IndexType) -> &T

Performs the indexing (container[index]) operation.

impl<T: FaerScalar> IndexMut<usize> for FaerVec<T>

fn index_mut(&mut self, i: IndexType) -> &mut T

Performs the mutable indexing (container[index]) operation.

impl<T: FaerScalar> Mul<Scale<T>> for FaerVec<T>

type Output = FaerVec<T>

The resulting type after applying the * operator.

fn mul(self, rhs: Scale<T>) -> Self

Performs the * operation.

impl<T: FaerScalar> Mul<Scale<T>> for &FaerVec<T>

type Output = FaerVec<T>

The resulting type after applying the * operator.

fn mul(self, rhs: Scale<T>) -> Self::Output

Performs the * operation.

impl<T: FaerScalar> MulAssign<Scale<T>> for FaerVec<T>

fn mul_assign(&mut self, rhs: Scale<T>)

Performs the *= operation.

impl<T: PartialEq + FaerScalar> PartialEq for FaerVec<T>

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

Equality operator ==.

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

Inequality operator !=.

impl<T: PartialEq + FaerScalar> StructuralPartialEq for FaerVec<T>

impl<T: FaerScalar> Sub for FaerVec<T>

type Output = FaerVec<T>

The resulting type after applying the - operator.

fn sub(self, rhs: FaerVec<T>) -> Self::Output

Performs the - operation.

impl<T: FaerScalar> Sub<&FaerVec<T>> for FaerVec<T>

type Output = FaerVec<T>

The resulting type after applying the - operator.

fn sub(self, rhs: &FaerVec<T>) -> Self::Output

Performs the - operation.

impl<T: FaerScalar> Sub<&FaerVec<T>> for FaerVecRef<'_, T>

type Output = FaerVec<T>

The resulting type after applying the - operator.

fn sub(self, rhs: &FaerVec<T>) -> Self::Output

Performs the - operation.

impl<T: FaerScalar> Sub<&FaerVec<T>> for &FaerVec<T>

type Output = FaerVec<T>

The resulting type after applying the - operator.

fn sub(self, rhs: &FaerVec<T>) -> Self::Output

Performs the - operation.

impl<T: FaerScalar> Sub<&FaerVecRef<'_, T>> for FaerVec<T>

type Output = FaerVec<T>

The resulting type after applying the - operator.

fn sub(self, rhs: &FaerVecRef<'_, T>) -> Self::Output

Performs the - operation.

impl<T: FaerScalar> Sub<&FaerVecRef<'_, T>> for &FaerVec<T>

type Output = FaerVec<T>

The resulting type after applying the - operator.

fn sub(self, rhs: &FaerVecRef<'_, T>) -> Self::Output

Performs the - operation.

impl<T: FaerScalar> Sub<FaerVec<T>> for FaerVecRef<'_, T>

type Output = FaerVec<T>

The resulting type after applying the - operator.

fn sub(self, rhs: FaerVec<T>) -> Self::Output

Performs the - operation.

impl<T: FaerScalar> Sub<FaerVec<T>> for &FaerVec<T>

type Output = FaerVec<T>

The resulting type after applying the - operator.

fn sub(self, rhs: FaerVec<T>) -> Self::Output

Performs the - operation.

impl<T: FaerScalar> Sub<FaerVecRef<'_, T>> for FaerVec<T>

type Output = FaerVec<T>

The resulting type after applying the - operator.

fn sub(self, rhs: FaerVecRef<'_, T>) -> Self::Output

Performs the - operation.

impl<T: FaerScalar> Sub<FaerVecRef<'_, T>> for &FaerVec<T>

type Output = FaerVec<T>

The resulting type after applying the - operator.

fn sub(self, rhs: FaerVecRef<'_, T>) -> Self::Output

Performs the - operation.

impl<T: FaerScalar> SubAssign for FaerVec<T>

fn sub_assign(&mut self, rhs: FaerVec<T>)

Performs the -= operation.

impl<T: FaerScalar> SubAssign<&FaerVec<T>> for FaerVec<T>

fn sub_assign(&mut self, rhs: &FaerVec<T>)

Performs the -= operation.

impl<T: FaerScalar> SubAssign<&FaerVec<T>> for FaerVecMut<'_, T>

fn sub_assign(&mut self, rhs: &FaerVec<T>)

Performs the -= operation.

impl<T: FaerScalar> SubAssign<&FaerVecRef<'_, T>> for FaerVec<T>

fn sub_assign(&mut self, rhs: &FaerVecRef<'_, T>)

Performs the -= operation.

impl<T: FaerScalar> SubAssign<FaerVec<T>> for FaerVecMut<'_, T>

fn sub_assign(&mut self, rhs: FaerVec<T>)

Performs the -= operation.

impl<T: FaerScalar> SubAssign<FaerVecRef<'_, T>> for FaerVec<T>

fn sub_assign(&mut self, rhs: FaerVecRef<'_, T>)

Performs the -= operation.

impl<T: FaerScalar> Vector for FaerVec<T>

type View<'a> = FaerVecRef<'a, T>

type ViewMut<'a> = FaerVecMut<'a, T>

type Index = FaerVecIndex

fn len(&self) -> IndexType

Get the per-batch length (number of states) in this vector. For batched vectors, this returns nstates, not nstates * nbatch.

fn inner_mut(&mut self) -> &mut Self::Inner

Get a mutable reference to the inner representation of the vector.

fn context(&self) -> &Self::C

Get the context associated with this vector (for device placement, threading, etc.).

fn norm(&self, k: i32) -> T

Compute the $\ell_k$ norm: $(\sum_i |x_i|^k)^{1/k}$

fn get_index(&self, i: IndexType) -> T

Get the value at the specified index. Panics unless nbatch == 1; for a batched vector read one lane with Self::get_batch.

fn set_index(&mut self, i: IndexType, v: T)

Set the value at the specified index to value. Panics unless nbatch == 1; to write the same value into every batch use Self::fill_index.

fn fill_index(&mut self, i: IndexType, v: T)

Set the value at the specified index to value in every batch.

fn squared_norm(&self, y: &Self, atol: &Self, rtol: T) -> T

Compute the squared weighted norm for error control: $\sum_i (x_i / (|y_i| \cdot \text{rtol} + \text{atol}_i))^2$

fn as_view(&self) -> Self::View<'_>

Create an immutable view of this vector.

fn as_view_mut(&mut self) -> Self::ViewMut<'_>

Create a mutable view of this vector.

fn get_batch(&self, b: usize) -> Self::View<'_>

Get an immutable view of a single batch (with nbatch=1 context).

fn get_batch_mut(&mut self, b: usize) -> Self::ViewMut<'_>

Get a mutable view of a single batch (with nbatch=1 context).

fn for_each_batch_mut_host<const M: usize, const N: usize>( mut_args: [&mut Self; M], args: [&Self; N], f: impl FnMut([&mut [T]; M], [&[T]; N], usize), )

Run f once per batch lane on the host.

fn copy_from(&mut self, o: &Self)

Copy all values from other into this vector.

fn fill(&mut self, v: T)

Fill all elements of this vector with value.

fn copy_from_view(&mut self, o: &Self::View<'_>)

Copy all values from a vector view into this vector.

fn from_element(n: usize, v: T, ctx: Self::C) -> Self

Create a vector of length nstates with all elements initialized to value.

fn from_vec(v: Vec<T>, ctx: Self::C) -> Self

Create a vector from a Rust Vec.

fn from_slice(v: &[T], ctx: Self::C) -> Self

Create a vector from a slice.

fn clone_as_vec(&self) -> Vec<T>

Clone this vector as a Rust Vec.

fn zeros(n: usize, ctx: Self::C) -> Self

Create a vector of length nstates with all elements set to zero.

fn axpy(&mut self, a: T, x: &Self, beta: T)

Compute the AXPY operation: self = alpha * x + beta * self

fn axpy_v(&mut self, a: T, x: &Self::View<'_>, beta: T)

Compute the AXPY operation with a vector view: self = alpha * x + beta * self

fn batched_axpy(&mut self, a: &Self, x: &Self, beta: T)

Per-batch AXPY: self[i]_b = alpha_b * x[i]_b + beta * self[i]_b

fn component_div_assign(&mut self, o: &Self)

Element-wise division: self_i /= other_i

fn component_mul_assign(&mut self, o: &Self)

Element-wise multiplication: self_i *= other_i

fn root_finding(&self, g1: &Self) -> (bool, T, i32)

Detect roots (zero crossings) between this vector (as g0) and another vector (g1).

fn assign_at_indices(&mut self, idx: &Self::Index, v: T)

Assign value to all elements at the specified indices.

fn copy_from_indices(&mut self, o: &Self, idx: &Self::Index)

Copy values from other at the specified indices: self[indices[i]] = other[indices[i]]

fn gather(&mut self, o: &Self, idx: &Self::Index)

Gather values from other at indices: self[i] = other[indices[i]]

fn scatter(&self, idx: &Self::Index, o: &mut Self)

Scatter values to other at indices: other[indices[i]] = self[i]

fn total_len(&self) -> IndexType

Get the total number of elements stored, including all batches. Returns self.len() * self.context().nbatch().

fn is_empty(&self) -> bool

Check if the vector is empty.

fn for_each_batch_host<const N: usize>( &mut self, args: [&Self; N], f: impl FnMut(&mut [Self::T], [&[Self::T]; N], usize), )

Run f once per batch lane of self on the host, passing that lane of self as a mutable slice and the corresponding lane of each operand in args as an immutable slice.

fn for_each_batch_mut<const M: usize, const N: usize>( mut_args: [&mut Self; M], args: [&Self; N], f: impl Fn([&mut [Self::T]; M], [&[Self::T]; N], usize) + Copy + Send, )

Run f once per batch lane on the device where the backend has one, falling back to Self::for_each_batch_mut_host otherwise.

fn for_each_batch<const N: usize>( &mut self, args: [&Self; N], f: impl Fn(&mut [Self::T], [&[Self::T]; N], usize) + Copy + Send, )

Run f once per batch lane of self on the device where the backend has one.

fn for_each_elem_mut<const M: usize, const N: usize>( mut_args: [&mut Self; M], args: [&Self; N], f: impl Fn([&mut Self::T; M], [&[Self::T]; N], usize, usize) + Copy + Send, )

Run f once per element of every batch lane on the device where the backend has one, falling back to a host loop otherwise.

fn for_each_elem<const N: usize>( &mut self, args: [&Self; N], f: impl Fn(&mut Self::T, [&[Self::T]; N], usize, usize) + Copy + Send, )

Run f once per element of every batch lane of self on the device where the backend has one.

fn reduce_batch_host<const N: usize>( dest: &mut Self, args: [&Self; N], init: Self::T, map: impl FnMut([&[Self::T]; N], usize, usize) -> Self::T, combine: impl FnMut(Self::T, Self::T) -> Self::T, )

Reduce args over the batch dimension, elementwise, on the host.

fn reduce_batch<const N: usize>( dest: &mut Self, args: [&Self; N], init: Self::T, map: impl Fn([&[Self::T]; N], usize, usize) -> Self::T + Copy + Send, combine: impl Fn(Self::T, Self::T) -> Self::T + Copy + Send, )

Reduce args over the batch dimension, elementwise, on the device where the backend has one, falling back to Self::reduce_batch_host otherwise.

fn reduce_elem_host<const N: usize>( dest: &mut Self, args: [&Self; N], init: Self::T, map: impl FnMut([&[Self::T]; N], usize, usize) -> Self::T, combine: impl FnMut(Self::T, Self::T) -> Self::T, )

Reduce each batch lane of args over its elements, on the host.

fn reduce_elem<const N: usize>( dest: &mut Self, args: [&Self; N], init: Self::T, map: impl Fn([&[Self::T]; N], usize, usize) -> Self::T + Copy + Send, combine: impl Fn(Self::T, Self::T) -> Self::T + Copy + Send, )

Reduce each batch lane of args over its elements, on the device where the backend has one, falling back to Self::reduce_elem_host otherwise.

fn dot(&self, other: &Self) -> Self::T

The dot product with other, summed over every element of every batch lane. other broadcasts into this vector’s lanes, as in Self::reduce_elem. The per-lane sums are added on the host, which on a device backend means a copy back to the host each call: meant for tests and checks rather than inner loops.

fn rand(nstates: usize, seed: f64, ctx: Self::C) -> Self

A deterministic pseudo-random vector of length nstates with the lanes of ctx, for tests: element i of lane b is sin((b * nstates + i + 1) * seed). The values are irregular, so a dot test can’t pass by symmetry, and different seeds give different vectors.

fn assert_eq_st(&self, other: &Self, tol: Self::T)

Assert that this vector equals other within a scalar tolerance tol.

fn assert_eq_eps(&self, other: &Self, factor: f64)

Assert that this vector equals other within factor machine epsilons of Self::T.

fn assert_eq_norm( &self, other: &Self, atol: &Self, rtol: Self::T, factor: Self::T, )

Assert that this vector equals other using a weighted norm (same as used by ODE solvers).

fn assert_eq(&self, other: &Self, tol: &Self)

Assert that this vector equals other using a vector of per-element tolerances.

fn assert_eq_vec(s: Vec<Self::T>, other: Vec<Self::T>, tol: Vec<Self::T>)

impl<T: FaerScalar> VectorCommon for FaerVec<T>

type T = T

type C = FaerContext

type Inner = Mat<Own<T>>

fn inner(&self) -> &Self::Inner