sciforge 0.0.3

A comprehensive scientific computing library in pure Rust with zero dependencies
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

//! Dispatch handler for sparse matrix functions.

use super::super::params::*;
use super::helpers::*;
use crate::hub::domain::common::errors::{HubError, HubResult};
use crate::hub::domain::maths;
use crate::hub::engine::experience::runner::RunOutput;

pub(super) fn dispatch(func: &str, p: &Params) -> HubResult<RunOutput> {
    match func {
        "sparse_kronecker" => Ok(out_sparse(maths::sparse::sparse_kronecker(
            &mk_sparse(p, "a")?,
            &mk_sparse(p, "b")?,
        ))),
        "sparse_add" => Ok(out_sparse(maths::sparse::sparse_add(
            &mk_sparse(p, "a")?,
            &mk_sparse(p, "b")?,
        ))),
        "sparse_scale" => Ok(out_sparse(maths::sparse::sparse_scale(
            &mk_sparse(p, "a")?,
            get_f(p, "scalar")?,
        ))),
        "sparse_mat_mul" => Ok(out_sparse(maths::sparse::sparse_mat_mul(
            &mk_sparse(p, "a")?,
            &mk_sparse(p, "b")?,
        ))),
        "sparse_trace" => Ok(RunOutput::Scalar(maths::sparse::sparse_trace(&mk_sparse(
            p, "a",
        )?))),
        "sparse_frobenius_norm" => Ok(RunOutput::Scalar(maths::sparse::sparse_frobenius_norm(
            &mk_sparse(p, "a")?,
        ))),
        "sparse_infinity_norm" => Ok(RunOutput::Scalar(maths::sparse::sparse_infinity_norm(
            &mk_sparse(p, "a")?,
        ))),
        "sparse_one_norm" => Ok(RunOutput::Scalar(maths::sparse::sparse_one_norm(
            &mk_sparse(p, "a")?,
        ))),
        "sparse_diagonal" => Ok(RunOutput::Vector(maths::sparse::sparse_diagonal(
            &mk_sparse(p, "a")?,
        ))),
        "sparse_lower_triangular" => Ok(out_sparse(maths::sparse::sparse_lower_triangular(
            &mk_sparse(p, "a")?,
        ))),
        "sparse_upper_triangular" => Ok(out_sparse(maths::sparse::sparse_upper_triangular(
            &mk_sparse(p, "a")?,
        ))),
        "sparse_row_sum" => Ok(RunOutput::Vector(maths::sparse::sparse_row_sum(
            &mk_sparse(p, "a")?,
        ))),
        "sparse_col_sum" => Ok(RunOutput::Vector(maths::sparse::sparse_col_sum(
            &mk_sparse(p, "a")?,
        ))),
        "sparse_is_symmetric" => Ok(RunOutput::Boolean(maths::sparse::sparse_is_symmetric(
            &mk_sparse(p, "a")?,
            get_f(p, "tol")?,
        ))),
        "conjugate_gradient" => Ok(RunOutput::Vector(maths::sparse::conjugate_gradient(
            &mk_sparse(p, "a")?,
            get_v(p, "b")?,
            get_f(p, "tol")?,
            get_u(p, "max_iter")?,
        ))),
        "jacobi_iterate" => Ok(RunOutput::Vector(maths::sparse::jacobi_iterate(
            &mk_sparse(p, "a")?,
            get_v(p, "b")?,
            get_f(p, "tol")?,
            get_u(p, "max_iter")?,
        ))),
        "gauss_seidel" => Ok(RunOutput::Vector(maths::sparse::gauss_seidel(
            &mk_sparse(p, "a")?,
            get_v(p, "b")?,
            get_f(p, "tol")?,
            get_u(p, "max_iter")?,
        ))),
        "sparse_lu_solve" => Ok(RunOutput::Vector(maths::sparse::sparse_lu_solve(
            &mk_sparse(p, "a")?,
            get_v(p, "b")?,
        ))),
        "sor_iterate" => Ok(RunOutput::Vector(maths::sparse::sor_iterate(
            &mk_sparse(p, "a")?,
            get_v(p, "b")?,
            get_f(p, "omega")?,
            get_f(p, "tol")?,
            get_u(p, "max_iter")?,
        ))),
        "steepest_descent" => Ok(RunOutput::Vector(maths::sparse::steepest_descent(
            &mk_sparse(p, "a")?,
            get_v(p, "b")?,
            get_f(p, "tol")?,
            get_u(p, "max_iter")?,
        ))),
        "bicgstab" => Ok(RunOutput::Vector(maths::sparse::bicgstab(
            &mk_sparse(p, "a")?,
            get_v(p, "b")?,
            get_f(p, "tol")?,
            get_u(p, "max_iter")?,
        ))),
        "gmres" => Ok(RunOutput::Vector(maths::sparse::gmres(
            &mk_sparse(p, "a")?,
            get_v(p, "b")?,
            get_f(p, "tol")?,
            get_u(p, "max_iter")?,
            get_u(p, "restart")?,
        ))),

        _ => Err(HubError::InvalidInput(format!("unknown function: {func}"))),
    }
}