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
use crate::numbers::*;

trait Arrays {
    fn new(self) -> Array;
}

impl Arrays for Vec<Array> {
    fn new(self) -> Array {
        let is_valid_dimensions = match self.split_first() {
            Some((first, elements)) => elements.iter().all(|item| *item.dimensions == *first.dimensions),
            None => true,
        };

        if is_valid_dimensions {
            let mut dimensions = vec![self.len()];
            dimensions.append(&mut self.first().unwrap().dimensions.clone());

            let values = self.into_iter().map(|array| array.values).flatten().collect::<Vec<Float>>();

            Array { dimensions, values }
        } else {
            panic!("error: invalid dimensions supplied");
        }
    }
}

impl Arrays for Vec<Float> {
    fn new(self) -> Array {
        Array { dimensions: vec![self.len()], values: self }
    }
}

struct Array {
    dimensions: Vec<usize>,
    values: Vec<Float>,
}

impl Array {
}

macro_rules! array {
    ( $( $x:expr ),* ) => {
        {
            let mut values = Vec::new();

            $(
                values.push($x);
            )*

            Arrays::new(values)
        }
    };
}

struct Tensor {
    values: Array,
}

impl Tensor {
    #[inline]
    pub fn new(values: Array) {
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_new() {
        let matrix = array![array![
            array![0.0], array![1.0]
        ],
        array![
            array![2.0], array![3.0]
        ],
        array![
            array![4.0], array![5.0]
        ]];

        assert_eq!(matrix.dimensions, vec![3, 2, 1]);
        assert_eq!(matrix.values, (0..=5).map(|x| x as Float).collect::<Vec<Float>>());
    }

    #[test]
    fn test_invalid_dimensions() {
        let matrix = array![array![
            array![0.0], array![1.0]
        ],
        array![
            array![2.0, 3.0], array![4.0]
        ]];
    }
}