Struct ShortestTrace

pub struct ShortestTrace { /* private fields */ }

The shortest trace found in the edit space.

The index k is calculated as k = x - y. d is the depth in the graph that is examined. The values stored in the matrix are the best x value that can be achieved at each point.

Layout

    |                k
    |-5 -4 -3 -2 -1  0  1  2  3  4  5
----+---------------------------------
  0 |                o
  1 |             o  o  o
d 2 |          o  o  o  o  o
  3 |       o  o  o  o  o  o  o
  4 |    o  o  o  o  o  o  o  o  o
  5 | o  o  o  o  o  o  o  o  o  o  o

Example

Trace for diff of sequences ‘ABCABBA’ and ‘CBABAC’:

    |                k
    |-5 -4 -3 -2 -1  0  1  2  3  4  5
----+---------------------------------
  0 |                0
  1 |             0  0  1
d 2 |          2  0  2  1  3
  3 |       3  2  4  2  5  3  5
  4 |       3  4  4  5  5  7  5  7
  5 |       3  4  5  5  7  7  5  7

Implementations

impl ShortestTrace

pub const fn len(&self) -> usize

The length of the found shortest trace.

pub const fn data(&self) -> &[isize]

A slice of the 2D-matrix containing the recorded trace.

pub fn get(&self, d: isize, k: isize) -> &isize

Get a shared reference to an element in the recorded trace.

pub fn get_mut(&mut self, d: isize, k: isize) -> &mut isize

Get a mutable reference to an element in the recorded trace.

Trait Implementations

impl Clone for ShortestTrace

fn clone(&self) -> ShortestTrace

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ShortestTrace

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

Formats the value using the given formatter.

impl Index<(isize, isize)> for ShortestTrace

type Output = isize

The returned type after indexing.

fn index(&self, (d, k): (isize, isize)) -> &Self::Output

Performs the indexing (container[index]) operation.

impl IndexMut<(isize, isize)> for ShortestTrace

fn index_mut(&mut self, (d, k): (isize, isize)) -> &mut Self::Output

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

impl PartialEq for ShortestTrace

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

impl StructuralPartialEq for ShortestTrace