nsys-mat 0.5.4

Dynamically sized 2d storage with rectangular iterators and in-place resizing
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

#[cfg(feature="serde")]
use serde::{Deserialize, Serialize};

use super::{Coordinate, Dimensions};

/// Rectangle defined by inclusive minimum and maximum coordinates.
///
/// ```
/// # use mat::Rectangle;
/// let rectangle = Rectangle::from (((1, 2).into(), (5, 3).into()));
/// assert_eq!(rectangle.height(), 5);
/// assert_eq!(rectangle.width(),  3);
/// assert_eq!(rectangle.height(), rectangle.dimensions.rows);
/// assert_eq!(rectangle.width(),  rectangle.dimensions.columns);
/// assert_eq!(rectangle.contains ((0, 0).into()), false);
/// assert_eq!(rectangle.contains ((4, 3).into()), true);
/// ```
#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
#[derive(Clone, Eq, Debug, Default, PartialEq)]
pub struct Rectangle {
  pub coordinate : Coordinate,
  pub dimensions : Dimensions
}

impl Rectangle {
  #[inline]
  pub const fn width (&self) -> usize {
    self.dimensions.columns
  }
  #[inline]
  pub const fn height (&self) -> usize {
    self.dimensions.rows
  }
  #[inline]
  pub const fn min (&self) -> Coordinate {
    self.coordinate
  }
  /// Max is inclusive: this is the lower right corner element of the rectangle
  #[inline]
  pub const fn max (&self) -> Coordinate {
    Coordinate {
      row:    self.coordinate.row + self.height() - 1,
      column: self.coordinate.column + self.width() - 1,
    }
  }
  #[inline]
  pub const fn upper_left (&self) -> Coordinate {
    self.min()
  }
  #[inline]
  pub const fn upper_right (&self) -> Coordinate {
    Coordinate {
      row:    self.min().row,
      column: self.max().column
    }
  }
  #[inline]
  pub const fn lower_right (&self) -> Coordinate {
    self.max()
  }
  #[inline]
  pub const fn lower_left (&self) -> Coordinate {
    Coordinate {
      row:    self.max().row,
      column: self.min().column
    }
  }
  #[inline]
  pub fn row (&self, row : usize) -> Option <Self> {
    if row < self.height() {
      let coordinate = self.min() + (row, 0).into();
      let dimensions = (1, self.width()).into();
      Some (Rectangle { coordinate, dimensions })
    } else {
      None
    }
  }
  #[inline]
  pub fn column (&self, column : usize) -> Option <Self> {
    if column < self.width() {
      let coordinate = self.min() + (0, column).into();
      let dimensions = (self.height(), 1).into();
      Some (Rectangle { coordinate, dimensions })
    } else {
      None
    }
  }
  /// Rows * columns
  #[inline]
  pub const fn area (&self) -> usize {
    self.height() * self.width()
  }
  /// Return true if the coordinate is between `min` and `max` (inclusive)
  #[inline]
  pub fn contains (&self, Coordinate { row, column } : Coordinate) -> bool {
    self.contains_rc (row, column)
  }
  #[inline]
  pub fn contains_rc (&self, row : usize, column : usize) -> bool {
    self.min().row    <= row    && row    <= self.max().row &&
    self.min().column <= column && column <= self.max().column
  }
  #[inline]
  pub fn iter (&self) -> impl Iterator <Item = Coordinate> {
    let row    = self.min().row;
    let col    = self.min().column;
    let height = self.height();
    let width  = self.width();
    (row..row + height).map (move |row| std::iter::repeat (row)
      .zip (col..col + width)).flatten().map (Into::into)
  }
} // end impl Rectangle
impl From <(Coordinate, Dimensions)> for Rectangle {
  fn from ((coordinate, dimensions) : (Coordinate, Dimensions)) -> Self {
    Rectangle { coordinate, dimensions }
  }
}
impl From <Dimensions> for Rectangle {
  fn from (dimensions : Dimensions) -> Self {
    Rectangle { coordinate: (0, 0).into(), dimensions }
  }
}