graphblassparselinear_algebra

Rust wrapper for SuiteSparse:GraphBLAS

Minimum example

```rust use graphblassparselinearalgebra::collections::Collection; use graphblassparselinearalgebra::context::{Context, Mode}; use graphblassparselinearalgebra::operators::apply::{BinaryOperatorApplier, ApplyBinaryOperator}; use graphblassparselinearalgebra::operators::binaryoperator::{Assignment, First}; use graphblassparselinearalgebra::operators::{binaryoperator::BinaryOperator, options::OperatorOptions}; use graphblassparselinearalgebra::operators::mask::{MatrixMask, SelectEntireMatrix}; use graphblassparselinearalgebra::collections::sparsematrix::{ FromMatrixElementList, GetMatrixElementValue, MatrixElementList, Size, SparseMatrix }; use graphblassparselinearalgebra::collections::sparsescalar::SparseScalar; use graphblassparselinearalgebra::collections::sparsevector::{ FromVectorElementList, GetVectorElementValue, VectorElementList, };

fn main() { let context = Context::init_ready(Mode::NonBlocking).unwrap();

let element_list = MatrixElementList::<u8>::from_element_vector(vec![
    (1, 1, 1).into(),
    (2, 1, 2).into(),
    (4, 2, 4).into(),
    (5, 2, 5).into(),
]);

let matrix_size: Size = (10, 15).into();
let matrix = SparseMatrix::<u8>::from_element_list(
    &context.to_owned(),
    &matrix_size,
    &element_list,
    &First::<u8>::new(),
)
.unwrap();

let mut product_matrix = SparseMatrix::<u8>::new(&context, &matrix_size).unwrap();

let operator = BinaryOperatorApplier::new(
);
let first_agrument = 10;
operator
    .apply_with_matrix_as_left_argument(
        &matrix, &First::<u8>::new(), 
        &first_agrument, 
        &Assignment::new(), 
        &mut product_matrix,
        &SelectEntireMatrix::new(&context),
        &OperatorOptions::new_default())
    .unwrap();

println!("{}", product_matrix);

assert_eq!(product_matrix.number_of_stored_elements().unwrap(), 4);
assert_eq!(product_matrix.get_element_value(&(2, 1).into()).unwrap(), Some(2));
assert_eq!(product_matrix.get_element_value(&(9, 1).into()).unwrap(), None);

let operator = BinaryOperatorApplier::new();
let second_agrument = 10;
operator
    .apply_with_matrix_as_right_argument(
        &second_agrument,
        &First::<u8>::new(), 
        &matrix, 
        &Assignment::new(),
        &mut product_matrix,
        &SelectEntireMatrix::new(&context),
        &OperatorOptions::new_default())
    .unwrap();

println!("{}", matrix);
println!("{}", product_matrix);

assert_eq!(product_matrix.number_of_stored_elements().unwrap(), 4);
assert_eq!(
    product_matrix.get_element_value(&(2, 1).into()).unwrap(),
    Some(10)
);
assert_eq!(product_matrix.get_element_value(&(9, 1).into()).unwrap(), None);

} ```

Dependencies

graphblassparselinear_algebra uses the SuiteSparse:GraphBLAS implementation developed by Timothy A. Davis.

Building from source

Please make sure to meet the requirements for building suitesparsegraphblassys.

Compatibility

graphblassparselinear_algebra is mostly compatible with the GraphBLAS specification version 2.0 and uses SuiteSparse:GraphBLAS v7.3.0.

Contributing

Awesome, contributions are welcome. Graphblassparselinear_algebra and your contribution may be relicensed and integrated into commercial software in the future. Therefore, you will be asked to agree to the Contributor License Agreement when you make a pull request.

Licensing

graphblassparselinear_algebra is licensed under Creative Commons Attribution Non Commercial 4.0 International. For other licensing options, please contact Sam Dekker.