black-jack 0.1.0

DataFrame / Series / general data processing in Rust
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

//! Mostly internal level macros for implementing ops per series type

/// Implement `IntoIter` for a dtype (ie. f64) for `Series`
#[macro_export]
macro_rules! impl_series_into_iter {
    // Use: impl_series_into_iter(i32)
    ($primitive:ty) => {
        impl IntoIterator for Series<$primitive> {
            type Item = $primitive;
            type IntoIter = IntoIter<$primitive>;

            fn into_iter(self) -> Self::IntoIter {
                self.values.into_iter()
            }
        }
    };
}

/// Implement various inplace numeric operations for a Series
/// ie. `series += 1`
#[macro_export]
macro_rules! impl_series_by_series_op_inplace {

    // Use: impl_series_by_series_op_inplace!(MulAssign, mul_assign, *=)
    ($operation:ident, $func_name:ident, $op:tt) => {
        impl<T> $operation<Series<T>> for Series<T>
            where T: BlackJackData + $operation
        {
            fn $func_name(&mut self, other: Series<T>) {
                let _ = self.values
                    .iter_mut()
                    .zip(other.values.into_iter())
                    .map(|(v, o)| *v $op o)
                    .collect::<Vec<()>>();
            }
        }
    }
}

/// Implement series by series operations
/// ie. `series1 + series2`
#[macro_export]
macro_rules! impl_series_by_series_op {

    // Use: impl_series_by_series_op(Add, add, +)
    ($operation:ident, $func_name:ident, $op:tt) => {

        /// Support `series + series`
        impl<T> $operation for Series<T>
            where
                T: $operation<Output=T> + BlackJackData,
        {
            type Output = Result<Series<T>, BlackJackError>;

            fn $func_name(self, other: Series<T>) -> Self::Output {
                if self.len() != other.len() {
                    Err(BlackJackError::ValueError(
                        format!("Source series is of size: {}, and other is of size: {}", &self.len(), &other.len())
                    ))
                } else {
                    let result = self.values
                        .into_iter()
                        .zip(other.values.into_iter())
                        .map(|(x1, x2)| x1 $op x2)
                        .collect();
                    Ok(Series::from_vec(result))
                }


            }
        }

    }
}