Struct BitMatrix 

pub struct BitMatrix<B: BitBlock = u32> { /* private fields */ }

A matrix of bits.

Implementations

impl<B: BitBlock> BitMatrix<B>

pub fn new(rows: usize, row_bits: usize) -> Self

Create a new BitMatrix with specific numbers of bits in columns and rows.

pub fn num_cols(&self) -> usize

Returns the number of columns.

pub fn size(&self) -> (usize, usize)

Returns the matrix’s size as (rows, columns).

pub fn set(&mut self, row: usize, col: usize, enabled: bool)

Sets the value of a bit.

Panics

Panics if (row, col) is out of bounds.

pub fn fill(&mut self, enabled: bool)

Sets the value of all bits.

pub fn grow(&mut self, num_rows: usize, value: bool)

Grows the matrix in-place, adding num_rows rows filled with value.

pub fn truncate(&mut self, num_rows: usize)

Truncates the matrix.

pub fn sub_matrix<R: RangeBounds<usize>>(&self, range: R) -> BitSubMatrix<'_, B>

Returns a slice of the matrix’s rows.

pub fn sub_matrix_mut<R: RangeBounds<usize>>( &mut self, range: R, ) -> BitSubMatrixMut<'_, B>

Returns a slice of the matrix’s rows.

pub fn split_at(&self, row: usize) -> (BitSubMatrix<'_, B>, BitSubMatrix<'_, B>)

Given a row’s index, returns a slice of all rows above that row, a reference to said row, and a slice of all rows below.

Functionally equivalent to (self.sub_matrix(0..row), &self[row], self.sub_matrix(row..self.num_rows())).

pub fn split_at_mut( &mut self, row: usize, ) -> (BitSubMatrixMut<'_, B>, BitSubMatrixMut<'_, B>)

Given a row’s index, returns a slice of all rows above that row, a reference to said row, and a slice of all rows below.

pub fn iter_row(&self, row: usize) -> impl Iterator<Item = bool> + '_

Iterate over bits in the specified row.

pub fn transitive_closure(&mut self)

Computes the transitive closure of the binary relation represented by this square bit matrix.

Modifies this matrix in place using Warshall’s algorithm.

After this operation, the matrix will describe a transitive relation. This means that, for any indices a, b, c, if M[(a, b)] and M[(b, c)], then M[(a, c)].

Complexity

The time complexity is O(n^3), where n is the number of columns and rows.

Panics

The matrix must be square for this operation to succeed.

pub fn is_square(&self) -> bool

Determines whether the number of rows equals the number of columns.

This means the matrix is square.

pub fn is_empty(&self) -> bool

Determines whether the matrix is empty.

pub fn reflexive_closure(&mut self)

Computes the reflexive closure of the binary relation represented by this bit matrix. The matrix can be rectangular.

The reflexive closure means that for every x`` that will be within bounds, M[(x, x)]` is true.

In other words, modifies this matrix in-place by making all bits on the diagonal set.

Trait Implementations

impl<B: Clone + BitBlock> Clone for BitMatrix<B>

fn clone(&self) -> BitMatrix<B>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<B: Debug + BitBlock> Debug for BitMatrix<B>

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

Formats the value using the given formatter.

impl<B: Default + BitBlock> Default for BitMatrix<B>

fn default() -> BitMatrix<B>

Returns the “default value” for a type.

impl<B: Eq + BitBlock> Eq for BitMatrix<B>

impl<B: Hash + BitBlock> Hash for BitMatrix<B>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<B: BitBlock> Index<(usize, usize)> for BitMatrix<B>

Returns true if a bit is enabled in the matrix, or false otherwise.

The first index in the tuple is row number, and the second is column number.

type Output = bool

The returned type after indexing.

fn index(&self, (row, col): (usize, usize)) -> &bool

Performs the indexing (container[index]) operation.

impl<B: BitBlock> Index<usize> for BitMatrix<B>

Gains immutable access to the matrix’s row in the form of a BitSlice.

type Output = BitSlice<B>

The returned type after indexing.

fn index(&self, row: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<B: BitBlock> IndexMut<usize> for BitMatrix<B>

Gains mutable access to the matrix’s row in the form of a BitSlice.

fn index_mut(&mut self, row: usize) -> &mut Self::Output

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

impl<B: Ord + BitBlock> Ord for BitMatrix<B>

fn cmp(&self, other: &BitMatrix<B>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<B: PartialEq + BitBlock> PartialEq for BitMatrix<B>

fn eq(&self, other: &BitMatrix<B>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<B: PartialOrd + BitBlock> PartialOrd for BitMatrix<B>

fn partial_cmp(&self, other: &BitMatrix<B>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<B: PartialEq + BitBlock> StructuralPartialEq for BitMatrix<B>