29package com.jogamp.opengl.test.junit.math;
33import org.junit.Assert;
34import org.junit.BeforeClass;
36import org.junit.FixMethodOrder;
37import org.junit.runners.MethodSorters;
39import com.jogamp.junit.util.JunitTracer;
40import com.jogamp.math.FloatUtil;
42@FixMethodOrder(MethodSorters.NAME_ASCENDING)
46 static boolean deltaMachEpsLEQEpsilon;
47 static boolean deltaFixedEpsLEQEpsilon;
52 System.err.println(
"Machine Epsilon: "+MACH_EPSILON);
54 System.err.println(
"Float MIN: "+Float.MIN_VALUE);
56 final float deltaMachEpsMin = Math.abs(MACH_EPSILON-Float.MIN_VALUE);
57 deltaMachEpsLEQEpsilon =
FloatUtil.
compare(deltaMachEpsMin, MACH_EPSILON) <= 0;
59 final float deltaFixedEpsMin = Math.abs(MACH_EPSILON-Float.MIN_VALUE);
60 deltaFixedEpsLEQEpsilon =
FloatUtil.
compare(deltaFixedEpsMin, MACH_EPSILON) <= 0;
62 System.err.println(
"deltaMachEpsMin "+deltaMachEpsMin+
", deltaMachEpsLEQEpsilon "+deltaMachEpsLEQEpsilon);
63 System.err.println(
"deltaFixedEpsMin "+deltaFixedEpsMin+
", deltaFixedEpsLEQEpsilon "+deltaFixedEpsLEQEpsilon);
66 private void dumpTestWE(
final int tstNum,
final int expWE,
final float a,
final float b,
final float EPSILON) {
67 final float delta = a-b;
70 final String msgWE = ( expWE != compWE ) ?
"**** mismatch ****" :
" OK";
71 System.err.println(
"Print.WE."+tstNum+
": a: "+a+
", b: "+b+
" -> d "+delta+
", exp "+expWE+
", equal "+equalWE+
", comp "+compWE+
" - "+msgWE+
"testZeroNoEpsilon "+EPSILON);
73 private void dumpTestNE(
final int tstNum,
final int exp,
final float a,
final float b) {
74 final float delta = a-b;
77 final String msg = ( exp != comp ) ?
"**** mismatch ****" :
" OK";
78 System.err.println(
"Print.NE."+tstNum+
": a: "+a+
", b: "+b+
" -> d "+delta+
", exp "+exp+
", equal "+equal+
", comp "+comp+
" - "+msg);
83 testZeroWithEpsilon0(100);
91 testZeroWithEpsilon1(300, MACH_EPSILON);
97 testZeroNoEpsilon(i++,
true, 0f);
98 testZeroNoEpsilon(i++,
false, 0f-Float.MIN_VALUE);
99 testZeroNoEpsilon(i++,
false, 0f+Float.MIN_VALUE);
100 testZeroNoEpsilon(i++,
true, -0f);
101 testZeroNoEpsilon(i++,
true, +0f);
103 testZeroNoEpsilon(i++,
false, 0f+Float.MIN_VALUE);
104 testZeroNoEpsilon(i++,
false, 0f-Float.MIN_VALUE);
107 dumpTestNE(i++, 1, 0f, 0f+Float.MIN_VALUE);
108 dumpTestNE(i++, 1, 0f, 0f-Float.MIN_VALUE);
110 private void testZeroNoEpsilon(
final int tstNum,
final boolean exp,
final float a) {
112 final float delta = a-0f;
113 System.err.println(
"Zero."+tstNum+
": a: "+a+
", -> d "+delta+
", exp "+exp+
", zero "+zero);
114 Assert.assertEquals(
"Zero failed a: "+a, exp, zero);
116 private void testZeroWithEpsilon1(
int i,
final float EPSILON) {
117 System.err.println();
118 testZeroWithEpsilon1(i++,
true, 0f, EPSILON);
119 testZeroWithEpsilon1(i++,
true, 0f-EPSILON/2f, EPSILON);
120 testZeroWithEpsilon1(i++,
true, 0f+EPSILON/2f, EPSILON);
121 testZeroWithEpsilon1(i++,
true, 0f-Float.MIN_VALUE, EPSILON);
122 testZeroWithEpsilon1(i++,
true, 0f+Float.MIN_VALUE, EPSILON);
123 testZeroWithEpsilon1(i++,
true, -0f, EPSILON);
124 testZeroWithEpsilon1(i++,
true, +0f, EPSILON);
126 testZeroWithEpsilon1(i++,
false, 0f+EPSILON+Float.MIN_VALUE, EPSILON);
127 testZeroWithEpsilon1(i++,
false, 0f-EPSILON-Float.MIN_VALUE, EPSILON);
130 dumpTestWE(i++, 1, 0f, 0f+EPSILON-Float.MIN_VALUE, EPSILON);
131 dumpTestWE(i++, 1, 0f, 0f-EPSILON+Float.MIN_VALUE, EPSILON);
133 private void testZeroWithEpsilon1(
final int tstNum,
final boolean exp,
final float a,
final float EPSILON) {
135 final float delta = a-0f;
136 System.err.println(
"Zero."+tstNum+
": a: "+a+
", -> d "+delta+
", exp "+exp+
", zero "+zero+
", epsilon "+EPSILON);
137 Assert.assertEquals(
"Zero failed a: "+a+
" within "+EPSILON, exp, zero);
139 private void testZeroWithEpsilon0(
int i) {
140 System.err.println();
141 testZeroWithEpsilon0(i++,
true, 0f);
144 testZeroWithEpsilon0(i++,
true, 0f-Float.MIN_VALUE);
145 testZeroWithEpsilon0(i++,
true, 0f+Float.MIN_VALUE);
146 testZeroWithEpsilon0(i++,
true, -0f);
147 testZeroWithEpsilon0(i++,
true, +0f);
156 private void testZeroWithEpsilon0(
final int tstNum,
final boolean exp,
final float a) {
157 final boolean zero = FloatUtil.isZero(a);
158 final float delta = a-0f;
159 System.err.println(
"Zero."+tstNum+
": a: "+a+
", -> d "+delta+
", exp "+exp+
", zero "+zero+
", build-in epsilon "+FloatUtil.EPSILON);
160 Assert.assertEquals(
"Zero failed a: "+a+
" within build-in "+FloatUtil.EPSILON, exp, zero);
166 System.err.println();
167 testEqualsNoEpsilon(i++,
true, 0f, 0f);
169 testEqualsNoEpsilon(i++,
true, Float.MAX_VALUE, Float.MAX_VALUE);
170 testEqualsNoEpsilon(i++,
true, Float.MIN_VALUE, Float.MIN_VALUE);
171 testEqualsNoEpsilon(i++,
true, Float.MIN_NORMAL, Float.MIN_NORMAL);
172 testEqualsNoEpsilon(i++,
true, Float.NEGATIVE_INFINITY, Float.NEGATIVE_INFINITY);
173 testEqualsNoEpsilon(i++,
true, Float.POSITIVE_INFINITY, Float.POSITIVE_INFINITY);
174 testEqualsNoEpsilon(i++,
true, Float.NaN, Float.NaN);
175 testEqualsNoEpsilon(i++,
false, -0f, 0f);
176 testEqualsNoEpsilon(i++,
false, 0f, -0f);
179 dumpTestNE(i++, 0, 1f, 1f-MACH_EPSILON/2f);
180 dumpTestNE(i++, 0, 0f, 0f-MACH_EPSILON/2f);
181 dumpTestNE(i++, 0, 1f, 1f+MACH_EPSILON/2f);
182 dumpTestNE(i++, 0, 0f, 0f+MACH_EPSILON/2f);
183 dumpTestNE(i++, 0, 1f, 1f-Float.MIN_VALUE);
184 dumpTestNE(i++, 0, 0f, 0f-Float.MIN_VALUE);
185 dumpTestNE(i++, 0, 1f, 1f+Float.MIN_VALUE);
186 dumpTestNE(i++, 0, 0f, 0f+Float.MIN_VALUE);
188 private void testEqualsNoEpsilon(
final int tstNum,
final boolean exp,
final float a,
final float b) {
191 final float delta = a-b;
192 System.err.println(
"Equal.NE."+tstNum+
": a: "+a+
", b: "+b+
" -> d "+delta+
", exp "+exp+
", equal "+equal+
", comp "+comp);
193 Assert.assertEquals(
"Compare failed a: "+a+
", b: "+b, exp, 0==comp);
194 Assert.assertEquals(
"Equal failed a: "+a+
", b: "+b, exp, equal);
203 testEqualsWithEpsilon(200, MACH_EPSILON);
205 private void testEqualsWithEpsilon(
int i,
final float EPSILON) {
206 System.err.println();
207 testEqualsWithEpsilon(i++,
true, 0f, 0f, EPSILON);
208 testEqualsWithEpsilon(i++,
true, 1f, 1f-EPSILON/2f, EPSILON);
209 testEqualsWithEpsilon(i++,
true, 1f, 1f+EPSILON/2f, EPSILON);
210 testEqualsWithEpsilon(i++,
true, 1f, 1f-Float.MIN_VALUE, EPSILON);
211 testEqualsWithEpsilon(i++,
true, 1f, 1f-Float.MIN_NORMAL, EPSILON);
212 testEqualsWithEpsilon(i++,
true, 1f, 1f+Float.MIN_VALUE, EPSILON);
213 testEqualsWithEpsilon(i++,
true, Float.MAX_VALUE, Float.MAX_VALUE, EPSILON);
214 testEqualsWithEpsilon(i++,
true, Float.MIN_VALUE, Float.MIN_VALUE, EPSILON);
215 testEqualsWithEpsilon(i++,
true, Float.MIN_NORMAL, Float.MIN_NORMAL, EPSILON);
216 testEqualsWithEpsilon(i++,
true, Float.NEGATIVE_INFINITY, Float.NEGATIVE_INFINITY, EPSILON);
217 testEqualsWithEpsilon(i++,
true, Float.POSITIVE_INFINITY, Float.POSITIVE_INFINITY, EPSILON);
218 testEqualsWithEpsilon(i++,
true, Float.NaN, Float.NaN, EPSILON);
219 testEqualsWithEpsilon(i++,
true, -0f, 0f, EPSILON);
220 testEqualsWithEpsilon(i++,
true, 0f, -0f, EPSILON);
222 testEqualsWithEpsilon(i++,
false, 1f, 1f+EPSILON+Float.MIN_VALUE, EPSILON);
223 testEqualsWithEpsilon(i++,
false, 1f, 1f-EPSILON-Float.MIN_VALUE, EPSILON);
226 dumpTestWE(i++, 1, 1f, 1f+EPSILON-Float.MIN_VALUE, EPSILON);
227 dumpTestWE(i++, 1, 1f, 1f-EPSILON+Float.MIN_VALUE, EPSILON);
229 private void testEqualsWithEpsilon(
final int tstNum,
final boolean exp,
final float a,
final float b,
final float EPSILON) {
232 final float delta = a-b;
233 System.err.println(
"Equal.WE."+tstNum+
": a: "+a+
", b: "+b+
" -> d "+delta+
", exp "+exp+
", equal "+equal+
", comp "+comp);
234 Assert.assertEquals(
"Compare failed a: "+a+
", b: "+b+
" within "+EPSILON, exp, 0==comp);
235 Assert.assertEquals(
"Equal failed a: "+a+
", b: "+b+
" within "+EPSILON, exp, equal);
241 System.err.println();
242 testCompareNoEpsilon(i++, 0, 0f, 0f);
243 testCompareNoEpsilon(i++, 0, Float.MAX_VALUE, Float.MAX_VALUE);
244 testCompareNoEpsilon(i++, 0, Float.MIN_VALUE, Float.MIN_VALUE);
245 testCompareNoEpsilon(i++, 0, Float.MIN_NORMAL, Float.MIN_NORMAL);
246 testCompareNoEpsilon(i++, 0, Float.NEGATIVE_INFINITY, Float.NEGATIVE_INFINITY);
247 testCompareNoEpsilon(i++, 0, Float.POSITIVE_INFINITY, Float.POSITIVE_INFINITY);
248 testCompareNoEpsilon(i++, 0, Float.NaN, Float.NaN);
250 testCompareNoEpsilon(i++, 1, 1f, 0f);
251 testCompareNoEpsilon(i++, -1, 0f, 1f);
252 testCompareNoEpsilon(i++, 1, 0f, -1f);
253 testCompareNoEpsilon(i++, -1, -1f, 0f);
255 testCompareNoEpsilon(i++, 1, Float.MAX_VALUE, Float.MIN_VALUE);
256 testCompareNoEpsilon(i++, -1, Float.MIN_VALUE, Float.MAX_VALUE);
257 testCompareNoEpsilon(i++, 1, Float.POSITIVE_INFINITY, Float.NEGATIVE_INFINITY);
258 testCompareNoEpsilon(i++, -1, Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY);
260 testCompareNoEpsilon(i++, -1, 0f, Float.NaN);
261 testCompareNoEpsilon(i++, 1, Float.NaN, 0f);
263 testCompareNoEpsilon(i++, -1, -0f, 0f);
264 testCompareNoEpsilon(i++, 1, 0f, -0f);
267 dumpTestNE(i++, 0, 1f, 1f-MACH_EPSILON/2f);
268 dumpTestNE(i++, 0, 0f, 0f-MACH_EPSILON/2f);
269 dumpTestNE(i++, 0, 1f, 1f+MACH_EPSILON/2f);
270 dumpTestNE(i++, 0, 0f, 0f+MACH_EPSILON/2f);
271 dumpTestNE(i++, 0, 1f, 1f-Float.MIN_VALUE);
272 dumpTestNE(i++, 0, 0f, 0f-Float.MIN_VALUE);
273 dumpTestNE(i++, 0, 1f, 1f+Float.MIN_VALUE);
274 dumpTestNE(i++, 0, 0f, 0f+Float.MIN_VALUE);
276 private void testCompareNoEpsilon(
final int tstNum,
final int exp,
final float a,
final float b) {
279 final float delta = a-b;
280 System.err.println(
"Comp.NE."+tstNum+
": a: "+a+
", b: "+b+
" -> d "+delta+
", equal "+equal+
", comp: exp "+exp+
" has "+comp);
281 Assert.assertEquals(
"Compare failed a: "+a+
", b: "+b, exp, comp);
290 test05CompareWithEpsilon(200, MACH_EPSILON);
292 private void test05CompareWithEpsilon(
int i,
final float epsilon) {
293 System.err.println();
294 testCompareWithEpsilon(i++, 0, 0f, 0f, epsilon);
295 testCompareWithEpsilon(i++, 0, 1f, 1f-epsilon/2f, epsilon);
296 testCompareWithEpsilon(i++, 0, 1f, 1f+epsilon/2f, epsilon);
297 testCompareWithEpsilon(i++, 0, 1f, 1f-Float.MIN_VALUE, epsilon);
298 testCompareWithEpsilon(i++, 0, 1f, 1f+Float.MIN_VALUE, epsilon);
299 testCompareWithEpsilon(i++, 0, Float.MAX_VALUE, Float.MAX_VALUE, epsilon);
300 testCompareWithEpsilon(i++, 0, Float.MIN_VALUE, Float.MIN_VALUE, epsilon);
301 testCompareWithEpsilon(i++, 0, Float.MIN_NORMAL, Float.MIN_NORMAL, epsilon);
302 testCompareWithEpsilon(i++, 0, Float.NEGATIVE_INFINITY, Float.NEGATIVE_INFINITY, epsilon);
303 testCompareWithEpsilon(i++, 0, Float.POSITIVE_INFINITY, Float.POSITIVE_INFINITY, epsilon);
304 testCompareWithEpsilon(i++, 0, Float.NaN, Float.NaN, epsilon);
306 testCompareWithEpsilon(i++, 1, 1f, 0f, epsilon);
307 testCompareWithEpsilon(i++, -1, 0f, 1f, epsilon);
308 testCompareWithEpsilon(i++, 1, 0f, -1f, epsilon);
309 testCompareWithEpsilon(i++, -1, -1f, 0f, epsilon);
311 testCompareWithEpsilon(i++, 1, Float.MAX_VALUE, Float.MIN_VALUE, epsilon);
312 testCompareWithEpsilon(i++, -1, Float.MIN_VALUE, Float.MAX_VALUE, epsilon);
313 testCompareWithEpsilon(i++, 1, Float.POSITIVE_INFINITY, Float.NEGATIVE_INFINITY, epsilon);
314 testCompareWithEpsilon(i++, -1, Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY, epsilon);
316 testCompareWithEpsilon(i++, -1, 0f,Float.NaN, epsilon);
317 testCompareWithEpsilon(i++, 1, Float.NaN, 0f, epsilon);
319 testCompareWithEpsilon(i++, 0, -0f, 0f, epsilon);
320 testCompareWithEpsilon(i++, 0, 0f, -0f, epsilon);
322 private void testCompareWithEpsilon(
final int tstNum,
final int exp,
final float a,
final float b,
final float epsilon) {
325 final float delta = a-b;
326 System.err.println(
"Comp.WE."+tstNum+
": a: "+a+
", b: "+b+
" -> d "+delta+
", equal "+equal+
", comp: exp "+exp+
" has "+comp);
327 Assert.assertEquals(
"Compare failed a: "+a+
", b: "+b+
" within "+epsilon, exp, comp);
330 public static void main(
final String args[]) {
Basic Float math utility functions.
static boolean isEqualRaw(final float a, final float b)
Returns true if both values are equal disregarding EPSILON but considering NaN, -Inf and +Inf.
static int compare(final float a, final float b)
Returns -1, 0 or 1 if a is less, equal or greater than b, disregarding epsilon but considering NaN,...
static final float EPSILON
Epsilon for floating point {@value}, as once computed via getMachineEpsilon() on an AMD-64 CPU.
static boolean isZeroRaw(final float a)
Returns true if value is zero, disregarding EPSILON but considering NaN, -Inf and +Inf.
static float getMachineEpsilon()
Return computed machine Epsilon value.
static boolean isZero(final float a, final float epsilon)
Returns true if value is zero, i.e.
static boolean isEqual(final float a, final float b, final float epsilon)
Returns true if both values are equal, i.e.
static void main(final String args[])
void test01cZeroNoEpsilon()
void test02EqualsNoEpsilon()
void test01aZeroWithFixedEpsilon0()
void test03bEqualsWithMachEpsilon()
void test05bCompareWithMachEpsilon()
static void test00Epsilon()
void test04CompareNoEpsilon()
void test01bZeroWithMachEpsilon()
void test05aCompareWithFixedEpsilon()
void test03aEqualsWithFixedEpsilon()
void test01bZeroWithFixedEpsilon1()