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

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

pub fn calc<C>(args: Vec<CalcVertex>, fetcher: &mut C) -> CalcVertex
where
    C: Connector,
{
    if args.len() < 1 || args.len() > 2 {
        return CalcVertex::from_error(ast::Error::Unspecified);
    }
    let mut iter = args.into_iter();
    let first = iter.next().unwrap();
    let guess = match iter.next() {
        Some(vertex) => {
            let value = fetcher.get_calc_value(vertex);
            match value {
                CalcValue::Scalar(v) => match convert(v) {
                    ConvertResult::None => Ok(0.),
                    ConvertResult::Number(f) => Ok(f),
                    ConvertResult::Err(e) => Err(e),
                },
                _ => Err(ast::Error::Value),
            }
        }
        None => Ok(0_f64),
    };
    if let Err(e) = guess {
        return CalcVertex::from_error(e);
    }
    let nums_value = fetcher.get_calc_value(first);
    match get_num_vec(nums_value) {
        Ok(nums) => {
            let g = guess.unwrap();
            let result = calc_irr(&nums, Some(g));
            match result {
                Some(n) => CalcVertex::from_number(n),
                None => CalcVertex::from_error(ast::Error::Value),
            }
        }
        Err(e) => CalcVertex::from_error(e),
    }
}

fn get_num_vec(value: CalcValue) -> Result<Vec<f64>, ast::Error> {
    match value {
        CalcValue::Scalar(sv) => match convert(sv) {
            ConvertResult::None => Ok(vec![]),
            ConvertResult::Number(n) => Ok(vec![n]),
            ConvertResult::Err(e) => Err(e),
        },
        CalcValue::Range(r) => {
            r.into_iter()
                .try_fold(Vec::<f64>::new(), |mut prev, v| match convert(v) {
                    ConvertResult::None => Ok(prev),
                    ConvertResult::Number(n) => {
                        prev.push(n);
                        Ok(prev)
                    }
                    ConvertResult::Err(e) => Err(e),
                })
        }
        CalcValue::Cube(c) => {
            c.into_iter()
                .try_fold(Vec::<f64>::new(), |mut prev, v| match convert(v) {
                    ConvertResult::None => Ok(prev),
                    ConvertResult::Number(n) => {
                        prev.push(n);
                        Ok(prev)
                    }
                    ConvertResult::Err(e) => Err(e),
                })
        }
        CalcValue::Union(union) => union
            .into_iter()
            .try_fold(Vec::<f64>::new(), |mut prev, v| match get_num_vec(*v) {
                Ok(nums) => {
                    prev.extend(nums);
                    Ok(prev)
                }
                Err(e) => Err(e),
            }),
    }
}

fn convert(value: Value) -> ConvertResult {
    match value {
        Value::Blank => ConvertResult::None,
        Value::Number(f) => ConvertResult::Number(f),
        Value::Text(_) => ConvertResult::None,
        Value::Boolean(_) => ConvertResult::None,
        Value::Error(e) => ConvertResult::Err(e),
    }
}

enum ConvertResult {
    None,
    Number(f64),
    Err(ast::Error),
}