torsh-sparse 0.1.2

Sparse tensor operations for ToRSh with SciRS2 integration
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

/*!
 * Basic Usage Example for ToRSh-Sparse
 *
 * This example demonstrates the fundamental operations of sparse tensors,
 * including creation, format conversion, and basic arithmetic operations.
 */

use torsh_core::TorshError;
use torsh_sparse::*;
use torsh_tensor::creation::zeros;

fn main() -> Result<(), TorshError> {
    println!("ToRSh-Sparse Basic Usage Example");
    println!("================================");

    // 1. Create a sparse matrix from triplets (COO format)
    println!("1. Creating sparse matrix from triplets...");
    let triplets = vec![
        (0, 0, 1.0),
        (0, 2, 2.0),
        (1, 1, 3.0),
        (2, 0, 4.0),
        (2, 2, 5.0),
    ];

    let coo_matrix = CooTensor::from_triplets(triplets, (3, 3))?;
    println!("COO matrix created with {} non-zeros", coo_matrix.nnz());

    // 2. Convert to different formats
    println!("\n2. Converting to different formats...");
    let csr_matrix = CsrTensor::from_coo(&coo_matrix)?;
    let csc_matrix = CscTensor::from_coo(&coo_matrix)?;

    println!("CSR matrix: {} non-zeros", csr_matrix.nnz());
    println!("CSC matrix: {} non-zeros", csc_matrix.nnz());

    // 3. Element access
    println!("\n3. Element access...");
    let value = csr_matrix.get(0, 0).unwrap_or(0.0);
    println!("Element at (0, 0): {value}");

    let value = csr_matrix.get(1, 1).unwrap_or(0.0);
    println!("Element at (1, 1): {value}");

    let value = csr_matrix.get(0, 1).unwrap_or(0.0); // Zero element
    println!("Element at (0, 1): {value}");

    // 4. Matrix properties
    println!("\n4. Matrix properties...");
    println!("Shape: {:?}", csr_matrix.shape());
    println!("Non-zeros: {}", csr_matrix.nnz());
    println!("Density: {:.2}%", csr_matrix.density() * 100.0);

    // 5. Convert to dense for visualization
    println!("\n5. Dense representation:");
    let dense = csr_matrix.to_dense()?;
    println!("Dense matrix:");
    for i in 0..3 {
        for j in 0..3 {
            print!("{:.1} ", dense.get(&[i, j]).unwrap());
        }
        println!();
    }

    // 6. Matrix-vector multiplication
    println!("\n6. Matrix-vector multiplication...");
    let vector = [1.0, 2.0, 3.0];
    let vector_tensor = zeros::<f32>(&[3])?;
    for (i, &v) in vector.iter().enumerate() {
        vector_tensor.set(&[i], v)?;
    }
    let result = csr_matrix.matvec(&vector_tensor)?;
    println!("Matrix * vector = {:?}", result.to_vec()?);

    // 7. Transpose
    println!("\n7. Matrix transpose...");
    let transposed = csr_matrix.transpose()?;
    println!("Transposed matrix has {} non-zeros", transposed.nnz());

    // 8. Scalar operations
    println!("\n8. Scalar operations...");
    let scaled = csr_matrix.scale(2.0)?;
    println!("Scaled matrix (2x) has {} non-zeros", scaled.nnz());

    // 9. Matrix addition
    println!("\n9. Matrix addition...");
    let sum = csr_matrix.add(&scaled)?;
    println!("Sum matrix has {} non-zeros", sum.nnz());

    // 10. Reductions
    println!("\n10. Reduction operations...");
    let total_sum = csr_matrix.sum()?;
    println!("Sum of all elements: {total_sum}");

    let l2_norm = csr_matrix.norm(2.0)?;
    println!("L2 norm: {l2_norm:.4}");

    let diagonal = csr_matrix.diagonal()?;
    println!("Diagonal elements: {diagonal:?}");

    println!("\nBasic usage example completed successfully!");
    Ok(())
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_basic_operations() {
        let result = main();
        assert!(result.is_ok());
    }

    #[test]
    fn test_matrix_properties() -> Result<(), TorshError> {
        let triplets = vec![(0, 0, 1.0), (1, 1, 2.0), (2, 2, 3.0)];
        let coo = CooTensor::from_triplets(triplets, (3, 3))?;
        let csr = CsrTensor::from_coo(&coo)?;

        assert_eq!(csr.nnz(), 3);
        assert_eq!(csr.shape(), (3, 3));
        assert!((csr.density() - 3.0 / 9.0).abs() < 1e-10);

        Ok(())
    }

    #[test]
    fn test_format_conversions() -> Result<(), TorshError> {
        let triplets = vec![(0, 0, 1.0), (1, 1, 2.0), (2, 2, 3.0)];
        let coo = CooTensor::from_triplets(triplets, (3, 3))?;

        let csr = CsrTensor::from_coo(&coo)?;
        let csc = CscTensor::from_coo(&coo)?;

        assert_eq!(coo.nnz(), csr.nnz());
        assert_eq!(coo.nnz(), csc.nnz());

        // Test element access consistency
        assert_eq!(csr.get(0, 0)?, 1.0);
        assert_eq!(csr.get(1, 1)?, 2.0);
        assert_eq!(csr.get(2, 2)?, 3.0);

        Ok(())
    }
}