xsum 0.1.5

Fast Exact Summation of Floating-Point Numbers
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
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

use crate::{Xsum, XsumAuto, XsumLarge, XsumSmall};

/// `XsumVariant` provides an easy way to manage multiple xsum variants.
///
/// This is useful when you want to adjust behavior based on the input size.
/// For example, `XsumAuto` can automatically choose the appropriate xsum variant,
/// which is useful when the input size is unknown.
/// However, it has some overhead to determine when to switch from `XsumSmall` to `XsumLarge`.
///
/// If you already know the input size in advance, you can directly select the
/// most suitable xsum variant, avoiding unnecessary overhead.
///
/// # Example
///
/// ```
/// use xsum::{Xsum, XsumVariant, XsumAuto, XsumLarge, XsumSmall, constants::XSUM_THRESHOLD};
///
/// let vec = vec![1.0; 2_000];
/// let mut xVariant = if vec.len() < XSUM_THRESHOLD {
///   XsumVariant::Small(XsumSmall::new())
/// } else {
///   XsumVariant::Large(XsumLarge::new())
/// };
/// xVariant.add_list(&vec);
/// assert_eq!(xVariant.sum(), 2_000.0);
/// ```
pub enum XsumVariant {
    Small(XsumSmall),
    Large(XsumLarge),
    Auto(XsumAuto),
}

impl Xsum for XsumVariant {
    /// Returns the default value. See [`XsumVariant::default`] for more information.
    fn new() -> Self {
        Self::default()
    }

    /// ```
    /// use xsum::{Xsum, XsumVariant, XsumAuto, XsumLarge, XsumSmall, constants::XSUM_THRESHOLD};
    ///
    /// let vec = vec![1.0; 2_000];
    /// let mut xVariant = if vec.len() < XSUM_THRESHOLD {
    ///   XsumVariant::Small(XsumSmall::new())
    /// } else {
    ///   XsumVariant::Large(XsumLarge::new())
    /// };
    /// xVariant.add_list(&vec);
    /// assert_eq!(xVariant.sum(), 2_000.0);
    /// ```
    fn add_list(&mut self, vec: &[f64]) {
        match self {
            Self::Small(xsum_small) => xsum_small.add_list(vec),
            Self::Large(xsum_large) => xsum_large.add_list(vec),
            Self::Auto(xsum_auto) => xsum_auto.add_list(vec),
        }
    }

    /// ```
    /// use xsum::{Xsum, XsumVariant, XsumAuto, XsumLarge, XsumSmall, constants::XSUM_THRESHOLD};
    ///
    /// let vec = vec![1.0; 2_000];
    /// let mut xVariant = if vec.len() < XSUM_THRESHOLD {
    ///   XsumVariant::Small(XsumSmall::new())
    /// } else {
    ///   XsumVariant::Large(XsumLarge::new())
    /// };
    /// for val in vec {
    ///   xVariant.add(val);
    /// }
    /// assert_eq!(xVariant.sum(), 2_000.0);
    /// ```
    fn add(&mut self, value: f64) {
        match self {
            Self::Small(xsum_small) => xsum_small.add(value),
            Self::Large(xsum_large) => xsum_large.add(value),
            Self::Auto(xsum_auto) => xsum_auto.add(value),
        }
    }

    /// ```
    /// use xsum::{Xsum, XsumVariant, XsumAuto, XsumLarge, XsumSmall, constants::XSUM_THRESHOLD};
    ///
    /// let vec = vec![1.0; 2_000];
    /// let mut xVariant = if vec.len() < XSUM_THRESHOLD {
    ///   XsumVariant::Small(XsumSmall::new())
    /// } else {
    ///   XsumVariant::Large(XsumLarge::new())
    /// };
    /// xVariant.add_list(&vec);
    /// assert_eq!(xVariant.sum(), 2_000.0);
    /// ```
    fn sum(&mut self) -> f64 {
        match self {
            Self::Small(xsum_small) => xsum_small.sum(),
            Self::Large(xsum_large) => xsum_large.sum(),
            Self::Auto(xsum_auto) => xsum_auto.sum(),
        }
    }

    /// ```
    /// use xsum::{Xsum, XsumVariant, XsumAuto, XsumLarge, XsumSmall, constants::XSUM_THRESHOLD};
    ///
    /// let vec = vec![1.0; 2_000];
    /// let mut xVariant = if vec.len() < XSUM_THRESHOLD {
    ///   XsumVariant::Small(XsumSmall::new())
    /// } else {
    ///   XsumVariant::Large(XsumLarge::new())
    /// };
    /// xVariant.add_list(&vec);
    /// assert_eq!(xVariant.sum(), 2_000.0);
    /// xVariant.clear();
    /// assert_eq!(xVariant.sum(), 0.0);
    /// ```
    fn clear(&mut self) {
        match self {
            Self::Small(xsum_small) => xsum_small.clear(),
            Self::Large(xsum_large) => xsum_large.clear(),
            Self::Auto(xsum_auto) => xsum_auto.clear(),
        }
    }
}

impl Default for XsumVariant {
    /// Returns `XsumVariant::Small(XsumSmall::new())`
    fn default() -> Self {
        Self::Small(XsumSmall::new())
    }
}