scirs2-linalg 0.4.2

Linear algebra module for SciRS2 (scirs2-linalg)
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
147
148
149
150
151
152

#[cfg(feature = "tensor_contraction")]
mod tensor_example {
    use scirs2_core::ndarray::array;
    use scirs2_linalg::tensor_contraction::{batch_matmul, contract, einsum, hosvd};

    pub fn run() {
        println!("Tensor Contraction Operations for Deep Learning");
        println!("===============================================\n");

        // Example 1: Basic matrix multiplication as tensor contraction
        println!("Example 1: Matrix Multiplication as Tensor Contraction");

        // Create two matrices
        let a = array![[1.0, 2.0], [3.0, 4.0]];
        let b = array![[5.0, 6.0], [7.0, 8.0]];

        // Perform matrix multiplication using contract
        let c = contract(&a.view(), &b.view(), &[1], &[0]).expect("Operation failed");

        println!("Matrix A:");
        println!("{:?}", a);
        println!("Matrix B:");
        println!("{:?}", b);
        println!("A * B using contract:");
        println!("{:?}", c);
        println!();

        // Example 2: Batch Matrix Multiplication
        println!("Example 2: Batch Matrix Multiplication");

        // Create a batch of 2 matrices, each 2x2
        let batch_a = array![[[1.0, 2.0], [3.0, 4.0]], [[5.0, 6.0], [7.0, 8.0]]];

        // Create another batch of 2 matrices, each 2x2
        let batch_b = array![[[9.0, 10.0], [11.0, 12.0]], [[13.0, 14.0], [15.0, 16.0]]];

        // Perform batch matrix multiplication
        let batch_c = batch_matmul(&batch_a.view(), &batch_b.view(), 1).expect("Operation failed");

        println!("Batch A (shape: {:?}):", batch_a.shape());
        println!("Batch B (shape: {:?}):", batch_b.shape());
        println!("Batch A * Batch B (shape: {:?}):", batch_c.shape());
        println!("Result:");
        println!("{:?}", batch_c);
        println!();

        // Example 3: Einstein Summation Notation
        println!("Example 3: Einstein Summation Notation (einsum)");

        // Matrix multiplication using einsum
        let d = einsum("ij,jk->ik", &[&a.view().into_dyn(), &b.view().into_dyn()])
            .expect("Operation failed");

        println!("Matrix multiplication using einsum:");
        println!("{:?}", d);
        println!();

        // Batch matrix multiplication using einsum
        let batch_d = einsum(
            "bij,bjk->bik",
            &[&batch_a.view().into_dyn(), &batch_b.view().into_dyn()],
        )
        .expect("Operation failed");

        println!("Batch matrix multiplication using einsum:");
        println!("{:?}", batch_d);
        println!();

        // Trace of a matrix using einsum
        let matrix = array![[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]];
        let trace = einsum("ii->", &[&matrix.view().into_dyn()]).expect("Operation failed");

        println!("Matrix:");
        println!("{:?}", matrix);
        println!("Trace using einsum: {}", trace[0]);
        println!();

        // Outer product using einsum
        let vec1 = array![1.0, 2.0, 3.0];
        let vec2 = array![4.0, 5.0];
        let outer = einsum(
            "i,j->ij",
            &[&vec1.view().into_dyn(), &vec2.view().into_dyn()],
        )
        .expect("Operation failed");

        println!("Vector 1: {:?}", vec1);
        println!("Vector 2: {:?}", vec2);
        println!("Outer product using einsum:");
        println!("{:?}", outer);
        println!();

        // Example 4: Tensor Decomposition with HOSVD
        println!("Example 4: Tensor Decomposition with Higher-Order SVD (HOSVD)");

        // Create a 3D tensor
        let tensor = array![[[1.0, 2.0], [3.0, 4.0]], [[5.0, 6.0], [7.0, 8.0]]];
        println!("Original tensor (shape: {:?}):", tensor.shape());

        // Decompose tensor with full rank
        let (core, factors) = hosvd(&tensor.view(), &[2, 2, 2]).expect("Operation failed");

        println!("Core tensor (shape: {:?}):", core.shape());
        for (i, factor) in factors.iter().enumerate() {
            println!("Factor {} (shape: {:?}):", i, factor.shape());
            println!("{:?}", factor);
        }

        // Example 5: Advanced einsum operations
        println!("\nExample 5: Advanced einsum operations");

        // Create a 3D tensor
        let tensor3d = array![
            [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]],
            [[7.0, 8.0, 9.0], [10.0, 11.0, 12.0]]
        ];

        // Create a 2D matrix
        let matrix2d = array![[0.1, 0.2], [0.3, 0.4], [0.5, 0.6]];

        // Contract tensor3d and matrix2d: tensor3d[i,j,k] * matrix2d[k,l] -> result[i,j,l]
        let result = einsum(
            "ijk,kl->ijl",
            &[&tensor3d.view().into_dyn(), &matrix2d.view().into_dyn()],
        )
        .expect("Operation failed");

        println!("Tensor (shape: {:?}):", tensor3d.shape());
        println!("Matrix (shape: {:?}):", matrix2d.shape());
        println!(
            "Result of einsum \"ijk,kl->ijl\" (shape: {:?}):",
            result.shape()
        );
        println!("{:?}", result);
    }
}

#[allow(dead_code)]
fn main() {
    #[cfg(feature = "tensor_contraction")]
    {
        tensor_example::run();
    }

    #[cfg(not(feature = "tensor_contraction"))]
    {
        println!("This example requires tensor_contraction feature.");
        println!(
            "Run with: cargo run --example tensor_contraction_example --features tensor_contraction"
        );
    }
}