Merge pull request #1017 from losanc/matrixmarket-io
added reading matrix market data to sparse coomatrix
This commit is contained in:
Sébastien Crozet
GitHub
commit
1576a1517a
|
|
@ -71,10 +71,10 @@ jobs:
|
|||
- name: test nalgebra-sparse
|
||||
# Manifest-path is necessary because cargo otherwise won't correctly forward features
|
||||
# We increase number of proptest cases to hopefully catch more potential bugs
|
||||
run: PROPTEST_CASES=10000 cargo test --manifest-path=nalgebra-sparse/Cargo.toml --features compare,proptest-support
|
||||
run: PROPTEST_CASES=10000 cargo test --manifest-path=nalgebra-sparse/Cargo.toml --features compare,proptest-support,io
|
||||
- name: test nalgebra-sparse (slow tests)
|
||||
# Unfortunately, the "slow-tests" take so much time that we need to run them with --release
|
||||
run: PROPTEST_CASES=10000 cargo test --release --manifest-path=nalgebra-sparse/Cargo.toml --features compare,proptest-support,slow-tests slow
|
||||
run: PROPTEST_CASES=10000 cargo test --release --manifest-path=nalgebra-sparse/Cargo.toml --features compare,proptest-support,io,slow-tests slow
|
||||
test-nalgebra-macros:
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
|
|
|
|||
|
|
@ -16,6 +16,9 @@ license = "Apache-2.0"
|
|||
proptest-support = ["proptest", "nalgebra/proptest-support"]
|
||||
compare = [ "matrixcompare-core" ]
|
||||
|
||||
# Enable matrix market I/O
|
||||
io = [ "pest", "pest_derive" ]
|
||||
|
||||
# Enable to enable running some tests that take a lot of time to run
|
||||
slow-tests = []
|
||||
|
||||
|
|
@ -24,6 +27,8 @@ nalgebra = { version="0.29", path = "../" }
|
|||
num-traits = { version = "0.2", default-features = false }
|
||||
proptest = { version = "1.0", optional = true }
|
||||
matrixcompare-core = { version = "0.1.0", optional = true }
|
||||
pest = { version = "2", optional = true }
|
||||
pest_derive = { version = "2", optional = true }
|
||||
|
||||
[dev-dependencies]
|
||||
itertools = "0.10"
|
||||
|
|
|
|||
|
|
@ -0,0 +1,53 @@
|
|||
WHITESPACE = _{ " "|"\t" }
|
||||
|
||||
//
|
||||
|
||||
Sparsity = {^"coordinate" | ^"array"}
|
||||
DataType = {^"real" | ^"complex" | ^"pattern" | ^"integer" }
|
||||
StorageScheme = {^"symmetric" | ^"general" | ^"skew-symmetric" | ^"hermitian"}
|
||||
// Only consider matrices here.
|
||||
Header = { ^"%%matrixmarket matrix" ~ Sparsity ~ DataType ~ StorageScheme }
|
||||
|
||||
//
|
||||
|
||||
Comments = _{ "%" ~ (!NEWLINE ~ ANY)* }
|
||||
|
||||
//
|
||||
|
||||
Dimension = @{ ASCII_DIGIT+ }
|
||||
SparseShape = { Dimension ~ Dimension ~ Dimension}
|
||||
DenseShape = { Dimension ~ Dimension}
|
||||
Shape = {SparseShape | DenseShape }
|
||||
|
||||
//
|
||||
|
||||
// grammar from https://doc.rust-lang.org/std/primitive.f64.html#grammar
|
||||
|
||||
Sign = {("+" | "-")}
|
||||
Exp = @{ ^"e" ~ Sign? ~ ASCII_DIGIT+}
|
||||
Number = @{ ((ASCII_DIGIT+ ~ "." ~ ASCII_DIGIT*) | (ASCII_DIGIT* ~ "." ~ASCII_DIGIT+) | ASCII_DIGIT+ ) ~ Exp? }
|
||||
Real = @{ Sign? ~ ("inf" | "NaN" | Number) }
|
||||
|
||||
|
||||
SparseReal = {Dimension~ Dimension~ Real }
|
||||
SparseComplex = {Dimension ~ Dimension ~ Real ~ Real}
|
||||
SparsePattern = {Dimension ~ Dimension}
|
||||
|
||||
DenseReal = {Real}
|
||||
DenseComplex = {Real ~ Real}
|
||||
|
||||
|
||||
Entry = { SparseComplex | SparseReal | SparsePattern | DenseComplex | DenseReal }
|
||||
|
||||
// end of file, a silent way, see https://github.com/pest-parser/pest/issues/304#issuecomment-427198507
|
||||
eoi = _{ !ANY }
|
||||
|
||||
Document = {
|
||||
SOI ~
|
||||
NEWLINE* ~
|
||||
Header ~
|
||||
(NEWLINE ~ Comments)* ~
|
||||
(NEWLINE ~ Shape) ~
|
||||
(NEWLINE ~ Entry?)* ~
|
||||
eoi
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,38 @@
|
|||
//! Functionality for importing and exporting sparse matrices to and from files.
|
||||
//!
|
||||
//! **Available only when the `io` feature is enabled.**
|
||||
//!
|
||||
//! The following formats are currently supported:
|
||||
//!
|
||||
//! | Format | Import | Export |
|
||||
//! | ------------------------------------------------|------------|------------|
|
||||
//! | [Matrix market](#matrix-market-format) | Yes | No |
|
||||
//!
|
||||
//! [Matrix market]: https://math.nist.gov/MatrixMarket/formats.html
|
||||
//!
|
||||
//! ## Matrix Market format
|
||||
//!
|
||||
//! The Matrix Market format is a simple ASCII-based file format for sparse matrices, and was initially developed for
|
||||
//! the [NIST Matrix Market](https://math.nist.gov/MatrixMarket/), a repository of example sparse matrices.
|
||||
//! In later years it has largely been superseded by the
|
||||
//! [SuiteSparse Matrix Collection](https://sparse.tamu.edu/) (formerly University of Florida Sparse Matrix Collection),
|
||||
//! which also uses the Matrix Market file format.
|
||||
//!
|
||||
//! We currently offer functionality for importing a Matrix market file to an instance of a
|
||||
//! [CooMatrix](crate::CooMatrix) through the function [load_coo_from_matrix_market_file]. It is also possible to load
|
||||
//! a matrix stored in the matrix market format with the function [load_coo_from_matrix_market_str].
|
||||
//!
|
||||
//! Export is currently not implemented, but [planned](https://github.com/dimforge/nalgebra/issues/1037).
|
||||
//!
|
||||
//! Our implementation is based on the [format description](https://math.nist.gov/MatrixMarket/formats.html)
|
||||
//! on the Matrix Market website and the
|
||||
//! [following NIST whitepaper](https://math.nist.gov/MatrixMarket/reports/MMformat.ps):
|
||||
//!
|
||||
//! > Boisvert, Ronald F., Roldan Pozo, and Karin A. Remington.<br/>
|
||||
//! > "*The Matrix Market Exchange Formats: Initial Design.*" (1996).
|
||||
|
||||
pub use self::matrix_market::{
|
||||
load_coo_from_matrix_market_file, load_coo_from_matrix_market_str, MatrixMarketError,
|
||||
MatrixMarketErrorKind, MatrixMarketScalar,
|
||||
};
|
||||
mod matrix_market;
|
||||
|
|
@ -19,6 +19,7 @@
|
|||
//! - Sparsity patterns in CSR and CSC matrices are explicitly represented by the
|
||||
//! [SparsityPattern](pattern::SparsityPattern) type, which encodes the invariants of the
|
||||
//! associated index data structures.
|
||||
//! - [Matrix market format support](`io`) when the `io` feature is enabled.
|
||||
//! - [proptest strategies](`proptest`) for sparse matrices when the feature
|
||||
//! `proptest-support` is enabled.
|
||||
//! - [matrixcompare support](https://crates.io/crates/matrixcompare) for effortless
|
||||
|
|
@ -142,11 +143,19 @@
|
|||
)]
|
||||
|
||||
pub extern crate nalgebra as na;
|
||||
#[cfg(feature = "io")]
|
||||
extern crate pest;
|
||||
#[macro_use]
|
||||
#[cfg(feature = "io")]
|
||||
extern crate pest_derive;
|
||||
|
||||
pub mod convert;
|
||||
pub mod coo;
|
||||
pub mod csc;
|
||||
pub mod csr;
|
||||
pub mod factorization;
|
||||
#[cfg(feature = "io")]
|
||||
pub mod io;
|
||||
pub mod ops;
|
||||
pub mod pattern;
|
||||
|
||||
|
|
|
|||
|
|
@ -1,6 +1,9 @@
|
|||
//! Unit tests
|
||||
#[cfg(any(not(feature = "proptest-support"), not(feature = "compare")))]
|
||||
compile_error!("Tests must be run with features `proptest-support` and `compare`");
|
||||
#[cfg(not(all(feature = "proptest-support", feature = "compare", feature = "io",)))]
|
||||
compile_error!(
|
||||
"Please enable the `proptest-support`, `compare` and `io` features in order to compile and run the tests.
|
||||
Example: `cargo test -p nalgebra-sparse --features proptest-support,compare,io`"
|
||||
);
|
||||
|
||||
mod unit_tests;
|
||||
|
||||
|
|
|
|||
|
|
@ -0,0 +1,345 @@
|
|||
use matrixcompare::assert_matrix_eq;
|
||||
use nalgebra::dmatrix;
|
||||
use nalgebra::Complex;
|
||||
use nalgebra_sparse::io::load_coo_from_matrix_market_str;
|
||||
use nalgebra_sparse::CooMatrix;
|
||||
|
||||
#[test]
|
||||
#[rustfmt::skip]
|
||||
fn test_matrixmarket_sparse_real_general_empty() {
|
||||
// Test several valid zero-shapes of a sparse matrix
|
||||
let shapes = vec![ (0, 0), (1, 0), (0, 1) ];
|
||||
let strings: Vec<String> = shapes
|
||||
.iter()
|
||||
.map(|(m, n)| format!("%%MatrixMarket matrix coordinate real general\n {} {} 0", m, n))
|
||||
.collect();
|
||||
|
||||
for (shape,string) in shapes.iter().zip(strings.iter()) {
|
||||
let sparse_mat = load_coo_from_matrix_market_str::<f32>(string).unwrap();
|
||||
assert_eq!(sparse_mat.nrows(), shape.0);
|
||||
assert_eq!(sparse_mat.ncols(), shape.1);
|
||||
assert_eq!(sparse_mat.nnz(), 0);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[rustfmt::skip]
|
||||
fn test_matrixmarket_dense_real_general_empty() {
|
||||
// Test several valid zero-shapes of a dense matrix
|
||||
let shapes = vec![ (0, 0), (1, 0), (0, 1) ];
|
||||
let strings: Vec<String> = shapes
|
||||
.iter()
|
||||
.map(|(m, n)| format!("%%MatrixMarket matrix array real general\n {} {}", m, n))
|
||||
.collect();
|
||||
|
||||
for (shape,string) in shapes.iter().zip(strings.iter()) {
|
||||
let sparse_mat = load_coo_from_matrix_market_str::<f32>(string).unwrap();
|
||||
assert_eq!(sparse_mat.nrows(), shape.0);
|
||||
assert_eq!(sparse_mat.ncols(), shape.1);
|
||||
assert_eq!(sparse_mat.nnz(), 0);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[rustfmt::skip]
|
||||
fn test_matrixmarket_sparse_real_general() {
|
||||
let file_str = r#"
|
||||
%%MatrixMarket matrix CoOrdinate real general
|
||||
% This is also an example of free-format features.
|
||||
%=================================================================================
|
||||
%
|
||||
% This ASCII file represents a sparse MxN matrix with L
|
||||
% nonzeros in the following Matrix Market format:
|
||||
%
|
||||
% +----------------------------------------------+
|
||||
% |%%MatrixMarket matrix coordinate real general | <--- header line
|
||||
% |% | <--+
|
||||
% |% comments | |-- 0 or more comment lines
|
||||
% |% | <--+
|
||||
% | M T L | <--- rows, columns, entries
|
||||
% | I1 J1 A(I1, J1) | <--+
|
||||
% | I2 J2 A(I2, J2) | |
|
||||
% | I3 J3 A(I3, J3) | |-- L lines
|
||||
% | . . . | |
|
||||
% | IL JL A(IL, JL) | <--+
|
||||
% +----------------------------------------------+
|
||||
%
|
||||
% Indices are 1-based, i.e. A(1,1) is the first element.
|
||||
%
|
||||
%=================================================================================
|
||||
5 5 8
|
||||
1 1 1
|
||||
|
||||
2 2 1.050e+01
|
||||
3 3 1.500e-02
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
1 4 6.000e+00
|
||||
|
||||
4 2 2.505e+02
|
||||
|
||||
4 4 -2.800e+02
|
||||
4 5 3.332e+01
|
||||
5 5 1.200e+01
|
||||
"#;
|
||||
let sparse_mat = load_coo_from_matrix_market_str::<f32>(file_str).unwrap();
|
||||
let expected = dmatrix![
|
||||
1.0, 0.0, 0.0, 6.0, 0.0;
|
||||
0.0, 10.5, 0.0, 0.0, 0.0;
|
||||
0.0, 0.0, 0.015, 0.0, 0.0;
|
||||
0.0, 250.5, 0.0, -280.0, 33.32;
|
||||
0.0, 0.0, 0.0, 0.0, 12.0;
|
||||
];
|
||||
assert_matrix_eq!(sparse_mat, expected);
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[rustfmt::skip]
|
||||
fn test_matrixmarket_sparse_int_symmetric() {
|
||||
let file_str = r#"
|
||||
%%MatrixMarket matrix coordinate integer symmetric
|
||||
%
|
||||
5 5 9
|
||||
1 1 11
|
||||
2 2 22
|
||||
3 2 23
|
||||
3 3 33
|
||||
4 2 24
|
||||
4 4 44
|
||||
5 1 -15
|
||||
5 3 35
|
||||
5 5 55
|
||||
"#;
|
||||
let sparse_mat = load_coo_from_matrix_market_str::<i128>(file_str).unwrap();
|
||||
let expected = dmatrix![
|
||||
11, 0, 0, 0, -15;
|
||||
0, 22, 23, 24, 0;
|
||||
0, 23, 33, 0, 35;
|
||||
0, 24, 0, 44, 0;
|
||||
-15, 0, 35, 0, 55;
|
||||
];
|
||||
assert_matrix_eq!(sparse_mat, expected);
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[rustfmt::skip]
|
||||
fn test_matrixmarket_sparse_complex_hermitian() {
|
||||
let file_str = r#"
|
||||
%%MatrixMarket matrix coordinate complex hermitian
|
||||
%
|
||||
5 5 7
|
||||
1 1 1.0 0.0
|
||||
2 2 10.5 0.0
|
||||
4 2 250.5 22.22
|
||||
3 3 0.015 0.0
|
||||
4 4 -2.8e2 0.0
|
||||
5 5 12.0 0.0
|
||||
5 4 0.0 33.32
|
||||
|
||||
"#;
|
||||
let sparse_mat = load_coo_from_matrix_market_str::<Complex<f64>>(file_str).unwrap();
|
||||
let expected = dmatrix![
|
||||
Complex::<f64>{re:1.0,im:0.0}, Complex::<f64>{re:0.0,im:0.0}, Complex::<f64>{re:0.0,im:0.0}, Complex::<f64>{re:0.0,im:0.0},Complex::<f64>{re:0.0,im:0.0};
|
||||
Complex::<f64>{re:0.0,im:0.0}, Complex::<f64>{re:10.5,im:0.0}, Complex::<f64>{re:0.0,im:0.0}, Complex::<f64>{re:250.5,im:-22.22},Complex::<f64>{re:0.0,im:0.0};
|
||||
Complex::<f64>{re:0.0,im:0.0}, Complex::<f64>{re:0.0,im:0.0}, Complex::<f64>{re:0.015,im:0.0}, Complex::<f64>{re:0.0,im:0.0},Complex::<f64>{re:0.0,im:0.0};
|
||||
Complex::<f64>{re:0.0,im:0.0}, Complex::<f64>{re:250.5,im:22.22}, Complex::<f64>{re:0.0,im:0.0}, Complex::<f64>{re:-280.0,im:0.0},Complex::<f64>{re:0.0,im:-33.32};
|
||||
Complex::<f64>{re:0.0,im:0.0}, Complex::<f64>{re:0.0,im:0.0}, Complex::<f64>{re:0.0,im:0.0}, Complex::<f64>{re:0.0,im:33.32},Complex::<f64>{re:12.0,im:0.0};
|
||||
];
|
||||
assert_matrix_eq!(sparse_mat, expected);
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[rustfmt::skip]
|
||||
fn test_matrixmarket_sparse_real_skew() {
|
||||
let file_str = r#"
|
||||
%%MatrixMarket matrix coordinate real skew-symmetric
|
||||
%
|
||||
5 5 4
|
||||
3 2 -23.0
|
||||
4 2 -24.0
|
||||
5 1 -15.0
|
||||
5 3 -35.0
|
||||
"#;
|
||||
let sparse_mat = load_coo_from_matrix_market_str::<f64>(file_str).unwrap();
|
||||
let expected = dmatrix![
|
||||
0.0, 0.0, 0.0, 0.0, 15.0;
|
||||
0.0, 0.0, 23.0, 24.0, 0.0;
|
||||
0.0, -23.0, 0.0, 0.0, 35.0;
|
||||
0.0, -24.0, 0.0, 0.0, 0.0;
|
||||
-15.0, 0.0, -35.0, 0.0, 0.0;
|
||||
];
|
||||
assert_matrix_eq!(sparse_mat, expected);
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[rustfmt::skip]
|
||||
fn test_matrixmarket_sparse_pattern_general() {
|
||||
let file_str = r#"
|
||||
%%MatrixMarket matrix coordinate pattern general
|
||||
%
|
||||
5 5 10
|
||||
1 1
|
||||
1 5
|
||||
2 3
|
||||
2 4
|
||||
3 2
|
||||
3 5
|
||||
4 1
|
||||
5 2
|
||||
5 4
|
||||
5 5
|
||||
"#;
|
||||
let pattern_matrix = load_coo_from_matrix_market_str::<()>(file_str).unwrap();
|
||||
let nrows = pattern_matrix.nrows();
|
||||
let ncols = pattern_matrix.ncols();
|
||||
let (row_idx, col_idx, val) = pattern_matrix.disassemble();
|
||||
let values = vec![1; val.len()];
|
||||
let sparse_mat = CooMatrix::try_from_triplets(nrows, ncols, row_idx, col_idx, values).unwrap();
|
||||
let expected = dmatrix![
|
||||
1, 0, 0, 0, 1;
|
||||
0, 0, 1, 1, 0;
|
||||
0, 1, 0, 0, 1;
|
||||
1, 0, 0, 0, 0;
|
||||
0, 1, 0, 1, 1;
|
||||
];
|
||||
assert_matrix_eq!(sparse_mat, expected);
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[rustfmt::skip]
|
||||
fn test_matrixmarket_dense_real_general() {
|
||||
let file_str = r#"
|
||||
%%MatrixMarket matrix array real general
|
||||
%
|
||||
4 3
|
||||
1.0
|
||||
2.0
|
||||
3.0
|
||||
4.0
|
||||
5.0
|
||||
6.0
|
||||
7.0
|
||||
8.0
|
||||
9.0
|
||||
10.0
|
||||
11.0
|
||||
12.0
|
||||
|
||||
"#;
|
||||
let sparse_mat = load_coo_from_matrix_market_str::<f32>(file_str).unwrap();
|
||||
let expected = dmatrix![
|
||||
1.0, 5.0, 9.0;
|
||||
2.0, 6.0, 10.0;
|
||||
3.0, 7.0, 11.0;
|
||||
4.0, 8.0, 12.0;
|
||||
];
|
||||
assert_matrix_eq!(sparse_mat, expected);
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[rustfmt::skip]
|
||||
fn test_matrixmarket_dense_real_symmetric() {
|
||||
let file_str = r#"
|
||||
%%MatrixMarket matrix array real symmetric
|
||||
%
|
||||
4 4
|
||||
1.0
|
||||
2.0
|
||||
3.0
|
||||
4.0
|
||||
5.0
|
||||
6.0
|
||||
7.0
|
||||
8.0
|
||||
9.0
|
||||
10.0
|
||||
|
||||
"#;
|
||||
let sparse_mat = load_coo_from_matrix_market_str::<f32>(file_str).unwrap();
|
||||
let expected = dmatrix![
|
||||
1.0, 2.0, 3.0, 4.0;
|
||||
2.0, 5.0, 6.0, 7.0;
|
||||
3.0, 6.0, 8.0, 9.0;
|
||||
4.0, 7.0, 9.0, 10.0;
|
||||
];
|
||||
assert_matrix_eq!(sparse_mat, expected);
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[rustfmt::skip]
|
||||
fn test_matrixmarket_dense_complex_hermitian() {
|
||||
let file_str = r#"
|
||||
%%MatrixMarket matrix array complex hermitian
|
||||
%
|
||||
4 4
|
||||
1.0 0.0
|
||||
2.0 2.0
|
||||
3.0 3.0
|
||||
4.0 4.0
|
||||
5.0 0.0
|
||||
6.0 6.0
|
||||
7.0 7.0
|
||||
8.0 0.0
|
||||
9.0 9.0
|
||||
10.0 0.0
|
||||
|
||||
"#;
|
||||
let sparse_mat = load_coo_from_matrix_market_str::<Complex<f64>>(file_str).unwrap();
|
||||
let expected = dmatrix![
|
||||
Complex::<f64>{re:1.0,im:0.0}, Complex::<f64>{re:2.0,im:-2.0} ,Complex::<f64>{re:3.0,im:-3.0} ,Complex::<f64>{re:4.0,im:-4.0};
|
||||
Complex::<f64>{re:2.0,im:2.0}, Complex::<f64>{re:5.0,im:0.0} ,Complex::<f64>{re:6.0,im:-6.0} ,Complex::<f64>{re:7.0,im:-7.0};
|
||||
Complex::<f64>{re:3.0,im:3.0}, Complex::<f64>{re:6.0,im:6.0} ,Complex::<f64>{re:8.0,im:0.0} ,Complex::<f64>{re:9.0,im:-9.0};
|
||||
Complex::<f64>{re:4.0,im:4.0}, Complex::<f64>{re:7.0,im:7.0} ,Complex::<f64>{re:9.0,im:9.0} ,Complex::<f64>{re:10.0,im:0.0};
|
||||
];
|
||||
assert_matrix_eq!(sparse_mat, expected);
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[rustfmt::skip]
|
||||
fn test_matrixmarket_dense_int_skew() {
|
||||
let file_str = r#"
|
||||
%%MatrixMarket matrix array integer skew-symmetric
|
||||
%
|
||||
4 4
|
||||
1
|
||||
2
|
||||
3
|
||||
4
|
||||
5
|
||||
6
|
||||
"#;
|
||||
let sparse_mat = load_coo_from_matrix_market_str::<i32>(file_str).unwrap();
|
||||
let expected = dmatrix![
|
||||
0,-1,-2,-3;
|
||||
1, 0,-4,-5;
|
||||
2, 4, 0,-6;
|
||||
3, 5, 6, 0;
|
||||
];
|
||||
assert_matrix_eq!(sparse_mat, expected);
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[rustfmt::skip]
|
||||
fn test_matrixmarket_dense_complex_general() {
|
||||
let file_str = r#"
|
||||
%%MatrixMarket matrix array complex general
|
||||
%
|
||||
2 2
|
||||
1 0
|
||||
1 0
|
||||
1 0
|
||||
1 0
|
||||
"#;
|
||||
let sparse_mat = load_coo_from_matrix_market_str::<Complex<f32>>(file_str).unwrap();
|
||||
let expected = dmatrix![
|
||||
Complex::<f32>{re:1.0,im:0.0},Complex::<f32>{re:1.0,im:0.0};
|
||||
Complex::<f32>{re:1.0,im:0.0},Complex::<f32>{re:1.0,im:0.0};
|
||||
];
|
||||
assert_matrix_eq!(sparse_mat, expected);
|
||||
}
|
||||
|
|
@ -3,6 +3,7 @@ mod convert_serial;
|
|||
mod coo;
|
||||
mod csc;
|
||||
mod csr;
|
||||
mod matrix_market;
|
||||
mod ops;
|
||||
mod pattern;
|
||||
mod proptest;
|
||||
|
|
|
|||
Loading…
Reference in New Issue