Struct SpVec 

pub struct SpVec<R> { /* private fields */ }

Implementations

impl<R> SpVec<R>

pub fn data(&self) -> (&[usize], &[R])

pub fn zero(dim: usize) -> Self

pub fn is_zero(&self) -> bool

where R: Zero,

pub fn unit(n: usize, i: usize) -> Self

where R: One,

pub fn dim(&self) -> usize

pub fn iter(&self) -> impl Iterator<Item = (usize, &R)>

pub fn iter_nz(&self) -> impl Iterator<Item = (usize, &R)>

where R: Zero,

pub fn into_vec(self) -> Vec<R>

where R: Clone + Zero,

pub fn into_mat(self) -> SpMat<R>

impl<R> SpVec<R>

where R: Scalar + Zero + ClosedAddAssign,

pub fn from_entries<T>(dim: usize, entries: T) -> Self

where T: IntoIterator<Item = (usize, R)>,

pub fn from_sorted_entries<T>(dim: usize, entries: T) -> Self

where T: IntoIterator<Item = (usize, R)>,

pub fn stack_vecs<I>(vecs: I) -> Self

where I: IntoIterator<Item = SpVec<R>>,

pub fn extract<F>(&self, dim: usize, f: F) -> SpVec<R>

where F: Fn(usize) -> Option<usize>,

pub fn permute(&self, p: PermView<'_>) -> SpVec<R>

pub fn subvec(&self, range: Range<usize>) -> SpVec<R>

pub fn stack(&self, other: &SpVec<R>) -> SpVec<R>

pub fn split(&self, at: usize) -> (SpVec<R>, SpVec<R>)

pub fn to_dense(&self) -> Vec<R>

Trait Implementations

impl<'a, 'b, R> Add for SpVec<R>

where R: Scalar + ClosedAddAssign + ClosedSubAssign + ClosedMulAssign + Zero + One + Neg<Output = R>,

type Output = SpVec<R>

The resulting type after applying the + operator.

fn add(self, rhs: SpVec<R>) -> Self::Output

Performs the + operation.

impl<'a, 'b, R> Add<&'b SpVec<R>> for &'a SpVec<R>

where R: Scalar + ClosedAddAssign + ClosedSubAssign + ClosedMulAssign + Zero + One + Neg<Output = R>,

type Output = SpVec<R>

The resulting type after applying the + operator.

fn add(self, rhs: &'b SpVec<R>) -> Self::Output

Performs the + operation.

impl<'a, 'b, R> Add<&'b SpVec<R>> for SpVec<R>

where R: Scalar + ClosedAddAssign + ClosedSubAssign + ClosedMulAssign + Zero + One + Neg<Output = R>,

type Output = SpVec<R>

The resulting type after applying the + operator.

fn add(self, rhs: &'b SpVec<R>) -> Self::Output

Performs the + operation.

impl<'a, 'b, R> Add<SpVec<R>> for &'a SpVec<R>

where R: Scalar + ClosedAddAssign + ClosedSubAssign + ClosedMulAssign + Zero + One + Neg<Output = R>,

type Output = SpVec<R>

The resulting type after applying the + operator.

fn add(self, rhs: SpVec<R>) -> Self::Output

Performs the + operation.

impl<'a, 'b, R> AddAssign for SpVec<R>

where R: Scalar + ClosedAddAssign + ClosedSubAssign + ClosedMulAssign + Zero + One + Neg<Output = R>,

fn add_assign(&mut self, rhs: SpVec<R>)

Performs the += operation.

impl<'a, 'b, R> AddAssign<&'b SpVec<R>> for SpVec<R>

where R: Scalar + ClosedAddAssign + ClosedSubAssign + ClosedMulAssign + Zero + One + Neg<Output = R>,

fn add_assign(&mut self, rhs: &'b SpVec<R>)

Performs the += operation.

impl<R: Clone> Clone for SpVec<R>

fn clone(&self) -> SpVec<R>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<R: Debug> Debug for SpVec<R>

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

Formats the value using the given formatter.

impl<R> Default for SpVec<R>

fn default() -> Self

Returns the “default value” for a type.

impl<R> Display for SpVec<R>

where R: Ring, for<'a> &'a R: RingOps<R>,

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

Formats the value using the given formatter.

impl<R: Eq> Eq for SpVec<R>

impl<R> From<SpVec<R>> for SpMat<R>

fn from(vec: SpVec<R>) -> Self

Converts to this type from the input type.

impl<R> From<SpVec<R>> for Vec<R>

where R: Clone + Zero,

fn from(value: SpVec<R>) -> Self

Converts to this type from the input type.

impl<R> From<Vec<R>> for SpVec<R>

where R: Scalar + Zero + ClosedAddAssign,

fn from(vec: Vec<R>) -> Self

Converts to this type from the input type.

impl<'a, 'b, R> Mul<&'b SpVec<R>> for &'a SpMat<R>

where R: Ring, for<'x> &'x R: RingOps<R>,

type Output = SpVec<R>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b SpVec<R>) -> Self::Output

Performs the * operation.

impl<'a, 'b, R> Mul<&'b SpVec<R>> for SpMat<R>

where R: Ring, for<'x> &'x R: RingOps<R>,

type Output = SpVec<R>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b SpVec<R>) -> Self::Output

Performs the * operation.

impl<'a, 'b, R> Mul<SpVec<R>> for &'a SpMat<R>

where R: Ring, for<'x> &'x R: RingOps<R>,

type Output = SpVec<R>

The resulting type after applying the * operator.

fn mul(self, rhs: SpVec<R>) -> Self::Output

Performs the * operation.

impl<'a, 'b, R> Mul<SpVec<R>> for SpMat<R>

where R: Ring, for<'x> &'x R: RingOps<R>,

type Output = SpVec<R>

The resulting type after applying the * operator.

fn mul(self, rhs: SpVec<R>) -> Self::Output

Performs the * operation.

impl<R> Neg for &SpVec<R>

where R: Scalar + Neg<Output = R>,

type Output = SpVec<R>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<R> Neg for SpVec<R>

where R: AddGrp, for<'a> &'a R: AddGrpOps<R>,

type Output = SpVec<R>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<R: PartialEq> PartialEq for SpVec<R>

fn eq(&self, other: &SpVec<R>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<R> StructuralPartialEq for SpVec<R>

impl<'a, 'b, R> Sub for SpVec<R>

where R: Scalar + ClosedAddAssign + ClosedSubAssign + ClosedMulAssign + Zero + One + Neg<Output = R>,

type Output = SpVec<R>

The resulting type after applying the - operator.

fn sub(self, rhs: SpVec<R>) -> Self::Output

Performs the - operation.

impl<'a, 'b, R> Sub<&'b SpVec<R>> for &'a SpVec<R>

where R: Scalar + ClosedAddAssign + ClosedSubAssign + ClosedMulAssign + Zero + One + Neg<Output = R>,

type Output = SpVec<R>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b SpVec<R>) -> Self::Output

Performs the - operation.

impl<'a, 'b, R> Sub<&'b SpVec<R>> for SpVec<R>

where R: Scalar + ClosedAddAssign + ClosedSubAssign + ClosedMulAssign + Zero + One + Neg<Output = R>,

type Output = SpVec<R>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b SpVec<R>) -> Self::Output

Performs the - operation.

impl<'a, 'b, R> Sub<SpVec<R>> for &'a SpVec<R>

where R: Scalar + ClosedAddAssign + ClosedSubAssign + ClosedMulAssign + Zero + One + Neg<Output = R>,

type Output = SpVec<R>

The resulting type after applying the - operator.

fn sub(self, rhs: SpVec<R>) -> Self::Output

Performs the - operation.

impl<'a, 'b, R> SubAssign for SpVec<R>

where R: Scalar + ClosedAddAssign + ClosedSubAssign + ClosedMulAssign + Zero + One + Neg<Output = R>,

fn sub_assign(&mut self, rhs: SpVec<R>)

Performs the -= operation.

impl<'a, 'b, R> SubAssign<&'b SpVec<R>> for SpVec<R>

where R: Scalar + ClosedAddAssign + ClosedSubAssign + ClosedMulAssign + Zero + One + Neg<Output = R>,

fn sub_assign(&mut self, rhs: &'b SpVec<R>)

Performs the -= operation.