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 29 package com.jogamp.opengl.test.junit.jogl.math; 30 31 32 33 import org.junit.Assert; 34 import org.junit.BeforeClass; 35 import org.junit.Test; 36 import org.junit.FixMethodOrder; 37 import org.junit.runners.MethodSorters; 38 39 import com.jogamp.opengl.math.FloatUtil; 40 41 @FixMethodOrder(MethodSorters.NAME_ASCENDING) 42 public class TestFloatUtil01NOUI { 43 static final float MACH_EPSILON = FloatUtil.getMachineEpsilon(); 44 45 static boolean deltaMachEpsLEQEpsilon; 46 static boolean deltaFixedEpsLEQEpsilon; 47 48 @BeforeClass test00Epsilon()49 public static void test00Epsilon() { 50 System.err.println(); 51 System.err.println("Machine Epsilon: "+MACH_EPSILON); 52 System.err.println("Fixed Epsilon: "+FloatUtil.EPSILON+", diff "+Math.abs(MACH_EPSILON-FloatUtil.EPSILON)); 53 System.err.println("Float MIN: "+Float.MIN_VALUE); 54 55 final float deltaMachEpsMin = Math.abs(MACH_EPSILON-Float.MIN_VALUE); 56 deltaMachEpsLEQEpsilon = FloatUtil.compare(deltaMachEpsMin, MACH_EPSILON) <= 0; 57 58 final float deltaFixedEpsMin = Math.abs(MACH_EPSILON-Float.MIN_VALUE); 59 deltaFixedEpsLEQEpsilon = FloatUtil.compare(deltaFixedEpsMin, MACH_EPSILON) <= 0; 60 61 System.err.println("deltaMachEpsMin "+deltaMachEpsMin+", deltaMachEpsLEQEpsilon "+deltaMachEpsLEQEpsilon); 62 System.err.println("deltaFixedEpsMin "+deltaFixedEpsMin+", deltaFixedEpsLEQEpsilon "+deltaFixedEpsLEQEpsilon); 63 } 64 dumpTestWE(final int tstNum, final int expWE, final float a, final float b, final float EPSILON)65 private void dumpTestWE(final int tstNum, final int expWE, final float a, final float b, final float EPSILON) { 66 final float delta = a-b; 67 final boolean equalWE = FloatUtil.isEqual(a, b, EPSILON); 68 final int compWE = FloatUtil.compare(a, b, EPSILON); 69 final String msgWE = ( expWE != compWE ) ? "**** mismatch ****" : " OK"; 70 System.err.println("Print.WE."+tstNum+": a: "+a+", b: "+b+" -> d "+delta+", exp "+expWE+", equal "+equalWE+", comp "+compWE+" - "+msgWE+", epsilon "+EPSILON); 71 } dumpTestNE(final int tstNum, final int exp, final float a, final float b)72 private void dumpTestNE(final int tstNum, final int exp, final float a, final float b) { 73 final float delta = a-b; 74 final boolean equal = FloatUtil.isEqual(a, b); 75 final int comp = FloatUtil.compare(a, b); 76 final String msg = ( exp != comp ) ? "**** mismatch ****" : " OK"; 77 System.err.println("Print.NE."+tstNum+": a: "+a+", b: "+b+" -> d "+delta+", exp "+exp+", equal "+equal+", comp "+comp+" - "+msg); 78 } 79 80 @Test test01aZeroWithFixedEpsilon()81 public void test01aZeroWithFixedEpsilon() { 82 testZeroWithEpsilon(10, FloatUtil.EPSILON); 83 } 84 @Test test01bZeroWithMachEpsilon()85 public void test01bZeroWithMachEpsilon() { 86 testZeroWithEpsilon(100, MACH_EPSILON); 87 } testZeroWithEpsilon(int i, final float EPSILON)88 private void testZeroWithEpsilon(int i, final float EPSILON) { 89 System.err.println(); 90 testZeroWithEpsilon(i++, true, 0f, EPSILON); 91 testZeroWithEpsilon(i++, true, 0f-EPSILON/2f, EPSILON); 92 testZeroWithEpsilon(i++, true, 0f+EPSILON/2f, EPSILON); 93 testZeroWithEpsilon(i++, true, 0f-Float.MIN_VALUE, EPSILON); 94 testZeroWithEpsilon(i++, true, 0f+Float.MIN_VALUE, EPSILON); 95 testZeroWithEpsilon(i++, true, -0f, EPSILON); 96 testZeroWithEpsilon(i++, true, +0f, EPSILON); 97 98 testZeroWithEpsilon(i++, false, 0f+EPSILON+Float.MIN_VALUE, EPSILON); 99 testZeroWithEpsilon(i++, false, 0f-EPSILON-Float.MIN_VALUE, EPSILON); 100 101 // Unpredicted .. accuracy beyond epsilon, or deltaMachEpsLEQEpsilon or deltaFixedEpsLEQEpsilon; 102 dumpTestWE(i++, 1, 0f, 0f+EPSILON-Float.MIN_VALUE, EPSILON); 103 dumpTestWE(i++, 1, 0f, 0f-EPSILON+Float.MIN_VALUE, EPSILON); 104 } testZeroWithEpsilon(final int tstNum, final boolean exp, final float a, final float EPSILON)105 private void testZeroWithEpsilon(final int tstNum, final boolean exp, final float a, final float EPSILON) { 106 final boolean zero = FloatUtil.isZero(a, EPSILON); 107 final float delta = a-0f; 108 System.err.println("Zero."+tstNum+": a: "+a+", -> d "+delta+", exp "+exp+", zero "+zero+", epsilon "+EPSILON); 109 Assert.assertEquals("Zero failed a: "+a+" within "+EPSILON, exp, zero); 110 } 111 112 @Test test02EqualsNoEpsilon()113 public void test02EqualsNoEpsilon() { 114 int i=0; 115 System.err.println(); 116 testEqualsNoEpsilon(i++, true, 0f, 0f); 117 118 testEqualsNoEpsilon(i++, true, Float.MAX_VALUE, Float.MAX_VALUE); 119 testEqualsNoEpsilon(i++, true, Float.MIN_VALUE, Float.MIN_VALUE); 120 testEqualsNoEpsilon(i++, true, Float.MIN_NORMAL, Float.MIN_NORMAL); 121 testEqualsNoEpsilon(i++, true, Float.NEGATIVE_INFINITY, Float.NEGATIVE_INFINITY); 122 testEqualsNoEpsilon(i++, true, Float.POSITIVE_INFINITY, Float.POSITIVE_INFINITY); 123 testEqualsNoEpsilon(i++, true, Float.NaN, Float.NaN); 124 testEqualsNoEpsilon(i++, false, -0f, 0f); 125 testEqualsNoEpsilon(i++, false, 0f, -0f); 126 127 // Unpredicted .. accuracy beyond epsilon, or deltaMachEpsLEQEpsilon or deltaFixedEpsLEQEpsilon; 128 dumpTestNE(i++, 0, 1f, 1f-MACH_EPSILON/2f); 129 dumpTestNE(i++, 0, 0f, 0f-MACH_EPSILON/2f); 130 dumpTestNE(i++, 0, 1f, 1f+MACH_EPSILON/2f); 131 dumpTestNE(i++, 0, 0f, 0f+MACH_EPSILON/2f); 132 dumpTestNE(i++, 0, 1f, 1f-Float.MIN_VALUE); 133 dumpTestNE(i++, 0, 0f, 0f-Float.MIN_VALUE); 134 dumpTestNE(i++, 0, 1f, 1f+Float.MIN_VALUE); 135 dumpTestNE(i++, 0, 0f, 0f+Float.MIN_VALUE); 136 } testEqualsNoEpsilon(final int tstNum, final boolean exp, final float a, final float b)137 private void testEqualsNoEpsilon(final int tstNum, final boolean exp, final float a, final float b) { 138 final boolean equal = FloatUtil.isEqual(a, b); 139 final int comp = FloatUtil.compare(a, b); 140 final float delta = a-b; 141 System.err.println("Equal.NE."+tstNum+": a: "+a+", b: "+b+" -> d "+delta+", exp "+exp+", equal "+equal+", comp "+comp); 142 Assert.assertEquals("Compare failed a: "+a+", b: "+b, exp, 0==comp); 143 Assert.assertEquals("Equal failed a: "+a+", b: "+b, exp, equal); 144 } 145 146 @Test test03aEqualsWithFixedEpsilon()147 public void test03aEqualsWithFixedEpsilon() { 148 testEqualsWithEpsilon(10, FloatUtil.EPSILON); 149 } 150 @Test test03bEqualsWithMachEpsilon()151 public void test03bEqualsWithMachEpsilon() { 152 testEqualsWithEpsilon(50, MACH_EPSILON); 153 } testEqualsWithEpsilon(int i, final float EPSILON)154 private void testEqualsWithEpsilon(int i, final float EPSILON) { 155 System.err.println(); 156 testEqualsWithEpsilon(i++, true, 0f, 0f, EPSILON); 157 testEqualsWithEpsilon(i++, true, 1f, 1f-EPSILON/2f, EPSILON); 158 testEqualsWithEpsilon(i++, true, 1f, 1f+EPSILON/2f, EPSILON); 159 testEqualsWithEpsilon(i++, true, 1f, 1f-Float.MIN_VALUE, EPSILON); 160 testEqualsWithEpsilon(i++, true, 1f, 1f+Float.MIN_VALUE, EPSILON); 161 testEqualsWithEpsilon(i++, true, Float.MAX_VALUE, Float.MAX_VALUE, EPSILON); 162 testEqualsWithEpsilon(i++, true, Float.MIN_VALUE, Float.MIN_VALUE, EPSILON); 163 testEqualsWithEpsilon(i++, true, Float.MIN_NORMAL, Float.MIN_NORMAL, EPSILON); 164 testEqualsWithEpsilon(i++, true, Float.NEGATIVE_INFINITY, Float.NEGATIVE_INFINITY, EPSILON); 165 testEqualsWithEpsilon(i++, true, Float.POSITIVE_INFINITY, Float.POSITIVE_INFINITY, EPSILON); 166 testEqualsWithEpsilon(i++, true, Float.NaN, Float.NaN, EPSILON); 167 testEqualsWithEpsilon(i++, true, -0f, 0f, EPSILON); 168 testEqualsWithEpsilon(i++, true, 0f, -0f, EPSILON); 169 170 testEqualsWithEpsilon(i++, false, 1f, 1f+EPSILON+Float.MIN_VALUE, EPSILON); 171 testEqualsWithEpsilon(i++, false, 1f, 1f-EPSILON-Float.MIN_VALUE, EPSILON); 172 173 // Unpredicted .. accuracy beyond epsilon, or deltaMachEpsLEQEpsilon or deltaFixedEpsLEQEpsilon; 174 dumpTestWE(i++, 1, 1f, 1f+EPSILON-Float.MIN_VALUE, EPSILON); 175 dumpTestWE(i++, 1, 1f, 1f-EPSILON+Float.MIN_VALUE, EPSILON); 176 } testEqualsWithEpsilon(final int tstNum, final boolean exp, final float a, final float b, final float EPSILON)177 private void testEqualsWithEpsilon(final int tstNum, final boolean exp, final float a, final float b, final float EPSILON) { 178 final boolean equal = FloatUtil.isEqual(a, b, EPSILON); 179 final int comp = FloatUtil.compare(a, b, EPSILON); 180 final float delta = a-b; 181 System.err.println("Equal.WE."+tstNum+": a: "+a+", b: "+b+" -> d "+delta+", exp "+exp+", equal "+equal+", comp "+comp); 182 Assert.assertEquals("Compare failed a: "+a+", b: "+b+" within "+EPSILON, exp, 0==comp); 183 Assert.assertEquals("Equal failed a: "+a+", b: "+b+" within "+EPSILON, exp, equal); 184 } 185 186 @Test test04CompareNoEpsilon()187 public void test04CompareNoEpsilon() { 188 int i=0; 189 System.err.println(); 190 testCompareNoEpsilon(i++, 0, 0f, 0f); 191 testCompareNoEpsilon(i++, 0, Float.MAX_VALUE, Float.MAX_VALUE); 192 testCompareNoEpsilon(i++, 0, Float.MIN_VALUE, Float.MIN_VALUE); 193 testCompareNoEpsilon(i++, 0, Float.MIN_NORMAL, Float.MIN_NORMAL); 194 testCompareNoEpsilon(i++, 0, Float.NEGATIVE_INFINITY, Float.NEGATIVE_INFINITY); 195 testCompareNoEpsilon(i++, 0, Float.POSITIVE_INFINITY, Float.POSITIVE_INFINITY); 196 testCompareNoEpsilon(i++, 0, Float.NaN, Float.NaN); 197 198 testCompareNoEpsilon(i++, 1, 1f, 0f); 199 testCompareNoEpsilon(i++, -1, 0f, 1f); 200 testCompareNoEpsilon(i++, 1, 0f, -1f); 201 testCompareNoEpsilon(i++, -1, -1f, 0f); 202 203 testCompareNoEpsilon(i++, 1, Float.MAX_VALUE, Float.MIN_VALUE); 204 testCompareNoEpsilon(i++, -1, Float.MIN_VALUE, Float.MAX_VALUE); 205 testCompareNoEpsilon(i++, 1, Float.POSITIVE_INFINITY, Float.NEGATIVE_INFINITY); 206 testCompareNoEpsilon(i++, -1, Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY); 207 208 testCompareNoEpsilon(i++, -1, 0f, Float.NaN); 209 testCompareNoEpsilon(i++, 1, Float.NaN, 0f); 210 211 testCompareNoEpsilon(i++, -1, -0f, 0f); 212 testCompareNoEpsilon(i++, 1, 0f, -0f); 213 214 // Unpredicted .. accuracy beyond epsilon, or deltaMachEpsLEQEpsilon or deltaFixedEpsLEQEpsilon; 215 dumpTestNE(i++, 0, 1f, 1f-MACH_EPSILON/2f); 216 dumpTestNE(i++, 0, 0f, 0f-MACH_EPSILON/2f); 217 dumpTestNE(i++, 0, 1f, 1f+MACH_EPSILON/2f); 218 dumpTestNE(i++, 0, 0f, 0f+MACH_EPSILON/2f); 219 dumpTestNE(i++, 0, 1f, 1f-Float.MIN_VALUE); 220 dumpTestNE(i++, 0, 0f, 0f-Float.MIN_VALUE); 221 dumpTestNE(i++, 0, 1f, 1f+Float.MIN_VALUE); 222 dumpTestNE(i++, 0, 0f, 0f+Float.MIN_VALUE); 223 } testCompareNoEpsilon(final int tstNum, final int exp, final float a, final float b)224 private void testCompareNoEpsilon(final int tstNum, final int exp, final float a, final float b) { 225 final boolean equal = FloatUtil.isEqual(a, b); 226 final int comp = FloatUtil.compare(a, b); 227 final float delta = a-b; 228 System.err.println("Comp.NE."+tstNum+": a: "+a+", b: "+b+" -> d "+delta+", equal "+equal+", comp: exp "+exp+" has "+comp); 229 Assert.assertEquals("Compare failed a: "+a+", b: "+b, exp, comp); 230 } 231 232 @Test test05aCompareWithFixedEpsilon()233 public void test05aCompareWithFixedEpsilon() { 234 test05CompareWithEpsilon(10, FloatUtil.EPSILON); 235 } 236 @Test test05bCompareWithMachEpsilon()237 public void test05bCompareWithMachEpsilon() { 238 test05CompareWithEpsilon(50, MACH_EPSILON); 239 } test05CompareWithEpsilon(int i, final float EPSILON)240 private void test05CompareWithEpsilon(int i, final float EPSILON) { 241 System.err.println(); 242 testCompareWithEpsilon(i++, 0, 0f, 0f, EPSILON); 243 testCompareWithEpsilon(i++, 0, 1f, 1f-EPSILON/2f, EPSILON); 244 testCompareWithEpsilon(i++, 0, 1f, 1f+EPSILON/2f, EPSILON); 245 testCompareWithEpsilon(i++, 0, 1f, 1f-Float.MIN_VALUE, EPSILON); 246 testCompareWithEpsilon(i++, 0, 1f, 1f+Float.MIN_VALUE, EPSILON); 247 testCompareWithEpsilon(i++, 0, Float.MAX_VALUE, Float.MAX_VALUE, EPSILON); 248 testCompareWithEpsilon(i++, 0, Float.MIN_VALUE, Float.MIN_VALUE, EPSILON); 249 testCompareWithEpsilon(i++, 0, Float.MIN_NORMAL, Float.MIN_NORMAL, EPSILON); 250 testCompareWithEpsilon(i++, 0, Float.NEGATIVE_INFINITY, Float.NEGATIVE_INFINITY, EPSILON); 251 testCompareWithEpsilon(i++, 0, Float.POSITIVE_INFINITY, Float.POSITIVE_INFINITY, EPSILON); 252 testCompareWithEpsilon(i++, 0, Float.NaN, Float.NaN, EPSILON); 253 254 testCompareWithEpsilon(i++, 1, 1f, 0f, EPSILON); 255 testCompareWithEpsilon(i++, -1, 0f, 1f, EPSILON); 256 testCompareWithEpsilon(i++, 1, 0f, -1f, EPSILON); 257 testCompareWithEpsilon(i++, -1, -1f, 0f, EPSILON); 258 259 testCompareWithEpsilon(i++, 1, Float.MAX_VALUE, Float.MIN_VALUE, EPSILON); 260 testCompareWithEpsilon(i++, -1, Float.MIN_VALUE, Float.MAX_VALUE, EPSILON); 261 testCompareWithEpsilon(i++, 1, Float.POSITIVE_INFINITY, Float.NEGATIVE_INFINITY, EPSILON); 262 testCompareWithEpsilon(i++, -1, Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY, EPSILON); 263 264 testCompareWithEpsilon(i++, -1, 0f,Float.NaN, EPSILON); 265 testCompareWithEpsilon(i++, 1, Float.NaN, 0f, EPSILON); 266 267 testCompareWithEpsilon(i++, 0, -0f, 0f, EPSILON); 268 testCompareWithEpsilon(i++, 0, 0f, -0f, EPSILON); 269 } testCompareWithEpsilon(final int tstNum, final int exp, final float a, final float b, final float EPSILON)270 private void testCompareWithEpsilon(final int tstNum, final int exp, final float a, final float b, final float EPSILON) { 271 final boolean equal = FloatUtil.isEqual(a, b, EPSILON); 272 final int comp = FloatUtil.compare(a, b, EPSILON); 273 final float delta = a-b; 274 System.err.println("Comp.WE."+tstNum+": a: "+a+", b: "+b+" -> d "+delta+", equal "+equal+", comp: exp "+exp+" has "+comp); 275 Assert.assertEquals("Compare failed a: "+a+", b: "+b+" within "+EPSILON, exp, comp); 276 } 277 278 main(final String args[])279 public static void main(final String args[]) { 280 org.junit.runner.JUnitCore.main(TestFloatUtil01NOUI.class.getName()); 281 } 282 } 283