The open source OpenXR runtime
a/math: Add floating point conversion methods to Rational
+41
-4
+18
src/xrt/auxiliary/math/m_rational.hpp
+18
src/xrt/auxiliary/math/m_rational.hpp
···
119
119
{
120
120
return Rational{denominator - numerator, denominator}.withNonNegativeDenominator();
121
121
}
122
+
123
+
/*!
124
+
* Get an approximation of this value as a float.
125
+
*/
126
+
constexpr float
127
+
as_float() const noexcept
128
+
{
129
+
return static_cast<float>(numerator) / static_cast<float>(denominator);
130
+
}
131
+
132
+
/*!
133
+
* Get an approximation of this value as a double.
134
+
*/
135
+
constexpr double
136
+
as_double() const noexcept
137
+
{
138
+
return static_cast<double>(numerator) / static_cast<double>(denominator);
139
+
}
122
140
};
123
141
124
142
/*!
+23
-4
tests/tests_rational.cpp
+23
-4
tests/tests_rational.cpp
···
28
28
};
29
29
} // namespace Catch
30
30
31
-
TEMPLATE_TEST_CASE("Rational", "", int32_t, uint32_t)
31
+
TEMPLATE_TEST_CASE("Rational", "", int32_t, uint32_t, int64_t, uint64_t)
32
32
{
33
33
using R = Rational<TestType>;
34
34
using T = TestType;
35
35
CHECK(R{1, 1} == R::simplestUnity());
36
36
CHECK((R::simplestUnity() * T{1}) == R::simplestUnity());
37
37
CHECK((T{1} * R::simplestUnity()) == R::simplestUnity());
38
+
CHECK(R::simplestUnity().as_float() == 1.0f);
39
+
CHECK(R::simplestUnity().as_double() == 1.0);
38
40
39
41
CHECK(R{5, 8}.reciprocal() == R{8, 5});
40
42
41
43
CHECK(R{5, 8}.complement() == R{3, 8});
42
44
CHECK(R{8, 8}.complement() == R{0, 8});
43
45
44
-
if constexpr (std::is_signed<TestType>::value) {
45
-
}
46
+
CHECK(R{0, 8}.as_float() == 0.0f);
47
+
CHECK(R{0, 8}.as_double() == 0.0);
46
48
47
49
CHECK(R{5, 8}.withNonNegativeDenominator() == R{5, 8});
48
50
···
90
92
CHECK((val / T{1}) == valNonNegativeDenominator);
91
93
}
92
94
93
-
// Check all our predicates
95
+
// Check all our predicates, and our float convesions
94
96
{
95
97
// This is divide by zero error, all should be false
96
98
R val{0, 0};
···
107
109
CHECK_FALSE(val.isBetweenZeroAndOne());
108
110
CHECK_FALSE(val.isUnity());
109
111
CHECK_FALSE(val.isOverUnity());
112
+
113
+
CHECK(val.as_float() == 0.0f);
114
+
CHECK(val.as_double() == 0.0);
110
115
}
111
116
112
117
{
···
116
121
CHECK(val.isBetweenZeroAndOne());
117
122
CHECK_FALSE(val.isUnity());
118
123
CHECK_FALSE(val.isOverUnity());
124
+
125
+
CHECK(val.as_float() > 0.0f);
126
+
CHECK(val.as_float() < 1.0f);
127
+
CHECK(val.as_double() > 0.0);
128
+
CHECK(val.as_double() < 1.0);
119
129
}
120
130
121
131
{
···
125
135
CHECK_FALSE(val.isBetweenZeroAndOne());
126
136
CHECK(val.isUnity());
127
137
CHECK_FALSE(val.isOverUnity());
138
+
139
+
CHECK(val.as_float() == 1.0f);
140
+
CHECK(val.as_double() == 1.0);
128
141
}
129
142
{
130
143
R val = R::simplestUnity();
···
133
146
CHECK_FALSE(val.isBetweenZeroAndOne());
134
147
CHECK(val.isUnity());
135
148
CHECK_FALSE(val.isOverUnity());
149
+
150
+
CHECK(val.as_float() == 1.0f);
151
+
CHECK(val.as_double() == 1.0);
136
152
}
137
153
{
138
154
R val{8, 5};
···
141
157
CHECK_FALSE(val.isBetweenZeroAndOne());
142
158
CHECK_FALSE(val.isUnity());
143
159
CHECK(val.isOverUnity());
160
+
161
+
CHECK(val.as_float() > 1.0f);
162
+
CHECK(val.as_double() > 1.0);
144
163
}
145
164
}