Trait TransformTarget 

pub trait TransformTarget<R>
where
    R: ?Sized + RingBase,
{
    // Required method
    fn transform<S: Copy + RingStore<Type = R>>(
        &mut self,
        ring: S,
        i: usize,
        j: usize,
        transform: &[R::Element; 4],
    );

    // Provided methods
    fn subtract<S: Copy + RingStore<Type = R>>(
        &mut self,
        ring: S,
        src: usize,
        dst: usize,
        factor: &R::Element,
    ) { ... }
    fn swap<S: Copy + RingStore<Type = R>>(
        &mut self,
        ring: S,
        i: usize,
        j: usize,
    ) { ... }
}

A trait for a “target” that can “consume” elementary operations on matrices.

This is mainly used during algorithms that work on matrices, since in many cases they transform matrices using elementary row or column operations, and have to accumulate data depending on these operations.

Required Methods

fn transform<S: Copy + RingStore<Type = R>>( &mut self, ring: S, i: usize, j: usize, transform: &[R::Element; 4], )

The transformation given by the matrix A with A[k, l] being

• 1 if k = l and k != i, j
• transform[0] if (k, l) = (i, i)
• transform[1] if (k, l) = (i, j)
• transform[2] if (k, l) = (j, i)
• transform[3] if (k, l) = (j, j)
• 0 otherwise

In other words, the matrix looks like

| 1  ...  0                       |
| ⋮        ⋮                       |
| 0  ...  1                       |
|    A             B              | <- i-th row
|            1  ...  0            |
|            ⋮        ⋮            |
|            0  ...  1            |
|    C             D              | <- j-th row
|                       1  ...  0 |
|                       ⋮        ⋮ |
|                       0  ...  1 |
     ^ i-th col    ^ j-th col

where transform = [A, B, C, D].

Provided Methods

fn subtract<S: Copy + RingStore<Type = R>>( &mut self, ring: S, src: usize, dst: usize, factor: &R::Element, )

The transformation corresponding to subtracting factor times the src-th row resp. col from the dst-th row resp. col.

More precisely, the (k, l)-th entry of the transform matrix is defined to be

• 1 if k == l
• -factor if k == dst, l == src
• 0 otherwise

fn swap<S: Copy + RingStore<Type = R>>(&mut self, ring: S, i: usize, j: usize)

The transformation corresponding to the permutation matrix swapping i-th and j-th row resp. column.

More precisely, the (k, l)-th entry of the transform matrix is defined to be

• 1 if k == l, k != i, k != j
• 1 if k == i, l == j
• 1 if k == j, l == i
• 0 otherwise

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl<'a, T, R> TransformTarget<R> for &'a mut T

where R: ?Sized + RingBase, T: TransformTarget<R>,

fn transform<S: Copy + RingStore<Type = R>>( &mut self, ring: S, i: usize, j: usize, transform: &[R::Element; 4], )

fn subtract<S: Copy + RingStore<Type = R>>( &mut self, ring: S, src: usize, dst: usize, factor: &R::Element, )

fn swap<S: Copy + RingStore<Type = R>>(&mut self, ring: S, i: usize, j: usize)

impl<R> TransformTarget<R> for ()

where R: ?Sized + RingBase,

fn transform<S: Copy + RingStore<Type = R>>( &mut self, _: S, _: usize, _: usize, _: &[R::Element; 4], )

fn subtract<S: Copy + RingStore<Type = R>>( &mut self, _: S, _: usize, _: usize, _: &R::Element, )

fn swap<S: Copy + RingStore<Type = R>>(&mut self, _: S, _: usize, _: usize)

Implementors

impl<'a, V, R> TransformTarget<R> for TransformCols<'a, V, R>

where V: AsPointerToSlice<R::Element>, R: ?Sized + RingBase,

impl<'a, V, R> TransformTarget<R> for TransformRows<'a, V, R>

where V: AsPointerToSlice<R::Element>, R: ?Sized + RingBase,

impl<R> TransformTarget<R> for TransformList<R>

where R: ?Sized + RingBase,

impl<R, T1, T2> TransformTarget<R> for DuplicateTransforms<R, T1, T2>

where R: ?Sized + RingBase, T1: TransformTarget<R>, T2: TransformTarget<R>,

impl<R, T> TransformTarget<R> for OffsetTransformIndex<R, T>

where R: ?Sized + RingBase, T: TransformTarget<R>,