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

//! Shared helpers for maths dispatch handlers.

use super::super::params::*;
use crate::hub::domain::common::errors::{HubError, HubResult};
use crate::hub::engine::experience::runner::RunOutput;
pub use crate::maths::complex::Complex;
pub use crate::maths::complex::Quaternion;
pub use crate::maths::polynomial::Polynomial;
pub use crate::maths::sparse::SparseMatrix;
pub use crate::maths::tensor::Tensor;
pub use crate::maths::vector::Vec3;

pub fn mk_vec3(p: &Params, name: &str) -> HubResult<Vec3> {
    let v = get_v(p, name)?;
    if v.len() < 3 {
        return Err(HubError::InvalidInput(format!("{name}: need 3 components")));
    }
    Ok(Vec3::new(v[0], v[1], v[2]))
}

pub fn mk_poly(p: &Params, name: &str) -> HubResult<Polynomial> {
    Ok(Polynomial::new(get_poly(p, name)?.to_vec()))
}

pub fn mk_tensor(p: &Params, name: &str) -> HubResult<Tensor> {
    let (data, shape) = get_tensor(p, name)?;
    Ok(Tensor::from_vec(shape, data.to_vec()))
}

pub fn mk_sparse(p: &Params, name: &str) -> HubResult<SparseMatrix> {
    let (rows, cols, row_ptr, col_idx, values) = get_sparse(p, name)?;
    Ok(SparseMatrix {
        rows,
        cols,
        row_ptr: row_ptr.to_vec(),
        col_idx: col_idx.to_vec(),
        values: values.to_vec(),
    })
}

pub fn out_vec3(v: Vec3) -> RunOutput {
    RunOutput::Triple(v.x, v.y, v.z)
}

pub fn out_poly(p: Polynomial) -> RunOutput {
    RunOutput::PolynomialOut(p.coeffs)
}

pub fn out_tensor(t: Tensor) -> RunOutput {
    RunOutput::TensorOut {
        data: t.data().to_vec(),
        shape: t.shape().to_vec(),
    }
}

pub fn out_sparse(s: SparseMatrix) -> RunOutput {
    RunOutput::SparseOut {
        rows: s.rows,
        cols: s.cols,
        row_ptr: s.row_ptr,
        col_idx: s.col_idx,
        values: s.values,
    }
}

pub fn out_quat(q: Quaternion) -> RunOutput {
    RunOutput::Vector(vec![q.w, q.x, q.y, q.z])
}

pub fn out_c(c: Complex) -> RunOutput {
    RunOutput::Complex(c.re, c.im)
}

pub fn out_cv(v: Vec<Complex>) -> RunOutput {
    RunOutput::ComplexVector(v.iter().map(|c| (c.re, c.im)).collect())
}

pub fn out_cm(m: Vec<Vec<Complex>>) -> RunOutput {
    RunOutput::ComplexMatrix(
        m.iter()
            .map(|row| row.iter().map(|c| (c.re, c.im)).collect())
            .collect(),
    )
}