Enum varpro::util::Weights

pub enum Weights<ScalarType, D>
where
    ScalarType: Scalar + ComplexField,
    D: Dim,
    DefaultAllocator: Allocator<ScalarType, D>,
{
    Unit,
    Diagonal(DiagMatrix<ScalarType, D>),
}

a variant for different weights that can be applied to a least squares problem Right now covers only either unit weights (i.e. unweighted problem) or a diagonal matrix for the weights. Can easily be extended in the future, because this structure offers an interface for matrix-matrix multiplication and matrix-vector multiplication

Variants

Unit

unit weights, which means the problem is unweighted

Diagonal(DiagMatrix<ScalarType, D>)

the weights are represented by a diagonal matrix

Implementations

impl<ScalarType, D> Weights<ScalarType, D>

where ScalarType: Scalar + ComplexField, D: Dim, DefaultAllocator: Allocator<ScalarType, D>,

pub fn diagonal(diagonal: OVector<ScalarType, D>) -> Self

create diagonal weights with the given diagonal elements of a matrix. The resulting diagonal matrix is a square matrix with the given diagonal elements and all off-diagonal elements set to zero Make sure that the dimensions of the weights match the data that they should be applied to

pub fn is_size_correct_for_data_length(&self, data_len: usize) -> bool

check that the weights are appropriately sized for the given data vector, so that they can be applied without panic. For unit weights this is always true, but for diagonal weights it is not.

Arguments

• data_len: the number of elements in the data vector

Trait Implementations

impl<ScalarType, D> Clone for Weights<ScalarType, D>

where ScalarType: Scalar + ComplexField + Clone, D: Dim + Clone, DefaultAllocator: Allocator<ScalarType, D>,

fn clone(&self) -> Weights<ScalarType, D>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<ScalarType, D> Debug for Weights<ScalarType, D>

where ScalarType: Scalar + ComplexField + Debug, D: Dim + Debug, DefaultAllocator: Allocator<ScalarType, D>,

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

Formats the value using the given formatter.

impl<ScalarType, D> Default for Weights<ScalarType, D>

where ScalarType: Scalar + ComplexField, D: Dim, DefaultAllocator: Allocator<ScalarType, D>,

Get a variant representing unit weights (i.e. unweighted problem)

fn default() -> Self

Returns the “default value” for a type.

impl<ScalarType, D> From<DiagMatrix<ScalarType, D>> for Weights<ScalarType, D>

where ScalarType: Scalar + ComplexField, D: Dim, DefaultAllocator: Allocator<ScalarType, D>,

create diagonal weights using the given diagonal matrix

fn from(diag: DiagMatrix<ScalarType, D>) -> Self

Converts to this type from the input type.

impl<ScalarType, R, C, S> Mul<Matrix<ScalarType, R, C, S>> for &Weights<ScalarType, R>

where ScalarType: ClosedMul + Scalar + ComplexField, C: Dim, R: Dim, S: RawStorageMut<ScalarType, R, C>, DefaultAllocator: Allocator<ScalarType, R> + Allocator<ScalarType, R, C>,

A convenience method that allows to multiply weights to a matrix from the left. This performs the matrix multiplication corresponding to the weight matrix. However, since the method knows e.g. if the weights are diagonal or unit it can take shortcuts and make the operation more efficient. It is a no-op if the weights are unit.

Panics

If the matrix matrix multiplication fails because of incorrect dimensions. (unit weights never panic)

type Output = Matrix<ScalarType, R, C, S>

The resulting type after applying the * operator.

fn mul(self, rhs: Matrix<ScalarType, R, C, S>) -> Self::Output

Performs the * operation.

impl<ScalarType, D> PartialEq for Weights<ScalarType, D>

where ScalarType: Scalar + ComplexField + PartialEq, D: Dim + PartialEq, DefaultAllocator: Allocator<ScalarType, D>,

fn eq(&self, other: &Weights<ScalarType, D>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<ScalarType, D> Eq for Weights<ScalarType, D>

where ScalarType: Scalar + ComplexField + Eq, D: Dim + Eq, DefaultAllocator: Allocator<ScalarType, D>,

impl<ScalarType, D> StructuralPartialEq for Weights<ScalarType, D>

where ScalarType: Scalar + ComplexField, D: Dim, DefaultAllocator: Allocator<ScalarType, D>,