Xuanyi Fu Blog
0%

Matrix Code Templates

Posted on Edited on
Symbols count in article: 33

Code Template for Matrix.

Point

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
struct Point{
  int x_;
  int y_;
  
  auto Up() const {
    return Point{x_ - 1, y_};
  }
  
  auto Down() const {
    return Point{x_ + 1, y_};
  }
  
  auto Left() const {
    return Point{x_, y_ - 1};
  }
  
  auto Right() const {
    return Point{x_, y_ + 1};
  }
  
  auto Adj2() const {
    return std::array<Point, 2> {
      Point{x_ + 1, y_},
      Point{x_, y_ + 1},
    };
  }
  
  auto Adj4() const {
    return std::array<Point, 4> {
      Point{x_ - 1, y_},
      Point{x_, y_ - 1},
      Point{x_ + 1, y_},
      Point{x_, y_ + 1},
    };
  }
  
  auto Adj8() const {
    return std::array<Point, 8> {
      Point{x_ - 1, y_},
      Point{x_, y_ - 1},
      Point{x_ + 1, y_},
      Point{x_, y_ + 1},
      Point{x_ + 1, y_ + 1},
      Point{x_ + 1, y_ - 1},
      Point{x_ - 1, y_ + 1},
      Point{x_ - 1, y_ - 1}
    };
  }
    
  friend Point operator+(Point l, Point r) {
    return Point{l.x_ + r.x_, l.y_ + r.y_};
  }
  
  friend bool operator==(Point l, Point r) {
    return l.x_ == r.x_ && l.y_ == r.y_;
  }
  
  friend bool operator!=(Point l, Point r) {
    return !(l == r);
  }
};

auto PointDir4() {
  return std::array<Point, 4>{
    Point{-1, 0},
    Point{0, -1},
    Point{1, 0},
    Point{0, 1}
  };
}

auto PointDir8() {
 return std::array<Point, 8>{
    Point{-1, 0},
    Point{-1, 1},
    Point{0, 1},
    Point{1, 1},
    Point{1, 0},
    Point{1, -1},
    Point{0, -1},
    Point{-1, -1}
  }; 
}

Matrix

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
struct Matrix{
  
  Matrix(std::vector<std::vector<int>>& m)
  :row_(m.size())
  ,col_(m.front().size())
  ,m_{m}
  {}
  
  bool Valid(Point pt) const {
    return pt.x_ < row_ && pt.x_ >= 0 
      && pt.y_ < col_ && pt.y_ >= 0;
  }
  
  int At(Point pt) const {
    assert(Valid(pt));
    return m_[pt.x_][pt.y_];
  }
  
  void Set(Point pt, int val) {
    assert(Valid(pt));
    m_[pt.x_][pt.y_] = val;
  }
  
  int Id(Point pt) const {
    assert(Valid(pt));
    return pt.x_ * col_ + pt.y_;
  }
  
  int Size() const {
    return row_ * col_;
  }
  
  template<typename Func>
  void ForEachPoint(Func func) {
    for(int r = 0; r < row_; ++r) {
      for(int c = 0; c < col_; ++c) {
        func(Point{r, c});
      }
    }
  }
  
  void Print() const {
    std::printf("---r:%d---c:%d---\n\n", row_, col_);
    for(int r = 0; r < row_; ++r) {
      for(int c = 0; c < col_; ++c) {
        std::printf("%d ", At(Point{r, c}));
      }
      std::puts("\n");
    }
  }
  
  const int row_;
  const int col_;
  std::vector<std::vector<int>>& m_;
};