cell-sheet-core 0.1.3

Core spreadsheet engine with formulas, dependency tracking, and file I/O
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

use crate::model::{CellError, CellValue};

fn collect_numbers(values: &[CellValue]) -> Result<Vec<f64>, CellError> {
    let mut nums = Vec::new();
    for v in values {
        match v {
            CellValue::Number(n) => nums.push(*n),
            CellValue::Error(e) => return Err(e.clone()),
            CellValue::Empty => {}
            CellValue::Text(_) => {}
            CellValue::Bool(_) => {}
        }
    }
    Ok(nums)
}

pub fn fn_sum(values: &[CellValue]) -> CellValue {
    match collect_numbers(values) {
        Ok(nums) => CellValue::Number(nums.iter().sum()),
        Err(e) => CellValue::Error(e),
    }
}

pub fn fn_average(values: &[CellValue]) -> CellValue {
    match collect_numbers(values) {
        Ok(nums) if nums.is_empty() => CellValue::Error(CellError::DivZero),
        Ok(nums) => {
            let count = nums.len() as f64;
            CellValue::Number(nums.iter().sum::<f64>() / count)
        }
        Err(e) => CellValue::Error(e),
    }
}

pub fn fn_count(values: &[CellValue]) -> CellValue {
    match collect_numbers(values) {
        Ok(nums) => CellValue::Number(nums.len() as f64),
        Err(e) => CellValue::Error(e),
    }
}

pub fn fn_min(values: &[CellValue]) -> CellValue {
    match collect_numbers(values) {
        Ok(nums) if nums.is_empty() => CellValue::Number(0.0),
        Ok(nums) => CellValue::Number(nums.iter().cloned().fold(f64::INFINITY, f64::min)),
        Err(e) => CellValue::Error(e),
    }
}

pub fn fn_max(values: &[CellValue]) -> CellValue {
    match collect_numbers(values) {
        Ok(nums) if nums.is_empty() => CellValue::Number(0.0),
        Ok(nums) => CellValue::Number(nums.iter().cloned().fold(f64::NEG_INFINITY, f64::max)),
        Err(e) => CellValue::Error(e),
    }
}

pub fn fn_if(args: &[CellValue]) -> CellValue {
    if args.len() != 3 {
        return CellValue::Error(CellError::Value);
    }
    match &args[0] {
        CellValue::Bool(true) => args[1].clone(),
        CellValue::Bool(false) => args[2].clone(),
        CellValue::Number(n) => {
            if *n != 0.0 {
                args[1].clone()
            } else {
                args[2].clone()
            }
        }
        CellValue::Error(e) => CellValue::Error(e.clone()),
        _ => CellValue::Error(CellError::Value),
    }
}