logisheets_controller 0.6.0

the core of LogiSheets
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

use super::{CalcValue, CalcVertex, Value};
use crate::calc_engine::connector::Connector;
use logisheets_parser::ast;

pub fn calc<C>(args: Vec<CalcVertex>, fetcher: &mut C) -> CalcVertex
where
    C: Connector,
{
    let sum_result = args
        .into_iter()
        .map(|arg| fetcher.get_calc_value(arg))
        .try_fold(0_f64, |sum, v| match sum_calc_value(v) {
            Ok(n) => Ok(sum + n),
            Err(e) => Err(e),
        });
    match sum_result {
        Ok(num) => CalcVertex::from_number(num),
        Err(e) => CalcVertex::from_error(e),
    }
}

pub fn calc_sumsq<C>(args: Vec<CalcVertex>, fetcher: &mut C) -> CalcVertex
where
    C: Connector,
{
    let sum_result = args
        .into_iter()
        .map(|arg| fetcher.get_calc_value(arg))
        .try_fold(0_f64, |sum, v| match sum_calc_value(v) {
            Ok(n) => Ok(sum + n.powi(2)),
            Err(e) => Err(e),
        });
    match sum_result {
        Ok(num) => CalcVertex::from_number(num),
        Err(e) => CalcVertex::from_error(e),
    }
}

fn sum_calc_value(value: CalcValue) -> Result<f64, ast::Error> {
    match value {
        CalcValue::Scalar(s) => match s {
            Value::Number(f) => Ok(f),
            Value::Error(e) => Err(e),
            _ => Ok(0_f64),
        },
        CalcValue::Range(r) => {
            let result = r.into_iter().try_fold(0_f64, |s, e| match e {
                Value::Number(n) => Ok(s + n),
                Value::Error(e) => Err(e),
                _ => Ok(s),
            })?;
            Ok(result)
        }
        CalcValue::Cube(c) => {
            let result = c.into_iter().try_fold(0_f64, |s, e| match e {
                Value::Number(n) => Ok(s + n),
                Value::Error(e) => Err(e),
                _ => Ok(s),
            })?;
            Ok(result)
        }
        CalcValue::Union(values) => values.into_iter().map(|v| sum_calc_value(*v)).try_fold(
            0_f64,
            |prev, this| match this {
                Ok(n) => Ok(prev + n),
                Err(e) => Err(e),
            },
        ),
    }
}

#[cfg(test)]
mod tests {
    use super::super::utils::tests_utils::TestFetcher;
    use super::{CalcValue, CalcVertex, Value};
    use logisheets_base::matrix_value::MatrixValue;
    use logisheets_parser::ast;

    #[test]
    fn sum_test() {
        let args = vec![
            CalcVertex::from_bool(true),
            CalcVertex::from_bool(false),
            CalcVertex::from_number(-1_f64),
            CalcVertex::from_string(String::from("text")),
            CalcVertex::Value(CalcValue::Range(MatrixValue::from(vec![
                vec![Value::Text(String::from("1"))],
                vec![Value::Number(1_f64)],
            ]))),
        ];
        let mut fetcher = TestFetcher {};
        let result = super::calc(args, &mut fetcher);
        if let CalcVertex::Value(CalcValue::Scalar(Value::Number(f))) = result {
            assert!((f - 0.0).abs() < 1e-10)
        } else {
            panic!()
        }
    }

    #[test]
    fn sum_error() {
        let args = vec![
            CalcVertex::from_error(ast::Error::Name),
            CalcVertex::from_bool(false),
            CalcVertex::from_number(100_f64),
        ];
        let mut fetcher = TestFetcher {};
        let result = super::calc(args, &mut fetcher);
        assert!(matches!(
            result,
            CalcVertex::Value(CalcValue::Scalar(Value::Error(ast::Error::Name)))
        ))
    }
}