Struct QuasiInverse 

pub struct QuasiInverse {
    image: Option<Vec<isize>>,
    preimage: Matrix,
}

Given a matrix M, a quasi-inverse Q is a map from the co-domain to the domain such that xQM = x for all x in the image (recall our matrices act on the right).

Fields

• image - The image of the original matrix. If the image is omitted, it is assumed to be everything (with the standard basis).
• preimage - The actual quasi-inverse, where the basis of the image is that given by image.

Fields

image: Option<Vec<isize>>

preimage: Matrix

Implementations

impl QuasiInverse

pub fn new(image: Option<Vec<isize>>, preimage: Matrix) -> Self

pub fn image_dimension(&self) -> usize

pub fn source_dimension(&self) -> usize

pub fn target_dimension(&self) -> usize

pub fn to_bytes(&self, buffer: &mut impl Write) -> Result<()>

pub fn from_bytes(p: ValidPrime, data: &mut impl Read) -> Result<Self>

pub fn stream_quasi_inverse<T, S>( p: ValidPrime, data: &mut impl Read, results: &mut [T], inputs: &[S], ) -> Result<()>

where for<'a> &'a mut T: Into<FpSliceMut<'a>>, for<'a> &'a S: Into<FpSlice<'a>>,

Given a data file containing a quasi-inverse, apply it to all the vectors in input and write the results to the corresponding vectors in results. This reads in the quasi-inverse row by row to minimize memory usage.

pub fn preimage(&self) -> &Matrix

pub fn pivots(&self) -> Option<&[isize]>

pub fn prime(&self) -> ValidPrime

pub fn apply(&self, target: FpSliceMut<'_>, coeff: u32, input: FpSlice<'_>)

Apply the quasi-inverse to an input vector and add a constant multiple of the result to an output vector

Arguments

• target - The output vector
• coeff - The constant multiple above
• input - The input vector, expressed in the basis of the ambient space

Trait Implementations

impl Clone for QuasiInverse

fn clone(&self) -> QuasiInverse

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for QuasiInverse

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for QuasiInverse

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for QuasiInverse

fn eq(&self, other: &QuasiInverse) -> 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 Serialize for QuasiInverse

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for QuasiInverse

impl StructuralPartialEq for QuasiInverse