lin_algebra

https://docs.rs/lin_algebra/0.4.1/
Admin
A Rust linear algebra library providing matrix operations over GF(2) fields and general matrix...
Tokens:18,882
Snippets:184
Trust Score:9.1
Update:5 months ago
Show doc for...
Tokens:
Raw
### Get Number of Columns

Source: https://docs.rs/lin_algebra/0.4.1/lin_algebra/matrix/struct.Matrix.html

Returns the number of columns in the matrix.

```rust
fn ncols(&self) -> usize
```

--------------------------------

### Get Matrix Dimensions

Source: https://docs.rs/lin_algebra/0.4.1/src/lin_algebra/lib.rs.html

Returns the number of rows and columns of a GF2Matrix. Essential for understanding matrix size.

```rust
let mat = GF2Matrix::new(vec![vec![1, 0, 1], vec![1, 1, 0]]);
assert_eq!(mat.nrows(), 2);
assert_eq!(mat.ncols(), 3)
```

--------------------------------

### Get Number of Rows

Source: https://docs.rs/lin_algebra/0.4.1/lin_algebra/matrix/struct.Matrix.html

Returns the number of rows in the matrix.

```rust
fn nrows(&self) -> usize
```

--------------------------------

### Get Echelon Form Operations

Source: https://docs.rs/lin_algebra/0.4.1/src/lin_algebra/lib.rs.html

Retrieves the sequence of operations performed to reach the echelon form of a GF2Matrix. This can be useful for understanding the transformation process.

```rust
let mat = GF2Matrix::new(vec![vec![1, 0], vec![1, 1]]);
let (_, ops) = mat.echelon_form();
assert_eq!(ops, vec![(1, 0)])
```

--------------------------------

### Get Type ID

Source: https://docs.rs/lin_algebra/0.4.1/lin_algebra/matrix/struct.Matrix.html

Gets the TypeId of the current type.

```rust
fn type_id(&self) -> TypeId
```

--------------------------------

### Get Row Slice

Source: https://docs.rs/lin_algebra/0.4.1/lin_algebra/matrix/struct.Matrix.html

Returns a slice representing the specified row of the matrix.

```rust
fn row(&self, r: usize) -> &[T]
```

--------------------------------

### MatrixCommon Trait Implementation

Source: https://docs.rs/lin_algebra/0.4.1/src/lin_algebra/matrix.rs.html

Implements the `MatrixCommon` trait for the `Matrix` struct, providing methods to get the number of rows, columns, and a specific row. Includes a helper function `get_pivot` to find the first non-zero element in a row.

```rust
impl<T: Number> MatrixCommon<T> for Matrix<T> {
    fn nrows(&self) -> usize {
        self.elements.len()
    }
    fn ncols(&self) -> usize {
        self.elements.first().map_or(0, |r| r.len())
    }
    fn row(&self, r: usize) -> &[T] {
        &self.elements[r]
    }
    fn get_pivot(row: &[T]) -> Option<usize> {
        row.iter().position(|&x| !x.is_zero())
    }
}
```

--------------------------------

### Instantiate GF2Matrix

Source: https://docs.rs/lin_algebra/0.4.1/src/lin_algebra/lib.rs.html

Creates a new GF2Matrix with the given elements. Used for initializing matrices.

```rust
let mat = GF2Matrix::new(vec![vec![1, 0], vec![1, 1]]);
let el = mat.elements;
assert_eq!(el, vec![vec![1, 0], vec![1, 1]]);
```

--------------------------------

### Create and Transform PackedGF2Matrix to Echelon Form

Source: https://docs.rs/lin_algebra/0.4.1/lin_algebra/packed_gf2_matrix/struct.PackedGF2Matrix.html

Demonstrates creating a PackedGF2Matrix and transforming it into echelon form. The original matrix is not modified. Pivots are always 1, and other entries in pivot columns are cleared.

```rust
let m = PackedGF2Matrix::new(vec![0b110u8, 0b101u8, 0b011u8], 3);
let (echelon, ops) = m.echelon_form();
// `echelon` contains the transformed matrix over GF(2),
// and `ops` contains the recorded row operations.
```

--------------------------------

### MatrixTrait Implementations for GF2Matrix

Source: https://docs.rs/lin_algebra/0.4.1/lin_algebra/gf2_matrix/type.GF2Matrix.html

Provides implementations for core matrix operations defined in the MatrixTrait.

```APIDOC
## impl MatrixTrait<u8> for GF2Matrix

### is_reduced_echelon
Checks if a GF(2) matrix is in reduced row echelon form (RREF).

### rank
Computes the rank of the linear application represented by a GF(2) matrix. Converts to RREF if necessary.

### kernel
Computes the base of the kernel of the linear application represented by a GF(2) matrix. Converts to RREF if necessary.

### echelon_form
Computes the reduced echelon form (RREF) of a GF(2) matrix along with the history of row operations.

### image
Computes the image of the linear application corresponding to a GF(2) matrix. Converts to RREF if necessary.
```

--------------------------------

### MatrixTrait Methods

Source: https://docs.rs/lin_algebra/0.4.1/lin_algebra/matrix/trait.MatrixTrait.html

This snippet details the required methods for types implementing the MatrixTrait.

```APIDOC
## Trait MatrixTrait

### Summary
```rust
pub trait MatrixTrait<T: Number>: MatrixCommon<T> {
    // Required methods
    fn rank(&self) -> usize;
    fn kernel(&self) -> Vec<Vec<T>>;
    fn echelon_form(&self) -> (Self, Vec<(usize, usize)>)
       where Self: Sized;
    fn image(&self) -> Vec<Vec<T>>;
    fn is_reduced_echelon(&self) -> bool;
}
```

## Required Methods

#### fn rank(&self) -> usize
Calculates the rank of the matrix.

#### fn kernel(&self) -> Vec<Vec<T>>
Computes the kernel (null space) of the matrix.

#### fn echelon_form(&self) -> (Self, Vec<(usize, usize)>)
where Self: Sized,
Transforms the matrix into its echelon form and returns the transformed matrix along with pivot positions.

#### fn image(&self) -> Vec<Vec<T>>
Computes the image (column space) of the matrix.

#### fn is_reduced_echelon(&self) -> bool
Checks if the matrix is in reduced row echelon form.
```

--------------------------------

### Get Column of GF2Matrix

Source: https://docs.rs/lin_algebra/0.4.1/src/lin_algebra/gf2_matrix.rs.html

Retrieves a specific column from a GF2Matrix as a vector of u8.

```rust
fn column(&self, idx: usize) -> Vec<u8> {
        self.elements.iter().map(|row| row[idx]).collect()
    }
```

--------------------------------

### Matrix::solve_matrix_system (for u8)

Source: https://docs.rs/lin_algebra/0.4.1/lin_algebra/matrix/struct.Matrix.html

Solves a system of linear equations of the form A*X = B, where A is the current matrix and B is a GF2Matrix.

```APIDOC
## impl Matrix<u8>

### pub fn solve_matrix_system(&self, y: &GF2Matrix) -> GF2Matrix

Solves for X such that equation A*X = B where A and B are GF2Matrix matrices.

#### Arguments
- `y`: GF2Matrix - The right-hand side matrix such that self * X = Y.

#### Returns
- GF2Matrix: Matrix X such that self * X = Y.
```

--------------------------------

### Solve Matrix System (GF2Matrix)

Source: https://docs.rs/lin_algebra/0.4.1/lin_algebra/matrix/struct.Matrix.html

Solves for X in the equation A*X = B, where A is the current matrix (self) and B is a GF2Matrix.

```rust
pub fn solve_matrix_system(&self, y: &GF2Matrix) -> GF2Matrix
```

--------------------------------

### Convert from PackedGF2Matrix (by reference)

Source: https://docs.rs/lin_algebra/0.4.1/lin_algebra/gf2_matrix/type.GF2Matrix.html

Converts a reference to a PackedGF2Matrix into a GF2Matrix.

```rust
fn from(int_matrix: &PackedGF2Matrix<T>) -> Self
```

--------------------------------

### Get Pivot Index

Source: https://docs.rs/lin_algebra/0.4.1/lin_algebra/matrix/struct.Matrix.html

Finds the index of the first non-zero element (pivot) in a given row slice.

```rust
fn get_pivot(row: &[T]) -> Option<usize>
```

--------------------------------

### Debug Implementation for BitOrder

Source: https://docs.rs/lin_algebra/0.4.1/lin_algebra/packed_gf2_matrix/enum.BitOrder.html

Enables debugging output for BitOrder values.

```APIDOC
### impl Debug for BitOrder

#### fn fmt(&self, f: &mut Formatter<'_>) -> Result
Formats the value using the given formatter.
```

--------------------------------

### Clone Implementation for BitOrder

Source: https://docs.rs/lin_algebra/0.4.1/lin_algebra/packed_gf2_matrix/enum.BitOrder.html

Provides methods for cloning BitOrder values.

```APIDOC
### impl Clone for BitOrder

#### fn clone(&self) -> BitOrder
Returns a duplicate of the value.

#### fn clone_from(&mut self, source: &Self)
Performs copy-assignment from `source`.
```

--------------------------------

### MatrixCommon Trait Definition

Source: https://docs.rs/lin_algebra/0.4.1/src/lin_algebra/matrix.rs.html

Defines the `MatrixCommon` trait for common matrix operations. It includes methods for getting the number of rows, columns, and a specific row, along with a static helper method `get_pivot`.

```rust
pub trait MatrixCommon<T: Number> {
    fn nrows(&self) -> usize;
    fn ncols(&self) -> usize;
    fn row(&self, r: usize) -> &[T];
    fn get_pivot(row: &[T]) -> Option<usize> {
        row.iter().position(|&x| !x.is_zero())
    }
}
```

--------------------------------

### solve_matrix_system

Source: https://docs.rs/lin_algebra/0.4.1/lin_algebra/gf2_matrix/type.GF2Matrix.html

Solves for X in the equation A*X = B, where A and B are GF2Matrix matrices.

```APIDOC
## pub fn solve_matrix_system(&self, y: &GF2Matrix) -> GF2Matrix

### Description
Solves for X such that equation A*X = B where A and B are GF2Matrix matrices.

### Arguments
* `y` - right hand side matrix: GF2Matrix such that self * X = Y

### Returns
Matrix X such that self * X = Y.
```

--------------------------------

### Solve Matrix System A*X = B

Source: https://docs.rs/lin_algebra/0.4.1/src/lin_algebra/gf2_matrix.rs.html

Solves for matrix X in the equation A*X = B, where A and B are GF2Matrix matrices. Panics if the matrix A does not have full rank.

```rust
pub fn solve_matrix_system(&self, y: &GF2Matrix) -> GF2Matrix {
        if self.rank() < self.ncols() {
            panic!("Matrix must have full rank");
        }

        let (ech, operations) = self.echelon_form();
        let to_remove = ech.nrows() - ech.rank();

        let n_rows = self.ncols();
        let n_cols = y.ncols();

        let mut elements = vec![vec![0u8; n_cols]; n_rows];
        for j in 0..y.ncols() {
            let mut solved_b = Self::apply_operations(&operations, &y.column(j));
            for _ in 0..to_remove {
                solved_b.remove(solved_b.len() - 1);
            }

            for i in 0..n_rows {
                elements[i][j] = solved_b[i];
            }
        }

        GF2Matrix::new(elements)
    }
```

--------------------------------

### Identity Conversion

Source: https://docs.rs/lin_algebra/0.4.1/lin_algebra/matrix/struct.Matrix.html

Returns the argument unchanged.

```rust
fn from(t: T) -> T
```

--------------------------------

### Echelon Form Method

Source: https://docs.rs/lin_algebra/0.4.1/lin_algebra/matrix/trait.MatrixTrait.html

Transforms the matrix into its row echelon form. Returns the transformed matrix and a list of row swaps performed.

```rust
fn echelon_form(&self) -> (Self, Vec<(usize, usize)>)
       where Self: Sized;
```

--------------------------------

### Solve Linear System (Vector)

Source: https://docs.rs/lin_algebra/0.4.1/lin_algebra/matrix/struct.Matrix.html

Solves for x in the equation A*x = b, where A is a GF2Matrix and b is a vector.

```rust
pub fn solve(&self, b: &Vec<u8>) -> Vec<u8>
```

--------------------------------

### Compute Kernel Basis from Echelon Form

Source: https://docs.rs/lin_algebra/0.4.1/src/lin_algebra/gf2_matrix.rs.html

Computes a basis for the kernel (null space) of a GF2Matrix, assuming the matrix is in echelon form. It identifies pivot and free columns to construct the basis vectors.

```rust
fn kernel_echelon_form(&self) -> Vec<Vec<u8>> {
        let rows = self.nrows();
        let cols = self.ncols();

        let mut pivots = std::collections::HashMap::new();
        let mut kernel_base: Vec<Vec<u8>> = Vec::new();
        let mut free_columns: Vec<usize> = Vec::new();
        let mut row_index = 0;

        for j in 0..cols {
            if row_index < rows && self.elements[row_index][j] == 1 {
                pivots.insert(j, row_index);
                row_index += 1;
            } else {
                free_columns.push(j);
            }
        }

        for &free_col in &free_columns {
            let mut kernel_vector = vec![0; cols];
            kernel_vector[free_col] = 1;

            for (&p_index, &p_row) in &pivots {
                let mut sum = 0;

                for col in (0..cols).rev() {
                    if col != p_index {
                        sum = sum ^ (self.elements[p_row][col] * kernel_vector[col]);
                    }
                }

                kernel_vector[p_index] = sum;
            }

            kernel_base.push(kernel_vector);
        }

        kernel_base
    }
```

--------------------------------

### Convert GF2Matrix to PackedGF2Matrix (Reference)

Source: https://docs.rs/lin_algebra/0.4.1/lin_algebra/matrix/struct.Matrix.html

Converts a reference to a GF2Matrix into a PackedGF2Matrix.

```rust
fn from(gf2_matrix: &GF2Matrix) -> Self
```

--------------------------------

### From<GF2Matrix> for PackedGF2Matrix<T>

Source: https://docs.rs/lin_algebra/0.4.1/src/lin_algebra/convert.rs.html

Converts an owned GF2Matrix into a PackedGF2Matrix.

```APIDOC
## From<GF2Matrix> for PackedGF2Matrix<T>

### Description
Converts an owned `GF2Matrix` into a `PackedGF2Matrix`.

### Method
`From` trait implementation

### Parameters
- `gf2_matrix`: `GF2Matrix` - The GF2Matrix to convert.

### Response
- `PackedGF2Matrix<T>` - The resulting PackedGF2Matrix.

### Example
```rust
use lin_algebra::gf2_matrix::GF2Matrix;
use lin_algebra::packed_gf2_matrix::PackedGF2Matrix;

let gf2_matrix = GF2Matrix { elements: vec![vec![0, 1], vec![1, 0]] };
let packed_matrix: PackedGF2Matrix<u8> = gf2_matrix.into();
```
```

--------------------------------

### Solve Matrix System with GF2Matrix

Source: https://docs.rs/lin_algebra/0.4.1/src/lin_algebra/lib.rs.html

Solves a system of linear equations represented by a matrix equation AX = B over GF(2). Assumes the matrix A has full rank.

```rust
let left_elements = vec![vec![1, 0, 0], vec![0, 1, 1], vec![1, 0, 1]];
let right_elements = vec![vec![0, 0, 1], vec![0, 1, 1], vec![1, 1, 1]];
let m = GF2Matrix::new(left_elements);
let rm = GF2Matrix::new(right_elements);
let r = m.solve_matrix_system(&rm);
assert_eq!(r.elements, vec![vec![0, 0, 1], vec![1, 0, 1], vec![1, 1, 0]]);
```

--------------------------------

### Clone to Uninitialized Memory (Nightly)

Source: https://docs.rs/lin_algebra/0.4.1/lin_algebra/matrix/struct.Matrix.html

Performs copy-assignment from self to uninitialized memory. This is a nightly-only experimental API.

```rust
unsafe fn clone_to_uninit(&self, dest: *mut u8)
```

--------------------------------

### Clone Into

Source: https://docs.rs/lin_algebra/0.4.1/lin_algebra/matrix/struct.Matrix.html

Uses borrowed data to replace owned data, usually by cloning.

```rust
fn clone_into(&self, target: &mut T)
```

--------------------------------

### Handle Non-Full Rank Matrix System

Source: https://docs.rs/lin_algebra/0.4.1/src/lin_algebra/lib.rs.html

Tests the panic condition when attempting to solve a matrix system with a matrix that does not have full rank. Expects a panic with a specific message.

```rust
let left_elements = vec![vec![1, 0, 0], vec![0, 1, 1]];
let right_elements = vec![vec![0, 0, 1], vec![0, 1, 1], vec![1, 1, 1]];
let m = GF2Matrix::new(left_elements);
let rm = GF2Matrix::new(right_elements);
m.solve_matrix_system(&rm);
```

--------------------------------

### Create New Matrix

Source: https://docs.rs/lin_algebra/0.4.1/lin_algebra/matrix/struct.Matrix.html

Constructs a new Matrix instance from a given vector of vectors.

```rust
pub fn new(elements: Vec<Vec<T>>) -> Self
```

--------------------------------

### Test conversion from PackedGF2Matrix to GF2Matrix (borrowed)

Source: https://docs.rs/lin_algebra/0.4.1/src/lin_algebra/convert.rs.html

Tests the conversion of a borrowed PackedGF2Matrix to a GF2Matrix and verifies the resulting elements.

```rust
#[test]
    fn test_int_mtrix_to_gf2_matrix_convertion_by_ref() {
        let elements = vec![0, 1, 2, 4, 8];
        let int_matrix = PackedGF2Matrix::<u8>::new(elements.clone(), 4);
        let gf2_matrix = GF2Matrix::from(&int_matrix);
        let expected = vec![
            vec![0, 0, 0, 0],
            vec![0, 0, 0, 1],
            vec![0, 0, 1, 0],
            vec![0, 1, 0, 0],
            vec![1, 0, 0, 0],
        ];
        assert_eq!(gf2_matrix.elements, expected);

        let int_matrix = PackedGF2Matrix::<u8>::new(elements.clone(), 4);
        let gf2_matrix: GF2Matrix = (&int_matrix).into();
        assert_eq!(gf2_matrix.elements, expected);
    }
```

--------------------------------

### Image Method

Source: https://docs.rs/lin_algebra/0.4.1/lin_algebra/matrix/trait.MatrixTrait.html

Computes the image (or column space) of the matrix. The image is the span of the matrix's column vectors.

```rust
fn image(&self) -> Vec<Vec<T>>;
```

--------------------------------

### solve

Source: https://docs.rs/lin_algebra/0.4.1/lin_algebra/gf2_matrix/type.GF2Matrix.html

Solves for X in the equation A*x = b, where A is a GF2Matrix and b is a Vec<u8>.

```APIDOC
## pub fn solve(&self, b: &Vec<u8>) -> Vec<u8>

### Description
Solves for X such that equation A*x = b where A is a GF2Matrix and b a Vec.

### Arguments
* `b` - right hand side vector: such that self*x = b

### Returns
x such that self*x = b
```

--------------------------------

### Implementations of Number for Primitive Types

Source: https://docs.rs/lin_algebra/0.4.1/lin_algebra/matrix/trait.Number.html

Shows implementations of the Number trait for unsigned integer types like u8, u16, u32, and u64.

```APIDOC
## Implementations on Foreign Types

### impl Number for u8
#### fn into_usize(self) -> usize

### impl Number for u16
#### fn into_usize(self) -> usize

### impl Number for u32
#### fn into_usize(self) -> usize

### impl Number for u64
#### fn into_usize(self) -> usize
```

--------------------------------

### From<PackedGF2Matrix<T>> for GF2Matrix (Owned)

Source: https://docs.rs/lin_algebra/0.4.1/src/lin_algebra/convert.rs.html

Converts an owned PackedGF2Matrix into a GF2Matrix.

```APIDOC
## From<PackedGF2Matrix<T>> for GF2Matrix

### Description
Converts an owned `PackedGF2Matrix` into a `GF2Matrix`.

### Method
`From` trait implementation

### Parameters
- `int_matrix`: `PackedGF2Matrix<T>` - The packed integer matrix to convert.

### Response
- `GF2Matrix` - The resulting GF2Matrix.

### Example
```rust
use lin_algebra::gf2_matrix::GF2Matrix;
use lin_algebra::packed_gf2_matrix::PackedGF2Matrix;

let packed_matrix = PackedGF2Matrix::<u8>::new(vec![0, 1, 2], 4);
let gf2_matrix: GF2Matrix = packed_matrix.into();
```
```

--------------------------------

### Convert GF2Matrix to PackedGF2Matrix (Owned)

Source: https://docs.rs/lin_algebra/0.4.1/lin_algebra/matrix/struct.Matrix.html

Converts an owned GF2Matrix into a PackedGF2Matrix.

```rust
fn from(gf2_matrix: GF2Matrix) -> Self
```

--------------------------------

### solve

Source: https://docs.rs/lin_algebra/0.4.1/src/lin_algebra/gf2_matrix.rs.html

Solves for vector x in the equation A*x = b, where A is a GF2Matrix and b is a Vec<u8>. The matrix A must have full rank.

```APIDOC
## solve

### Description
Solves for vector x in the equation A*x = b, where A is a GF2Matrix and b is a Vec<u8>. The matrix A must have full rank.

### Method
`pub fn solve(&self, b: &Vec<u8>) -> Vec<u8>`

### Arguments
* `b` - The right-hand side vector (Vec<u8>) such that `self * x = b`.

### Returns
Vector `x` such that `self * x = b`.

### Panics
Panics if the matrix `self` does not have full rank.
```

--------------------------------

### Solve Linear Equation with GF2Matrix

Source: https://docs.rs/lin_algebra/0.4.1/src/lin_algebra/lib.rs.html

Solves a system of linear equations AX = B over GF(2) where B is a vector. Assumes the matrix A has full rank.

```rust
let left_elements = vec![vec![1, 0, 0], vec![0, 1, 1], vec![1, 0, 1]];
let b = vec![0, 0, 1];
let m = GF2Matrix::new(left_elements);
let r = m.solve(&b);
assert_eq!(r, vec![0, 1, 1]);
```

--------------------------------

### From<PackedGF2Matrix<T>> for GF2Matrix

Source: https://docs.rs/lin_algebra/0.4.1/src/lin_algebra/convert.rs.html

Converts a PackedGF2Matrix into a GF2Matrix. This conversion is done by reference.

```APIDOC
## From<&PackedGF2Matrix<T>> for GF2Matrix

### Description
Converts a reference to a `PackedGF2Matrix` into a `GF2Matrix`.

### Method
`From` trait implementation

### Parameters
- `int_matrix`: `&PackedGF2Matrix<T>` - A reference to the packed integer matrix to convert.

### Response
- `GF2Matrix` - The resulting GF2Matrix.

### Example
```rust
use lin_algebra::gf2_matrix::GF2Matrix;
use lin_algebra::packed_gf2_matrix::PackedGF2Matrix;

let packed_matrix = PackedGF2Matrix::<u8>::new(vec![0, 1, 2], 4);
let gf2_matrix = GF2Matrix::from(&packed_matrix);
```
```

--------------------------------

### Handle Non-Full Rank Linear Equation

Source: https://docs.rs/lin_algebra/0.4.1/src/lin_algebra/lib.rs.html

Tests the panic condition when attempting to solve a linear equation with a matrix that does not have full rank. Expects a panic with a specific message.

```rust
let left_elements = vec![vec![1, 0, 0], vec![0, 1, 1]];
let b = vec![0, 0, 1];
let m = GF2Matrix::new(left_elements);
m.solve(&b);
```

--------------------------------

### From<&GF2Matrix> for PackedGF2Matrix<T>

Source: https://docs.rs/lin_algebra/0.4.1/src/lin_algebra/convert.rs.html

Converts a reference to a GF2Matrix into a PackedGF2Matrix.

```APIDOC
## From<&GF2Matrix> for PackedGF2Matrix<T>

### Description
Converts a reference to a `GF2Matrix` into a `PackedGF2Matrix`.

### Method
`From` trait implementation

### Parameters
- `gf2_matrix`: `&GF2Matrix` - A reference to the GF2Matrix to convert.

### Response
- `PackedGF2Matrix<T>` - The resulting PackedGF2Matrix.

### Example
```rust
use lin_algebra::gf2_matrix::GF2Matrix;
use lin_algebra::packed_gf2_matrix::PackedGF2Matrix;

let gf2_matrix = GF2Matrix { elements: vec![vec![0, 1], vec![1, 0]] };
let packed_matrix = PackedGF2Matrix::<u8>::from(&gf2_matrix);
```
```

--------------------------------

### Test conversion from PackedGF2Matrix to GF2Matrix (owned)

Source: https://docs.rs/lin_algebra/0.4.1/src/lin_algebra/convert.rs.html

Tests the conversion of an owned PackedGF2Matrix to a GF2Matrix and verifies the resulting elements.

```rust
#[test]
    fn test_int_mtrix_to_gf2_matrix_convertion() {
        let elements = vec![0, 1, 2, 4, 8];
        let int_matrix = PackedGF2Matrix::<u8>::new(elements.clone(), 4);
        let gf2_matrix = GF2Matrix::from(int_matrix);
        let expected = vec![
            vec![0, 0, 0, 0],
            vec![0, 0, 0, 1],
            vec![0, 0, 1, 0],
            vec![0, 1, 0, 0],
            vec![1, 0, 0, 0],
        ];
        assert_eq!(gf2_matrix.elements, expected);

        let int_matrix = PackedGF2Matrix::<u8>::new(elements.clone(), 4);
        let gf2_matrix: GF2Matrix = int_matrix.into();
        assert_eq!(gf2_matrix.elements, expected);
    }
```

--------------------------------

### Matrix::new

Source: https://docs.rs/lin_algebra/0.4.1/lin_algebra/matrix/struct.Matrix.html

Constructs a new Matrix from a given nested vector of elements.

```APIDOC
## impl<T: Number> Matrix<T>

### pub fn new(elements: Vec<Vec<T>>) -> Self

Creates a new Matrix with the provided elements.
```

--------------------------------

### Convert from PackedGF2Matrix (by value)

Source: https://docs.rs/lin_algebra/0.4.1/lin_algebra/gf2_matrix/type.GF2Matrix.html

Converts a PackedGF2Matrix into a GF2Matrix.

```rust
fn from(int_matrix: PackedGF2Matrix<T>) -> Self
```

--------------------------------

### Convert PackedGF2Matrix to GF2Matrix (owned)

Source: https://docs.rs/lin_algebra/0.4.1/src/lin_algebra/convert.rs.html

Converts an owned PackedGF2Matrix into a GF2Matrix. Uses MSB bit order for conversion.

```rust
impl<T: Number> From<PackedGF2Matrix<T>> for GF2Matrix {
    fn from(int_matrix: PackedGF2Matrix<T>) -> Self {
        int_matrix.from_int_matrix_to_gf2_matrix(BitOrder::MSB)
    }
}
```

--------------------------------

### Solve Vector Equation A*x = b

Source: https://docs.rs/lin_algebra/0.4.1/src/lin_algebra/gf2_matrix.rs.html

Solves for vector x in the equation A*x = b, where A is a GF2Matrix and b is a vector of u8. Panics if the matrix A does not have full rank.

```rust
pub fn solve(&self, b: &Vec<u8>) -> Vec<u8> {
        // et mut y_copy = y.clone();
        if self.rank() < self.ncols() {
            panic!("Matrix must have full rank");
        }
        let (ech, operations) = self.echelon_form();
        let to_remove = ech.nrows() - ech.rank();
        let mut solved_b = Self::apply_operations(&operations, b);
        for _ in 0..to_remove {
            solved_b.remove(solved_b.len() - 1);
        }
        solved_b
    }
```

--------------------------------

### Kernel Method

Source: https://docs.rs/lin_algebra/0.4.1/lin_algebra/matrix/trait.MatrixTrait.html

Computes the kernel (or null space) of the matrix. The kernel is the set of all vectors that the matrix maps to the zero vector.

```rust
fn kernel(&self) -> Vec<Vec<T>>;
```

--------------------------------

### kernel

Source: https://docs.rs/lin_algebra/0.4.1/src/lin_algebra/gf2_matrix.rs.html

Computes the base of the kernel of the linear application represented by a GF(2) matrix.

```APIDOC
## kernel

### Description
Computes the base of the kernel of the linear application represented by a GF(2) matrix. If the matrix is not in reduced row echelon form (RREF), it first converts the matrix to its RREF before computing the kernel.

### Returns
A vector of row vectors, each representing a basis vector of the kernel.
```

--------------------------------

### Convert PackedGF2Matrix to GF2Matrix (borrowed)

Source: https://docs.rs/lin_algebra/0.4.1/src/lin_algebra/convert.rs.html

Converts a borrowed PackedGF2Matrix into a GF2Matrix. Uses MSB bit order for conversion.

```rust
impl<T: Number> From<&PackedGF2Matrix<T>> for GF2Matrix {
    fn from(int_matrix: &PackedGF2Matrix<T>) -> Self {
        int_matrix.from_int_matrix_to_gf2_matrix(BitOrder::MSB)
    }
}
```

--------------------------------

### Solve Matrix System with Linear Dependence

Source: https://docs.rs/lin_algebra/0.4.1/src/lin_algebra/lib.rs.html

Solves a matrix system AX = B over GF(2) where the matrix A has linearly dependent rows. The result is asserted against the expected solution.

```rust
let left_elements = vec![vec![1, 0, 0], vec![0, 1, 1], vec![1, 0, 1], vec![1, 1, 1]];
let right_elements = vec![vec![0, 0, 1], vec![0, 1, 1], vec![1, 1, 1], vec![1, 1, 0]];
let m = GF2Matrix::new(left_elements);
let rm = GF2Matrix::new(right_elements);
let r = m.solve_matrix_system(&rm);
assert_eq!(r.elements, vec![vec![0, 0, 1], vec![1, 0, 1], vec![1, 1, 0]]);
```

--------------------------------

### Matrix::solve (for u8)

Source: https://docs.rs/lin_algebra/0.4.1/lin_algebra/matrix/struct.Matrix.html

Solves a system of linear equations of the form A*x = b, where A is the current matrix and b is a vector.

```APIDOC
## impl Matrix<u8>

### pub fn solve(&self, b: &Vec<u8>) -> Vec<u8>

Solves for X such that equation A*x = b where A is a GF2Matrix and b a Vec.

#### Arguments
- `b`: Vec<u8> - The right-hand side vector such that self*x = b.

#### Returns
- Vec<u8>: Vector x such that self*x = b.
```

--------------------------------

### Convert Integer Matrix to GF2 Matrix (MSB)

Source: https://docs.rs/lin_algebra/0.4.1/src/lin_algebra/packed_gf2_matrix.rs.html

Converts an integer matrix representation to a GF(2) matrix, processing bits in Most Significant Bit (MSB) order. This is an alternative to LSB processing for different applications.

```rust
let elements = vec![0, 1, 2, 4, 8];
let int_matrix = PackedGF2Matrix::<u8>::new(elements.clone(), 4);
let gf2_matrix = int_matrix.from_int_matrix_to_gf2_matrix(BitOrder::MSB);
let expected = vec![
    vec![0, 0, 0, 0],
    vec![0, 0, 0, 1],
    vec![0, 0, 1, 0],
    vec![0, 1, 0, 0],
    vec![1, 0, 0, 0],
];
assert_eq!(gf2_matrix.elements, expected);
```

```rust
let elements = vec![0, 1, 2, 3, 5];
let int_matrix = PackedGF2Matrix::<u8>::new(elements.clone(), 4);
let gf2_matrix = int_matrix.from_int_matrix_to_gf2_matrix(BitOrder::MSB);
let expected = vec![
    vec![0, 0, 0, 0],
    vec![0, 0, 0, 1],
    vec![0, 0, 1, 0],
    vec![0, 0, 1, 1],
    vec![0, 1, 0, 1],
];
assert_eq!(gf2_matrix.elements, expected);
```

--------------------------------

### Create PackedGF2Matrix from Owned Vector

Source: https://docs.rs/lin_algebra/0.4.1/lin_algebra/packed_gf2_matrix/struct.PackedGF2Matrix.html

Creates a PackedGF2Matrix with a single row from an owned vector of row data. The number of columns is inferred from the vector's length. The input vector is moved.

```rust
let m = PackedGF2Matrix::new(vec![0b110u8, 0b101u8, 0b011u8], 3);
let (echelon, ops) = m.echelon_form();

assert_eq!(m.ncols(), 3);
```

--------------------------------

### Compute Kernel of GF(2) Matrix

Source: https://docs.rs/lin_algebra/0.4.1/src/lin_algebra/gf2_matrix.rs.html

Finds a basis for the kernel (null space) of the linear transformation represented by a GF(2) matrix. The computation is performed on the reduced row echelon form (RREF) of the matrix.

```rust
    /// Computes the base of the kernel of the linear applocation represented by a GF(2) matrix.
    ///
    /// If the matrix is not in reduced row echelon form (RREF),
    /// it first converts the matrix to its RREF before computing the kernel.
    ///
    /// # Returns
    /// A vector of row vectors, each representing a basis vector of the kernel.
    fn kernel(&self) -> Vec<Vec<u8>> {
        match self.is_reduced_echelon() {
            true => self.kernel_echelon_form(),
            false => {
                let (ech_form, _) = self.echelon_form();
                ech_form.kernel_echelon_form()
            }
        }
    }

```

--------------------------------

### Create PackedGF2Matrix from a vector

Source: https://docs.rs/lin_algebra/0.4.1/src/lin_algebra/packed_gf2_matrix.rs.html

Constructs a PackedGF2Matrix from a vector of elements. The number of columns is determined by the vector's length.

```rust
pub fn from_vec(vect: Vec<T>) -> Self {
        let n = vect.len();
        Self {
            elements: vect,
            n: n,
        }
    }
```

--------------------------------

### Create PackedGF2Matrix from a referenced vector

Source: https://docs.rs/lin_algebra/0.4.1/src/lin_algebra/packed_gf2_matrix.rs.html

Creates a PackedGF2Matrix from a reference to a vector. The internal storage is a clone of the input vector, and the number of columns is inferred from the vector's length.

```rust
pub fn from_vec_referenced(vect: &Vec<T>) -> Self {
        let n = vect.len();
        Self {
            elements: vect.to_vec(),
            n: n,
        }
    }
```

--------------------------------

### Copy Implementation for BitOrder

Source: https://docs.rs/lin_algebra/0.4.1/lin_algebra/packed_gf2_matrix/enum.BitOrder.html

Indicates that BitOrder is a Copy type, meaning it can be copied implicitly.

```APIDOC
### impl Copy for BitOrder
```

--------------------------------

### MatrixCommon Trait Methods

Source: https://docs.rs/lin_algebra/0.4.1/lin_algebra/matrix/trait.MatrixCommon.html

This snippet details the required and provided methods for the MatrixCommon trait.

```APIDOC
## Trait MatrixCommon

### Required Methods

#### fn nrows(&self) -> usize
Returns the number of rows in the matrix.

#### fn ncols(&self) -> usize
Returns the number of columns in the matrix.

#### fn row(&self, r: usize) -> &[T]
Returns a slice representing the specified row `r` of the matrix.

### Provided Methods

#### fn get_pivot(row: &[T]) -> Option<usize>
Finds the index of the first non-zero element (pivot) in a given row. Returns `None` if the row is all zeros.
```

--------------------------------

### Clone From Matrix

Source: https://docs.rs/lin_algebra/0.4.1/lin_algebra/matrix/struct.Matrix.html

Performs copy-assignment from a source Matrix into the current one.

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

--------------------------------

### Calculate Rank from Echelon Form

Source: https://docs.rs/lin_algebra/0.4.1/src/lin_algebra/gf2_matrix.rs.html

Calculates the rank of a GF2Matrix by counting pivot columns in its echelon form.

```rust
fn rank_echelon_form(&self) -> usize {
        let mut count = 0;
        let mut pivot_columns = std::collections::HashSet::new();

        for i in 0..self.nrows() {
            let p = GF2Matrix::get_pivot(&self.elements[i]);
            if let Some(col) = p {
                if pivot_columns.insert(col) {
                    count += 1;
                }
            }
        }
        count
    }
```

--------------------------------

### Create PackedGF2Matrix

Source: https://docs.rs/lin_algebra/0.4.1/lin_algebra/packed_gf2_matrix/struct.PackedGF2Matrix.html

Creates a new integer-encoded matrix from a vector of row elements and the number of columns.

```rust
let m = PackedGF2Matrix::new(vec![0b1011u8, 0b0101u8], 4);
```

--------------------------------

### Number Trait Implementations

Source: https://docs.rs/lin_algebra/0.4.1/lin_algebra/matrix/trait.Number.html

Shows implementations of the Number trait for unsigned integer types like u8, u16, u32, and u64.

```rust
impl Number for u8
Source
```

```rust
fn into_usize(self) -> usize
Source
```

```rust
impl Number for u16
Source
```

```rust
fn into_usize(self) -> usize
Source
```

```rust
impl Number for u32
Source
```

```rust
fn into_usize(self) -> usize
Source
```

```rust
impl Number for u64
Source
```

```rust
fn into_usize(self) -> usize
Source
```

--------------------------------

### Into Conversion

Source: https://docs.rs/lin_algebra/0.4.1/lin_algebra/matrix/struct.Matrix.html

Calls `U::from(self)` to convert the value into type U.

```rust
fn into(self) -> U
```

--------------------------------

### Convert GF2Matrix to PackedGF2Matrix (borrowed)

Source: https://docs.rs/lin_algebra/0.4.1/src/lin_algebra/convert.rs.html

Converts a borrowed GF2Matrix into a PackedGF2Matrix. Each row of the GF2Matrix is converted to a numerical type T using MSB ordering.

```rust
impl<T: Number> From<&GF2Matrix> for PackedGF2Matrix<T>
where
    T: Number + From<usize>,
{
    fn from(gf2_matrix: &GF2Matrix) -> Self {
        let ve: Vec<T> = gf2_matrix
            .elements
            .iter()
            .map(|row| Matrix::<T>::from_vec_to_int_msb(&row))
            .collect();
        Self::from_vec(ve)
    }
}
```

--------------------------------

### Clone Matrix

Source: https://docs.rs/lin_algebra/0.4.1/lin_algebra/matrix/struct.Matrix.html

Returns a duplicate of the Matrix value.

```rust
fn clone(&self) -> Matrix<T>
```

--------------------------------

### Convert GF2Matrix to PackedGF2Matrix (owned)

Source: https://docs.rs/lin_algebra/0.4.1/src/lin_algebra/convert.rs.html

Converts an owned GF2Matrix into a PackedGF2Matrix. Each row of the GF2Matrix is converted to a numerical type T using MSB ordering.

```rust
impl<T: Number> From<GF2Matrix> for PackedGF2Matrix<T>
where
    T: Number + From<usize>,
{
    fn from(gf2_matrix: GF2Matrix) -> Self {
        let ve: Vec<T> = gf2_matrix
            .elements
            .iter()
            .map(|row| Matrix::<T>::from_vec_to_int_msb(&row))
            .collect();
        Self::from_vec(ve)
    }
}
```

--------------------------------

### From<&Vec<T>> for PackedGF2Matrix<T>

Source: https://docs.rs/lin_algebra/0.4.1/src/lin_algebra/convert.rs.html

Converts a reference to a vector of numbers into a PackedGF2Matrix.

```APIDOC
## From<&Vec<T>> for PackedGF2Matrix<T>

### Description
Converts a reference to a vector of numbers into a `PackedGF2Matrix`.

### Method
`From` trait implementation

### Parameters
- `value`: `&Vec<T>` - A reference to the vector of numbers to convert.

### Response
- `PackedGF2Matrix<T>` - The resulting PackedGF2Matrix.

### Example
```rust
use lin_algebra::packed_gf2_matrix::PackedGF2Matrix;

let elements = vec![0u8, 1, 2, 4];
let packed_matrix = PackedGF2Matrix::<u8>::from(&elements);
```
```

--------------------------------

### Create PackedGF2Matrix from Referenced Vector

Source: https://docs.rs/lin_algebra/0.4.1/lin_algebra/packed_gf2_matrix/struct.PackedGF2Matrix.html

Creates a PackedGF2Matrix with a single row from a referenced vector of row data. The number of columns is inferred from the vector's length. The input vector is cloned.

```rust
let rows = vec![0b1010u8, 0b0110u8];
let m = PackedGF2Matrix::from_vec_referenced(&rows);

assert_eq!(m.ncols(), 2);
```

--------------------------------

### Format Matrix for Debug

Source: https://docs.rs/lin_algebra/0.4.1/lin_algebra/matrix/struct.Matrix.html

Formats the Matrix value for debugging output using the given formatter.

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

--------------------------------

### TryFrom Conversion

Source: https://docs.rs/lin_algebra/0.4.1/lin_algebra/matrix/struct.Matrix.html

Performs the conversion from type U to type T.

```rust
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
```

--------------------------------

### Convert to GF2Matrix with LSB Bit Order

Source: https://docs.rs/lin_algebra/0.4.1/lin_algebra/packed_gf2_matrix/struct.PackedGF2Matrix.html

Converts the integer-encoded matrix to an explicit GF(2) matrix with the least significant bit first.

```rust
let m = PackedGF2Matrix::new(vec![0b0010u8], 4);
let gf2 = m.from_int_matrix_to_gf2_matrix(BitOrder::LSB);

// Result: [[0, 1, 0, 0]]
```

--------------------------------

### Convert PackedGF2Matrix to GF2Matrix (MSB)

Source: https://docs.rs/lin_algebra/0.4.1/src/lin_algebra/packed_gf2_matrix.rs.html

Converts an integer-encoded matrix to an explicit GF(2) matrix, interpreting bits from most significant to least significant.

```rust
let m = PackedGF2Matrix::new(vec![0b0010u8], 4);
let gf2 = m.from_int_matrix_to_gf2_matrix(BitOrder::MSB);
```

--------------------------------

### TryInto Conversion

Source: https://docs.rs/lin_algebra/0.4.1/lin_algebra/matrix/struct.Matrix.html

Performs the conversion from type T to type U.

```rust
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
```

--------------------------------

### Check if GF(2) Matrix is in Reduced Row Echelon Form

Source: https://docs.rs/lin_algebra/0.4.1/src/lin_algebra/gf2_matrix.rs.html

Verifies if a GF(2) matrix adheres to the properties of reduced row echelon form (RREF). Ensures pivots are leading ones and are the only non-zero entry in their respective columns, and that zero rows are at the bottom.

```rust
impl MatrixTrait<u8> for GF2Matrix {
    /// Checks if a GF(2) matrix is in reduced row echelon form (RREF).
    ///
    /// # Returns
    /// `true` if the matrix is in reduced row echelon form; otherwise, `false`.
    fn is_reduced_echelon(&self) -> bool {
        let nrows = self.nrows();
        let mut old_piv = 0;
        let mut found_zero_row = false;
        for i in 0..nrows {
            let piv = GF2Matrix::get_pivot(&self.elements[i]);
            match piv {
                None => {
                    found_zero_row = true;
                    continue;
                }
                Some(piv) => {
                    if piv < old_piv || found_zero_row == true {
                        return false;
                    }
                    for j in 0..nrows {
                        if j != i && self.elements[j][piv] != 0 {
                            return false;
                        }
                    }
                    old_piv = piv;
                }
            }
        }
        return true;
    }

```

--------------------------------

### From<Vec<T>> for PackedGF2Matrix<T>

Source: https://docs.rs/lin_algebra/0.4.1/src/lin_algebra/convert.rs.html

Converts a vector of numbers into a PackedGF2Matrix.

```APIDOC
## From<Vec<T>> for PackedGF2Matrix<T>

### Description
Converts a vector of numbers into a `PackedGF2Matrix`.

### Method
`From` trait implementation

### Parameters
- `value`: `Vec<T>` - The vector of numbers to convert.

### Response
- `PackedGF2Matrix<T>` - The resulting PackedGF2Matrix.

### Example
```rust
use lin_algebra::packed_gf2_matrix::PackedGF2Matrix;

let elements = vec![0u8, 1, 2, 4];
let packed_matrix: PackedGF2Matrix<u8> = elements.into();
```
```

--------------------------------

### Check Reduced Echelon Form with Zero Rows

Source: https://docs.rs/lin_algebra/0.4.1/src/lin_algebra/lib.rs.html

Tests the `is_reduced_echelon` method when zero rows are present in the matrix. Demonstrates how zero rows affect the reduced echelon form property.

```rust
assert_eq!(GF2Matrix::new(vec![vec![0, 0, 0, 0], vec![1, 0, 0, 0], vec![0, 1, 0, 1]]).is_reduced_echelon(), false);
assert_eq!(GF2Matrix::new(vec![vec![1, 0, 0, 0], vec![0, 0, 0, 0], vec![0, 1, 0, 1]]).is_reduced_echelon(), false);
assert_eq!(GF2Matrix::new(vec![vec![1, 0, 1, 0], vec![0, 0, 0, 0]]).is_reduced_echelon(), true);
```

--------------------------------

### Calculate Image Basis of GF2Matrix

Source: https://docs.rs/lin_algebra/0.4.1/src/lin_algebra/gf2_matrix.rs.html

Computes the image basis of a GF2Matrix. It first converts the matrix to its Reduced Row Echelon Form (RREF) if it's not already, then identifies basis vectors from rows with pivots.

```rust
fn image(&self) -> Vec<Vec<u8>> {
        let mat = if !self.is_reduced_echelon() {
            let (m, _) = self.echelon_form();
            m
        } else {
            self.clone()
        };
        let mut image_base: Vec<Vec<u8>> = Vec::new();
        for i in 0..mat.nrows() {
            let row = mat.elements[i].clone();
            let piv = GF2Matrix::get_pivot(&row);
            if !piv.is_none() {
                image_base.push(row);
            }
        }
        image_base
    }
```

--------------------------------

### Rank Method

Source: https://docs.rs/lin_algebra/0.4.1/lin_algebra/matrix/trait.MatrixTrait.html

Calculates the rank of the matrix. The rank is the dimension of the vector space spanned by its columns (or rows).

```rust
fn rank(&self) -> usize;
```

--------------------------------

### MatrixCommon Trait

Source: https://docs.rs/lin_algebra/0.4.1/src/lin_algebra/matrix.rs.html

Provides common methods for matrix operations.

```APIDOC
pub trait MatrixCommon<T: Number> {
    fn nrows(&self) -> usize;
    fn ncols(&self) -> usize;
    fn row(&self, r: usize) -> &[T];
    fn get_pivot(row: &[T]) -> Option<usize>;
}
```

--------------------------------

### PackedGF2Matrix::from_int_matrix_to_gf2_matrix

Source: https://docs.rs/lin_algebra/0.4.1/lin_algebra/packed_gf2_matrix/struct.PackedGF2Matrix.html

Converts the packed matrix into an explicit GF(2) matrix with a specified bit order.

```APIDOC
## PackedGF2Matrix::from_int_matrix_to_gf2_matrix

### Description
Converts the integer-encoded matrix into an explicit GF(2) matrix. Each row is expanded into a vector of bits (`0` or `1`), according to the specified bit order.

### Bit Order
* `BitOrder::LSB`: the least-significant bit is placed first (column 0 corresponds to bit 0).
* `BitOrder::MSB`: the most-significant bit is placed first (column 0 corresponds to bit `n - 1`).

### Returns
A `GF2Matrix` whose entries are elements of GF(2), represented as `u8` values (`0` or `1`).

### Example
```rust
let m = PackedGF2Matrix::new(vec![0b0010u8], 4);
let gf2 = m.from_int_matrix_to_gf2_matrix(BitOrder::LSB);

// Result: [[0, 1, 0, 0]]
```
```

--------------------------------

### Compute Row Echelon Form over GF(2)

Source: https://docs.rs/lin_algebra/0.4.1/src/lin_algebra/packed_gf2_matrix.rs.html

Calculates the row echelon form of a PackedGF2Matrix over GF(2). It returns the transformed matrix and a list of elementary row operations performed. The original matrix is not modified.

```rust
pub fn echelon_form(&self) -> (Self, Vec<(usize, usize)>) {
        let mut m_copy = self.clone();
        let mut lead = 0;
        let mut operations: Vec<(usize, usize)> = Vec::new();
        for r in 0..self.nrows() {
            if lead >= self.ncols() {
                break;
            }
            let mut i = r;
            while m_copy.get_element(i, lead) == 0 {
                i += 1;
                if i == self.nrows() {
                    i = r;
                    lead += 1;
                    if lead == self.ncols() {
                        return (m_copy, operations);
                    }
                }
            }
            m_copy.swap_rows(r, i);
            if r != i {
                operations.push((r, i));
                operations.push((i, r));
                operations.push((r, i));
            }
            for i in 0..self.nrows() {

```
Tokens:
Raw