-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathDgBoundedHexC2RF2D.cpp
146 lines (107 loc) · 3.72 KB
/
DgBoundedHexC2RF2D.cpp
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
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
////////////////////////////////////////////////////////////////////////////////
//
// DgBoundedHexC2RF2D.cpp: DgBoundedHexC2RF2D class implementation
//
// Version 6.1 - Kevin Sahr, 5/23/13
//
////////////////////////////////////////////////////////////////////////////////
#include <limits>
#include <cstdint>
#include "DgBoundedHexC2RF2D.h"
#include "DgDiscRF.h"
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
DgBoundedHexC2RF2D::DgBoundedHexC2RF2D
(const DgDiscRF<DgIVec2D, DgDVec2D, long double>& rf,
const DgIVec2D& lowerLeft, const DgIVec2D& upperRight)
: DgBoundedRF2D (rf, lowerLeft, upperRight)
{
DgIVec2D magVec = upperRight - lowerLeft + DgIVec2D(1, 1);
size_ = magVec.i() / 3 * magVec.j();
if (magVec.i() != static_cast<int>((3 * size_ / magVec.j())))
{
report("DgBoundedHexC2RF2D::DgBoundedHexC2RF2D() invalid size setting "
"due to possible overflow", DgBase::Warning);
validSize_ = false;
}
else validSize_ = true;
setLastAdd(addFromSeqNum(size() - 1));
} // DgBoundedHexC2RF2D::DgBoundedHexC2RF2D
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
DgIVec2D&
DgBoundedHexC2RF2D::incrementAddress (DgIVec2D& add) const
{
if (!validAddress(add)) return add = invalidAdd();
else if (add == upperRight() || add == endAdd()) return add = endAdd();
do {
if (add.j() == upperRight().j())
{
add = DgIVec2D(add.i() + 1, lowerLeft().j());
}
else
{
add.setJ(add.j() + 1);
}
} while (((add.i() + add.j()) % 3) && add != upperRight());
if (add == upperRight() && ((add.i() + add.j()) % 3)) add = endAdd();
return add;
} // DgIVec2D& DgBoundedHexC2RF2D::incrementAddress
////////////////////////////////////////////////////////////////////////////////
DgIVec2D&
DgBoundedHexC2RF2D::decrementAddress (DgIVec2D& add) const
{
if (!validAddress(add) || add == lowerLeft()) return add = invalidAdd();
do {
if (add.j() == lowerLeft().j())
{
add = DgIVec2D(add.i() - 1, upperRight().j());
}
else
{
add.setJ(add.j() - 1);
}
} while (((add.i() + add.j()) % 3) && add != lowerLeft());
if (add == lowerLeft() && ((add.i() + add.j()) % 3)) add = invalidAdd();
return add;
} // DgIVec2D& DgBoundedHexC2RF2D::decrementAddress
////////////////////////////////////////////////////////////////////////////////
std::uint64_t
DgBoundedHexC2RF2D::seqNumAddress (const DgIVec2D& add) const
{
DgIVec2D tVec = add - lowerLeft();
std::uint64_t sNum = tVec.i() * numI() / 3;
switch (tVec.i() % 3)
{
case 0: sNum += tVec.j() / 3;
break;
case 1: sNum += (tVec.j() - 2) / 3;
break;
case 2: sNum += (tVec.j() - 1) / 3;
break;
}
if (!zeroBased()) sNum++;
return sNum;
}
////////////////////////////////////////////////////////////////////////////////
DgIVec2D
DgBoundedHexC2RF2D::addFromSeqNum (std::uint64_t sNum) const
{
DgIVec2D res;
if (!zeroBased())
sNum--;
res.setI((sNum * 3) / numI());
res.setJ((sNum * 3) % numI());
switch (res.i() % 3)
{
case 0: break;
case 1: res.setJ(res.j() + 2);
break;
case 2: res.setJ(res.j() + 1);
break;
}
res += lowerLeft();
return res;
} // DgIVec2D DgBoundedHexC2RF2D::addFromSeqNum
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////