JOGL v2.6.0-rc-20250712
JOGL, High-Performance Graphics Binding for Java™ (public API).
TestFloatUtil01NOUI.java
Go to the documentation of this file.
1/**
2 * Copyright 2014 JogAmp Community. All rights reserved.
3 *
4 * Redistribution and use in source and binary forms, with or without modification, are
5 * permitted provided that the following conditions are met:
6 *
7 * 1. Redistributions of source code must retain the above copyright notice, this list of
8 * conditions and the following disclaimer.
9 *
10 * 2. Redistributions in binary form must reproduce the above copyright notice, this list
11 * of conditions and the following disclaimer in the documentation and/or other materials
12 * provided with the distribution.
13 *
14 * THIS SOFTWARE IS PROVIDED BY JogAmp Community ``AS IS'' AND ANY EXPRESS OR IMPLIED
15 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
16 * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JogAmp Community OR
17 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
18 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
19 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
20 * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
21 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
22 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
23 *
24 * The views and conclusions contained in the software and documentation are those of the
25 * authors and should not be interpreted as representing official policies, either expressed
26 * or implied, of JogAmp Community.
27 */
28
29package com.jogamp.opengl.test.junit.math;
30
31
32
33import org.junit.Assert;
34import org.junit.BeforeClass;
35import org.junit.Test;
36import org.junit.FixMethodOrder;
37import org.junit.runners.MethodSorters;
38
39import com.jogamp.junit.util.JunitTracer;
40import com.jogamp.math.FloatUtil;
41
42@FixMethodOrder(MethodSorters.NAME_ASCENDING)
43public class TestFloatUtil01NOUI extends JunitTracer {
44 static final float MACH_EPSILON = FloatUtil.getMachineEpsilon();
45
46 static boolean deltaMachEpsLEQEpsilon;
47 static boolean deltaFixedEpsLEQEpsilon;
48
49 @BeforeClass
50 public static void test00Epsilon() {
51 System.err.println();
52 System.err.println("Machine Epsilon: "+MACH_EPSILON);
53 System.err.println("Fixed Epsilon: "+FloatUtil.EPSILON+", diff "+Math.abs(MACH_EPSILON-FloatUtil.EPSILON));
54 System.err.println("Float MIN: "+Float.MIN_VALUE);
55
56 final float deltaMachEpsMin = Math.abs(MACH_EPSILON-Float.MIN_VALUE);
57 deltaMachEpsLEQEpsilon = FloatUtil.compare(deltaMachEpsMin, MACH_EPSILON) <= 0;
58
59 final float deltaFixedEpsMin = Math.abs(MACH_EPSILON-Float.MIN_VALUE);
60 deltaFixedEpsLEQEpsilon = FloatUtil.compare(deltaFixedEpsMin, MACH_EPSILON) <= 0;
61
62 System.err.println("deltaMachEpsMin "+deltaMachEpsMin+", deltaMachEpsLEQEpsilon "+deltaMachEpsLEQEpsilon);
63 System.err.println("deltaFixedEpsMin "+deltaFixedEpsMin+", deltaFixedEpsLEQEpsilon "+deltaFixedEpsLEQEpsilon);
64 }
65
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;
68 final boolean equalWE = FloatUtil.isEqual(a, b, EPSILON);
69 final int compWE = FloatUtil.compare(a, b, EPSILON);
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);
72 }
73 private void dumpTestNE(final int tstNum, final int exp, final float a, final float b) {
74 final float delta = a-b;
75 final boolean equal = FloatUtil.isEqualRaw(a, b);
76 final int comp = FloatUtil.compare(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);
79 }
80
81 @Test
83 testZeroWithEpsilon0(100);
84 }
85 @Test
87 testZeroWithEpsilon1(200, FloatUtil.EPSILON);
88 }
89 @Test
91 testZeroWithEpsilon1(300, MACH_EPSILON);
92 }
93 @Test
94 public void test01cZeroNoEpsilon() {
95 int i = 400;
96 System.err.println();
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);
102
103 testZeroNoEpsilon(i++, false, 0f+Float.MIN_VALUE);
104 testZeroNoEpsilon(i++, false, 0f-Float.MIN_VALUE);
105
106 // Unpredicted .. accuracy beyond epsilon, or deltaMachEpsLEQEpsilon or deltaFixedEpsLEQEpsilon;
107 dumpTestNE(i++, 1, 0f, 0f+Float.MIN_VALUE);
108 dumpTestNE(i++, 1, 0f, 0f-Float.MIN_VALUE);
109 }
110 private void testZeroNoEpsilon(final int tstNum, final boolean exp, final float a) {
111 final boolean zero = FloatUtil.isZeroRaw(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);
115 }
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);
125
126 testZeroWithEpsilon1(i++, false, 0f+EPSILON+Float.MIN_VALUE, EPSILON);
127 testZeroWithEpsilon1(i++, false, 0f-EPSILON-Float.MIN_VALUE, EPSILON);
128
129 // Unpredicted .. accuracy beyond epsilon, or deltaMachEpsLEQEpsilon or deltaFixedEpsLEQEpsilon;
130 dumpTestWE(i++, 1, 0f, 0f+EPSILON-Float.MIN_VALUE, EPSILON);
131 dumpTestWE(i++, 1, 0f, 0f-EPSILON+Float.MIN_VALUE, EPSILON);
132 }
133 private void testZeroWithEpsilon1(final int tstNum, final boolean exp, final float a, final float EPSILON) {
134 final boolean zero = FloatUtil.isZero(a, 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);
138 }
139 private void testZeroWithEpsilon0(int i) {
140 System.err.println();
141 testZeroWithEpsilon0(i++, true, 0f);
142 testZeroWithEpsilon0(i++, true, 0f-FloatUtil.EPSILON/2f);
143 testZeroWithEpsilon0(i++, true, 0f+FloatUtil.EPSILON/2f);
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);
148
149 testZeroWithEpsilon0(i++, false, 0f+FloatUtil.EPSILON+Float.MIN_VALUE);
150 testZeroWithEpsilon0(i++, false, 0f-FloatUtil.EPSILON-Float.MIN_VALUE);
151
152 // Unpredicted .. accuracy beyond epsilon, or deltaMachEpsLEQEpsilon or deltaFixedEpsLEQEpsilon;
153 dumpTestWE(i++, 1, 0f, 0f+FloatUtil.EPSILON-Float.MIN_VALUE, FloatUtil.EPSILON);
154 dumpTestWE(i++, 1, 0f, 0f-FloatUtil.EPSILON+Float.MIN_VALUE, FloatUtil.EPSILON);
155 }
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);
161 }
162
163 @Test
164 public void test02EqualsNoEpsilon() {
165 int i=0;
166 System.err.println();
167 testEqualsNoEpsilon(i++, true, 0f, 0f);
168
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);
177
178 // Unpredicted .. accuracy beyond epsilon, or deltaMachEpsLEQEpsilon or deltaFixedEpsLEQEpsilon;
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);
187 }
188 private void testEqualsNoEpsilon(final int tstNum, final boolean exp, final float a, final float b) {
189 final boolean equal = FloatUtil.isEqualRaw(a, b);
190 final int comp = FloatUtil.compare(a, 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);
195 }
196
197 @Test
199 testEqualsWithEpsilon(100, FloatUtil.EPSILON);
200 }
201 @Test
203 testEqualsWithEpsilon(200, MACH_EPSILON);
204 }
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);
221
222 testEqualsWithEpsilon(i++, false, 1f, 1f+EPSILON+Float.MIN_VALUE, EPSILON);
223 testEqualsWithEpsilon(i++, false, 1f, 1f-EPSILON-Float.MIN_VALUE, EPSILON);
224
225 // Unpredicted .. accuracy beyond epsilon, or deltaMachEpsLEQEpsilon or deltaFixedEpsLEQEpsilon;
226 dumpTestWE(i++, 1, 1f, 1f+EPSILON-Float.MIN_VALUE, EPSILON);
227 dumpTestWE(i++, 1, 1f, 1f-EPSILON+Float.MIN_VALUE, EPSILON);
228 }
229 private void testEqualsWithEpsilon(final int tstNum, final boolean exp, final float a, final float b, final float EPSILON) {
230 final boolean equal = FloatUtil.isEqual(a, b, EPSILON);
231 final int comp = FloatUtil.compare(a, b, 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);
236 }
237
238 @Test
240 int i=0;
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);
249
250 testCompareNoEpsilon(i++, 1, 1f, 0f);
251 testCompareNoEpsilon(i++, -1, 0f, 1f);
252 testCompareNoEpsilon(i++, 1, 0f, -1f);
253 testCompareNoEpsilon(i++, -1, -1f, 0f);
254
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);
259
260 testCompareNoEpsilon(i++, -1, 0f, Float.NaN);
261 testCompareNoEpsilon(i++, 1, Float.NaN, 0f);
262
263 testCompareNoEpsilon(i++, -1, -0f, 0f);
264 testCompareNoEpsilon(i++, 1, 0f, -0f);
265
266 // Unpredicted .. accuracy beyond epsilon, or deltaMachEpsLEQEpsilon or deltaFixedEpsLEQEpsilon;
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);
275 }
276 private void testCompareNoEpsilon(final int tstNum, final int exp, final float a, final float b) {
277 final boolean equal = FloatUtil.isEqualRaw(a, b);
278 final int comp = FloatUtil.compare(a, 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);
282 }
283
284 @Test
286 test05CompareWithEpsilon(100, FloatUtil.EPSILON);
287 }
288 @Test
290 test05CompareWithEpsilon(200, MACH_EPSILON);
291 }
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);
305
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);
310
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);
315
316 testCompareWithEpsilon(i++, -1, 0f,Float.NaN, epsilon);
317 testCompareWithEpsilon(i++, 1, Float.NaN, 0f, epsilon);
318
319 testCompareWithEpsilon(i++, 0, -0f, 0f, epsilon);
320 testCompareWithEpsilon(i++, 0, 0f, -0f, epsilon);
321 }
322 private void testCompareWithEpsilon(final int tstNum, final int exp, final float a, final float b, final float epsilon) {
323 final boolean equal = FloatUtil.isEqual(a, b, epsilon);
324 final int comp = FloatUtil.compare(a, b, 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);
328 }
329
330 public static void main(final String args[]) {
331 org.junit.runner.JUnitCore.main(TestFloatUtil01NOUI.class.getName());
332 }
333}
Basic Float math utility functions.
Definition: FloatUtil.java:83
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.