brassfibre 0.2.0

Provides multiple-dtype columner storage, known as DataFrame in pandas/R
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
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

//! Common Traits

/// Indexing methods for non-labeled Array / Indexer
pub use nullvec::prelude::Slicer;

/// Indexing methods for Indexer
pub trait IndexerIndex: Slicer {
    type Key;

    fn contains(&self, label: &Self::Key) -> bool;
    fn push(&mut self, label: Self::Key);
    fn get_loc(&self, label: &Self::Key) -> usize;
    fn get_locs(&self, labels: &[Self::Key]) -> Vec<usize>;

    // temp
    fn init_state(&self);
}

/// Indexing methods for Index(Row)
pub trait RowIndex<'s>: Sized {
    // 's: lifetime of myself

    type Key;
    type Row;

    fn len(&'s self) -> usize;

    fn head(&'s self, n: usize) -> Self {
        let indexer: Vec<usize> = (0..n).collect();
        self.ilocs(&indexer)
    }

    fn tail(&'s self, n: usize) -> Self {
        let len = self.len();
        let indexer: Vec<usize> = ((len - n)..len).collect();
        self.ilocs(&indexer)
    }

    fn reindex<'l>(&'s self, labels: &'l [Self::Key]) -> Self;
    fn reindex_by_index<'l>(&'s self, locations: &'l [usize]) -> Self;

    // selection

    /// Get a single value corresponding to given label (slice by LOCation)
    fn loc<'l>(&'s self, label: &'l Self::Key) -> Self::Row;

    /// Get a single value corresponding to given index (slice by Index LOCation)
    fn iloc<'l>(&'s self, location: &'l usize) -> Self::Row;

    /// Slice using given labels (slice by LOCationS)
    fn locs<'l>(&'s self, labels: &'l [Self::Key]) -> Self {
        self.reindex(labels)
    }

    /// Slice using given indices (slice by Index LOCationS)
    fn ilocs<'l>(&'s self, locations: &'l [usize]) -> Self {
        self.reindex_by_index(locations)
    }

    /// Slice using given Vec<bool> (slice by Bool LOCationS)
    fn blocs<'l>(&'s self, flags: &'l [bool]) -> Self;
}

/// Indexing methods for Columns
pub trait ColIndex<'s>: Sized {
    // 's: lifetime of myself

    type Key;
    type Column;

    /// Get column using label
    fn get<'l>(&'s self, label: &'l Self::Key) -> Self::Column;

    /// Get column using given index
    fn iget<'l>(&'s self, label: &'l usize) -> Self::Column;

    /// Slice columns using labels
    fn gets<'l>(&'s self, labels: &'l [Self::Key]) -> Self;

    /// Slice columns given indices
    fn igets<'l>(&'s self, locations: &'l [usize]) -> Self;

    // ToDo: Add .insert
    // ToDo bgets
}

/// Concatenate along row
pub trait Append<'s>: Sized {
    fn append<'o>(&'s self, other: &'o Self) -> Self;
}

/// Concatenate along columns
pub trait Concatenation<'s>: Sized {
    fn concat<'o>(&'s self, other: &'o Self) -> Self;
}

/// Join by index
pub trait Join: Sized {
    fn join_inner(&self, other: &Self) -> Self;
}

pub trait Apply<'s, R> {
    // R: Type function returns, dummy to avoid unconstrained lifetime parameter

    type In;
    type FOut;
    type Out;

    fn apply<'f>(&'s self, func: &'f Fn(&Self::In) -> Self::FOut) -> Self::Out;
}

pub trait BasicAggregation<'s> {
    // result which can keep current dtype
    type Kept;
    // result for count (to usize or its container)
    type Counted;

    fn sum(&'s self) -> Self::Kept;
    fn count(&'s self) -> Self::Counted;
}

pub trait NumericAggregation<'s> {
    // result which is coerced (to f64 or its container)
    type Coerced;

    fn mean(&'s self) -> Self::Coerced;
    fn var(&'s self) -> Self::Coerced;
    fn unbiased_var(&'s self) -> Self::Coerced;
    fn std(&'s self) -> Self::Coerced;
    fn unbiased_std(&'s self) -> Self::Coerced;
}

pub trait ComparisonAggregation<'s> {
    type Kept;

    fn min(&'s self) -> Self::Kept;
    fn max(&'s self) -> Self::Kept;
}

pub trait Description<'s>
    : BasicAggregation<'s> + NumericAggregation<'s> + ComparisonAggregation<'s> {
    type Described;

    fn describe(&'s self) -> Self::Described;
}