ironcalc_base 0.7.1

Open source spreadsheet engine
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

use statrs::distribution::{Discrete, DiscreteCDF, Hypergeometric};

use crate::expressions::types::CellReferenceIndex;
use crate::{
    calc_result::CalcResult, expressions::parser::Node, expressions::token::Error, model::Model,
};

impl<'a> Model<'a> {
    // =HYPGEOM.DIST(sample_s, number_sample, population_s, number_pop, cumulative)
    pub(crate) fn fn_hyp_geom_dist(
        &mut self,
        args: &[Node],
        cell: CellReferenceIndex,
    ) -> CalcResult {
        if args.len() != 5 {
            return CalcResult::new_args_number_error(cell);
        }

        // sample_s (number of successes in the sample)
        let sample_s = match self.get_number_no_bools(&args[0], cell) {
            Ok(f) => f.trunc(),
            Err(e) => return e,
        };

        // number_sample (sample size)
        let number_sample = match self.get_number_no_bools(&args[1], cell) {
            Ok(f) => f.trunc(),
            Err(e) => return e,
        };

        // population_s (number of successes in the population)
        let population_s = match self.get_number_no_bools(&args[2], cell) {
            Ok(f) => f.trunc(),
            Err(e) => return e,
        };

        // number_pop (population size)
        let number_pop = match self.get_number_no_bools(&args[3], cell) {
            Ok(f) => f.trunc(),
            Err(e) => return e,
        };

        let cumulative = match self.get_boolean(&args[4], cell) {
            Ok(b) => b,
            Err(e) => return e,
        };

        if sample_s < 0.0 || sample_s > f64::min(number_sample, population_s) {
            return CalcResult::Error {
                error: Error::NUM,
                origin: cell,
                message: "Invalid parameters for HYPGEOM.DIST".to_string(),
            };
        }

        if sample_s < f64::max(0.0, number_sample + population_s - number_pop) {
            return CalcResult::Error {
                error: Error::NUM,
                origin: cell,
                message: "Invalid parameters for HYPGEOM.DIST".to_string(),
            };
        }

        if number_sample <= 0.0 || number_sample > number_pop {
            return CalcResult::Error {
                error: Error::NUM,
                origin: cell,
                message: "Invalid parameters for HYPGEOM.DIST".to_string(),
            };
        }

        if population_s <= 0.0 || population_s > number_pop {
            return CalcResult::Error {
                error: Error::NUM,
                origin: cell,
                message: "Invalid parameters for HYPGEOM.DIST".to_string(),
            };
        }

        let n_pop = number_pop as u64;
        let k_pop = population_s as u64;
        let n_sample = number_sample as u64;
        let k = sample_s as u64;

        let dist = match Hypergeometric::new(n_pop, k_pop, n_sample) {
            Ok(d) => d,
            Err(_) => {
                return CalcResult::new_error(
                    Error::NUM,
                    cell,
                    "Invalid parameters for hypergeometric distribution".to_string(),
                )
            }
        };

        let prob = if cumulative { dist.cdf(k) } else { dist.pmf(k) };

        if !prob.is_finite() {
            return CalcResult::Error {
                error: Error::NUM,
                origin: cell,
                message: "Invalid result for HYPGEOM.DIST".to_string(),
            };
        }

        CalcResult::Number(prob)
    }
}