nd_vector 0.1.0

[WIP] Lengthen! Shrink! Iterate! Scale! Twist and turn to your imagination along any dimension on a vector!
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

use std::default::Default;
use crate::{usage_types::coordinates::Coordinate, VectorGrid};


impl<ItemType: Default + Clone> VectorGrid<ItemType> {

    /// Inserts an `amount` of layers filled with default items at a specific `distance` along a `dimension`
    pub fn extend_dimension(
        &mut self,
        dimension: usize,
        distance: usize,
        amount: usize
    ) {

        if dimension == self.defined_shape.len() {
            self.items.splice(0..0, vec![Default::default(); self.step_sizes()[dimension] * amount]);
            return;
        }
        let mut i = distance * self.step_sizes()[dimension + 1];
        self.defined_shape[dimension] = self.defined_shape[dimension].saturating_add(amount);
        
        let step_sizes = self.step_sizes();
        while i < self.items.len() {
            self.items.splice(i..i, vec![Default::default(); amount * step_sizes[dimension]]);
            i += step_sizes[dimension + 1];
        }
    }


    // todo remove
    pub fn extend_inwards(&mut self, axis: usize, amount: usize) {

        let mut i = 0;
        match self.defined_shape.get_mut(axis) {
            Some(dimension) => *dimension = dimension.saturating_add(amount),
            None => {
                self.items.splice(0..0, vec![Default::default(); self.step_sizes()[axis] * amount]);
                return;
            },
        }
        let step_sizes = self.step_sizes();
        while i < self.items.len() {
            self.items.splice(i..i, vec![Default::default(); amount * step_sizes[axis]]);
            i += step_sizes[axis + 1];
        }
    }

    pub fn extend_outwards(&mut self, axis: usize, amount: usize) {

        let mut i = match self.step_sizes().get(axis + 1) {
            Some(i) => *i as usize,
            None => {
                //self.items.extend_from_slice(&vec![Default::default(); self.step_sizes()[axis] * amount]);
                return;
            },
        };
        self.defined_shape[axis] = self.defined_shape[axis].saturating_add(amount);
          
        let step_sizes = self.step_sizes();
        while i < self.items.len() {
            self.items.splice(i..i, vec![Default::default(); amount * step_sizes[axis]]);
            i += step_sizes[axis + 1];
        }
    }

    pub fn scale_to_encompace(&mut self, coordinate: &mut Coordinate) {
        for (i, dimension) in coordinate.iter_mut().enumerate() {
            if *dimension < 0 {
                self.extend_inwards(i, -*dimension as usize);
                *dimension = 0;
            } else if i < self.defined_shape.len() {
                if *dimension as usize > self.defined_shape[i].get() {
                    self.extend_outwards(i, *dimension as usize - self.defined_shape[i].get());
                }
            } else {
                break;
            }
        }

        let corner_index = self.get_coordinate_index(&coordinate);
        if self.items.len() < corner_index {
            self.extend(corner_index - self.items.len())
        }
    }

    pub fn extend(&mut self, amount: usize) {
        self.items.extend(vec![Default::default(); amount])
    }
}