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

use std::borrow::{Borrow, Cow};
use std::hash::Hash;

use super::Block;
use algos::join::{JoinOp, HashJoin};
use indexer::Indexer;
use traits::{Slicer, IndexerIndex, RowIndex, Append, Concatenation, Join};


impl<'v, 'i, 'c, V, I, C> Append<'c> for Block<'v, 'i, 'c, V, I, C>
    where V: Clone,
          I: Clone + Eq + Hash,
          C: Clone + Eq + Hash
{
    fn append<'o>(&'c self, other: &'o Self) -> Self {
        assert!(self.columns == other.columns, "columns must be identical");

        let new_index = self.index.append(&other.index);

        let mut new_values: Vec<Cow<Vec<V>>> = Vec::with_capacity(self.columns.len());
        for (svalues, ovalues) in self.values.iter().zip(&other.values) {
            // ToDo: avoid clone
            let mut new_value = svalues.clone().into_owned();
            new_value.append(&mut ovalues.clone().into_owned());
            new_values.push(Cow::Owned(new_value));
        }

        Block::from_cow(new_values,
                        Cow::Owned(new_index),
                        Cow::Borrowed(self.columns.borrow()))
    }
}

impl<'v, 'i, 'c, V, I, C> Concatenation<'i> for Block<'v, 'i, 'c, V, I, C>
    where V: Clone,
          I: Clone + Eq + Hash,
          C: Clone + Eq + Hash
{
    fn concat<'o>(&'i self, other: &'o Self) -> Self {
        assert!(self.index == other.index, "index must be identical");

        let new_columns = self.columns.append(&other.columns);

        let mut new_values: Vec<Cow<Vec<V>>> = Vec::with_capacity(new_columns.len());
        for values in self.values.iter().chain(&other.values) {
            // ToDo: avoid clone / into_owned()
            // new_values.push(Cow::Borrowed(values.borrow()));
            new_values.push(Cow::Owned(values.clone().into_owned()));
        }

        Block::from_cow(new_values,
                        Cow::Borrowed(self.index.borrow()),
                        Cow::Owned(new_columns))
    }
}

impl<'v, 'i, 'c, V, I, C> Join for Block<'v, 'i, 'c, V, I, C>
    where V: Clone,
          I: Clone + Eq + Hash,
          C: Clone + Eq + Hash
{
    fn join_inner(&self, other: &Self) -> Self {

        let (new_index, lindexer, rindexer) = HashJoin::inner(&self.index.values,
                                                              &other.index.values);
        let new_columns = self.columns.append(&other.columns);

        let mut new_values: Vec<Cow<Vec<V>>> = Vec::with_capacity(new_columns.len());

        for values in self.ilocs(&lindexer).values {
            new_values.push(values);
        }
        for values in other.ilocs(&rindexer).values {
            new_values.push(values);
        }

        Block::from_cow(new_values,
                        Cow::Owned(Indexer::new(new_index)),
                        Cow::Owned(new_columns))
    }
}