Struct SparseMatrixF32 

pub struct SparseMatrixF32 { /* private fields */ }

Owned sparse single-precision matrix handle backed by the Swift bridge.

Implementations

impl SparseMatrixF32

pub fn new(rows: usize, columns: usize) -> Option<Self>

Creates a sparse single-precision matrix with sparse_matrix_create_float.

Examples found in repository

examples/07_sparse_linear_algebra.rs (line 24)

fn main() {
    let values = [2.0_f32, 4.0];
    let indices = [0_i64, 2_i64];
    let dense = [1.0_f32, 2.0, 3.0];
    let dot = sparse_dot_dense_f32(&values, &indices, &dense).expect("dense dot");
    assert!((dot - 14.0).abs() < 1.0e-6);

    let sparse_dot = sparse_dot_sparse_f32(&values, &indices, &[3.0_f32, 5.0], &[0_i64, 2_i64])
        .expect("sparse dot");
    assert!((sparse_dot - 26.0).abs() < 1.0e-6);

    let mut accum = vec![10.0_f32, 10.0, 10.0];
    sparse_add_to_dense_f32(&values, &indices, 0.5, &mut accum).expect("accumulate");
    assert!(accum
        .iter()
        .zip([11.0_f32, 10.0, 12.0])
        .all(|(actual, expected)| (*actual - expected).abs() < 1.0e-6));

    let mut matrix = SparseMatrixF32::new(2, 2).expect("matrix");
    matrix
        .set_property(sparse_matrix_property::LOWER_TRIANGULAR)
        .expect("property");
    matrix.insert_entry(0, 0, 2.0).expect("a00");
    matrix.insert_entry(1, 0, 1.0).expect("a10");
    matrix.insert_entry(1, 1, 3.0).expect("a11");
    matrix.commit().expect("commit");

    let mut rhs = [2.0_f32, 7.0];
    matrix
        .triangular_solve_vector(blas_transpose::NO_TRANS, 1.0, &mut rhs)
        .expect("solve vector");
    assert!(rhs
        .iter()
        .zip([1.0_f32, 2.0])
        .all(|(actual, expected)| (*actual - expected).abs() < 1.0e-6));

    println!("sparse smoke passed: dot={dot} accum={accum:?} solve={rhs:?}");
}

pub fn set_property(&mut self, property: i32) -> Result<()>

Sets a sparse_matrix_property on the matrix with sparse_set_matrix_property.

Examples found in repository

examples/07_sparse_linear_algebra.rs (line 26)

fn main() {
    let values = [2.0_f32, 4.0];
    let indices = [0_i64, 2_i64];
    let dense = [1.0_f32, 2.0, 3.0];
    let dot = sparse_dot_dense_f32(&values, &indices, &dense).expect("dense dot");
    assert!((dot - 14.0).abs() < 1.0e-6);

    let sparse_dot = sparse_dot_sparse_f32(&values, &indices, &[3.0_f32, 5.0], &[0_i64, 2_i64])
        .expect("sparse dot");
    assert!((sparse_dot - 26.0).abs() < 1.0e-6);

    let mut accum = vec![10.0_f32, 10.0, 10.0];
    sparse_add_to_dense_f32(&values, &indices, 0.5, &mut accum).expect("accumulate");
    assert!(accum
        .iter()
        .zip([11.0_f32, 10.0, 12.0])
        .all(|(actual, expected)| (*actual - expected).abs() < 1.0e-6));

    let mut matrix = SparseMatrixF32::new(2, 2).expect("matrix");
    matrix
        .set_property(sparse_matrix_property::LOWER_TRIANGULAR)
        .expect("property");
    matrix.insert_entry(0, 0, 2.0).expect("a00");
    matrix.insert_entry(1, 0, 1.0).expect("a10");
    matrix.insert_entry(1, 1, 3.0).expect("a11");
    matrix.commit().expect("commit");

    let mut rhs = [2.0_f32, 7.0];
    matrix
        .triangular_solve_vector(blas_transpose::NO_TRANS, 1.0, &mut rhs)
        .expect("solve vector");
    assert!(rhs
        .iter()
        .zip([1.0_f32, 2.0])
        .all(|(actual, expected)| (*actual - expected).abs() < 1.0e-6));

    println!("sparse smoke passed: dot={dot} accum={accum:?} solve={rhs:?}");
}

pub fn insert_entry( &mut self, row: usize, column: usize, value: f32, ) -> Result<()>

Inserts one matrix entry with sparse_insert_entry_float.

Examples found in repository

examples/07_sparse_linear_algebra.rs (line 28)

fn main() {
    let values = [2.0_f32, 4.0];
    let indices = [0_i64, 2_i64];
    let dense = [1.0_f32, 2.0, 3.0];
    let dot = sparse_dot_dense_f32(&values, &indices, &dense).expect("dense dot");
    assert!((dot - 14.0).abs() < 1.0e-6);

    let sparse_dot = sparse_dot_sparse_f32(&values, &indices, &[3.0_f32, 5.0], &[0_i64, 2_i64])
        .expect("sparse dot");
    assert!((sparse_dot - 26.0).abs() < 1.0e-6);

    let mut accum = vec![10.0_f32, 10.0, 10.0];
    sparse_add_to_dense_f32(&values, &indices, 0.5, &mut accum).expect("accumulate");
    assert!(accum
        .iter()
        .zip([11.0_f32, 10.0, 12.0])
        .all(|(actual, expected)| (*actual - expected).abs() < 1.0e-6));

    let mut matrix = SparseMatrixF32::new(2, 2).expect("matrix");
    matrix
        .set_property(sparse_matrix_property::LOWER_TRIANGULAR)
        .expect("property");
    matrix.insert_entry(0, 0, 2.0).expect("a00");
    matrix.insert_entry(1, 0, 1.0).expect("a10");
    matrix.insert_entry(1, 1, 3.0).expect("a11");
    matrix.commit().expect("commit");

    let mut rhs = [2.0_f32, 7.0];
    matrix
        .triangular_solve_vector(blas_transpose::NO_TRANS, 1.0, &mut rhs)
        .expect("solve vector");
    assert!(rhs
        .iter()
        .zip([1.0_f32, 2.0])
        .all(|(actual, expected)| (*actual - expected).abs() < 1.0e-6));

    println!("sparse smoke passed: dot={dot} accum={accum:?} solve={rhs:?}");
}

pub fn commit(&mut self) -> Result<()>

Finalizes pending sparse edits with sparse_commit.

Examples found in repository

examples/07_sparse_linear_algebra.rs (line 31)

fn main() {
    let values = [2.0_f32, 4.0];
    let indices = [0_i64, 2_i64];
    let dense = [1.0_f32, 2.0, 3.0];
    let dot = sparse_dot_dense_f32(&values, &indices, &dense).expect("dense dot");
    assert!((dot - 14.0).abs() < 1.0e-6);

    let sparse_dot = sparse_dot_sparse_f32(&values, &indices, &[3.0_f32, 5.0], &[0_i64, 2_i64])
        .expect("sparse dot");
    assert!((sparse_dot - 26.0).abs() < 1.0e-6);

    let mut accum = vec![10.0_f32, 10.0, 10.0];
    sparse_add_to_dense_f32(&values, &indices, 0.5, &mut accum).expect("accumulate");
    assert!(accum
        .iter()
        .zip([11.0_f32, 10.0, 12.0])
        .all(|(actual, expected)| (*actual - expected).abs() < 1.0e-6));

    let mut matrix = SparseMatrixF32::new(2, 2).expect("matrix");
    matrix
        .set_property(sparse_matrix_property::LOWER_TRIANGULAR)
        .expect("property");
    matrix.insert_entry(0, 0, 2.0).expect("a00");
    matrix.insert_entry(1, 0, 1.0).expect("a10");
    matrix.insert_entry(1, 1, 3.0).expect("a11");
    matrix.commit().expect("commit");

    let mut rhs = [2.0_f32, 7.0];
    matrix
        .triangular_solve_vector(blas_transpose::NO_TRANS, 1.0, &mut rhs)
        .expect("solve vector");
    assert!(rhs
        .iter()
        .zip([1.0_f32, 2.0])
        .all(|(actual, expected)| (*actual - expected).abs() < 1.0e-6));

    println!("sparse smoke passed: dot={dot} accum={accum:?} solve={rhs:?}");
}

pub fn rows(&self) -> Result<usize>

Returns the row count reported by sparse_get_matrix_number_of_rows.

pub fn columns(&self) -> Result<usize>

Returns the column count reported by sparse_get_matrix_number_of_columns.

pub fn nonzero_count(&self) -> Result<usize>

Returns the nonzero count reported by sparse_get_matrix_nonzero_count.

pub fn triangular_solve_vector( &self, transpose: i32, alpha: f32, values: &mut [f32], ) -> Result<()>

Solves a sparse triangular system against a dense vector with sparse_vector_triangular_solve_dense_float.

Examples found in repository

examples/07_sparse_linear_algebra.rs (line 35)

fn main() {
    let values = [2.0_f32, 4.0];
    let indices = [0_i64, 2_i64];
    let dense = [1.0_f32, 2.0, 3.0];
    let dot = sparse_dot_dense_f32(&values, &indices, &dense).expect("dense dot");
    assert!((dot - 14.0).abs() < 1.0e-6);

    let sparse_dot = sparse_dot_sparse_f32(&values, &indices, &[3.0_f32, 5.0], &[0_i64, 2_i64])
        .expect("sparse dot");
    assert!((sparse_dot - 26.0).abs() < 1.0e-6);

    let mut accum = vec![10.0_f32, 10.0, 10.0];
    sparse_add_to_dense_f32(&values, &indices, 0.5, &mut accum).expect("accumulate");
    assert!(accum
        .iter()
        .zip([11.0_f32, 10.0, 12.0])
        .all(|(actual, expected)| (*actual - expected).abs() < 1.0e-6));

    let mut matrix = SparseMatrixF32::new(2, 2).expect("matrix");
    matrix
        .set_property(sparse_matrix_property::LOWER_TRIANGULAR)
        .expect("property");
    matrix.insert_entry(0, 0, 2.0).expect("a00");
    matrix.insert_entry(1, 0, 1.0).expect("a10");
    matrix.insert_entry(1, 1, 3.0).expect("a11");
    matrix.commit().expect("commit");

    let mut rhs = [2.0_f32, 7.0];
    matrix
        .triangular_solve_vector(blas_transpose::NO_TRANS, 1.0, &mut rhs)
        .expect("solve vector");
    assert!(rhs
        .iter()
        .zip([1.0_f32, 2.0])
        .all(|(actual, expected)| (*actual - expected).abs() < 1.0e-6));

    println!("sparse smoke passed: dot={dot} accum={accum:?} solve={rhs:?}");
}

pub fn triangular_solve_matrix_row_major( &self, transpose: i32, rhs_columns: usize, alpha: f32, values: &mut [f32], ) -> Result<()>

Solves a sparse triangular system against a row-major dense matrix with sparse_matrix_triangular_solve_dense_float.

Trait Implementations

impl Drop for SparseMatrixF32

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl Send for SparseMatrixF32

impl Sync for SparseMatrixF32