1 /* 2 * Copyright (C) 2006 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 /** 18 * Test arithmetic operations. 19 */ 20 public class FloatMath { 21 convTest()22 static void convTest() { 23 System.out.println("FloatMath.convTest"); 24 25 float f; 26 double d; 27 int i; 28 long l; 29 30 /* float --> int */ 31 f = 1234.5678f; 32 i = (int) f; 33 Main.assertTrue(i == 1234); 34 35 f = -1234.5678f; 36 i = (int) f; 37 Main.assertTrue(i == -1234); 38 39 /* float --> long */ 40 f = 1238.5678f; 41 l = (long) f; 42 Main.assertTrue(l == 1238); 43 44 f = -1238.5678f; 45 l = (long) f; 46 Main.assertTrue(l == -1238); 47 48 /* float --> double */ 49 f = 1238.5678f; 50 d = (double) f; 51 Main.assertTrue(d > 1238.567 && d < 1238.568); 52 53 /* double --> int */ 54 d = 1234.5678; 55 i = (int) d; 56 Main.assertTrue(i == 1234); 57 58 d = -1234.5678; 59 i = (int) d; 60 Main.assertTrue(i == -1234); 61 62 /* double --> long */ 63 d = 5678956789.0123; 64 l = (long) d; 65 Main.assertTrue(l == 5678956789L); 66 67 d = -5678956789.0123; 68 l = (long) d; 69 Main.assertTrue(l == -5678956789L); 70 71 /* double --> float */ 72 d = 1238.5678; 73 f = (float) d; 74 Main.assertTrue(f > 1238.567 && f < 1238.568); 75 76 /* int --> long */ 77 i = 7654; 78 l = (long) i; 79 Main.assertTrue(l == 7654L); 80 81 i = -7654; 82 l = (long) i; 83 Main.assertTrue(l == -7654L); 84 85 /* int --> float */ 86 i = 1234; 87 f = (float) i; 88 Main.assertTrue(f > 1233.9f && f < 1234.1f); 89 90 i = -1234; 91 f = (float) i; 92 Main.assertTrue(f < -1233.9f && f > -1234.1f); 93 94 /* int --> double */ 95 i = 1238; 96 d = (double) i; 97 Main.assertTrue(d > 1237.9f && d < 1238.1f); 98 99 i = -1238; 100 d = (double) i; 101 Main.assertTrue(d < -1237.9f && d > -1238.1f); 102 103 /* long --> int (with truncation) */ 104 l = 5678956789L; 105 i = (int) l; 106 Main.assertTrue(i == 1383989493); 107 108 l = -5678956789L; 109 i = (int) l; 110 Main.assertTrue(i == -1383989493); 111 112 /* long --> float */ 113 l = 5678956789L; 114 f = (float) l; 115 Main.assertTrue(f > 5.6789564E9 && f < 5.6789566E9); 116 117 l = -5678956789L; 118 f = (float) l; 119 Main.assertTrue(f < -5.6789564E9 && f > -5.6789566E9); 120 121 /* long --> double */ 122 l = 6678956789L; 123 d = (double) l; 124 Main.assertTrue(d > 6.6789567E9 && d < 6.6789568E9); 125 126 l = -6678956789L; 127 d = (double) l; 128 Main.assertTrue(d < -6.6789567E9 && d > -6.6789568E9); 129 } 130 131 /* 132 * We pass in the arguments and return the results so the compiler 133 * doesn't do the math for us. 134 */ floatOperTest(float x, float y)135 static float[] floatOperTest(float x, float y) { 136 System.out.println("FloatMath.floatOperTest"); 137 138 float[] results = new float[9]; 139 140 /* this seems to generate "op-float" instructions */ 141 results[0] = x + y; 142 results[1] = x - y; 143 results[2] = x * y; 144 results[3] = x / y; 145 results[4] = x % -y; 146 147 /* this seems to generate "op-float/2addr" instructions */ 148 results[8] = x + (((((x + y) - y) * y) / y) % y); 149 150 return results; 151 } floatOperCheck(float[] results)152 static void floatOperCheck(float[] results) { 153 Main.assertTrue(results[0] > 69996.99f && results[0] < 69997.01f); 154 Main.assertTrue(results[1] > 70002.99f && results[1] < 70003.01f); 155 Main.assertTrue(results[2] > -210000.01f && results[2] < -209999.99f); 156 Main.assertTrue(results[3] > -23333.34f && results[3] < -23333.32f); 157 Main.assertTrue(results[4] > 0.999f && results[4] < 1.001f); 158 Main.assertTrue(results[8] > 70000.99f && results[8] < 70001.01f); 159 } 160 161 /* 162 * We pass in the arguments and return the results so the compiler 163 * doesn't do the math for us. 164 */ doubleOperTest(double x, double y)165 static double[] doubleOperTest(double x, double y) { 166 System.out.println("FloatMath.doubleOperTest"); 167 168 double[] results = new double[9]; 169 170 /* this seems to generate "op-double" instructions */ 171 results[0] = x + y; 172 results[1] = x - y; 173 results[2] = x * y; 174 results[3] = x / y; 175 results[4] = x % -y; 176 177 /* this seems to generate "op-double/2addr" instructions */ 178 results[8] = x + (((((x + y) - y) * y) / y) % y); 179 180 return results; 181 } doubleOperCheck(double[] results)182 static void doubleOperCheck(double[] results) { 183 Main.assertTrue(results[0] > 69996.99 && results[0] < 69997.01); 184 Main.assertTrue(results[1] > 70002.99 && results[1] < 70003.01); 185 Main.assertTrue(results[2] > -210000.01 && results[2] < -209999.99); 186 Main.assertTrue(results[3] > -23333.34 && results[3] < -23333.32); 187 Main.assertTrue(results[4] > 0.999 && results[4] < 1.001); 188 Main.assertTrue(results[8] > 70000.99 && results[8] < 70001.01); 189 } 190 191 /* 192 * Try to cause some unary operations. 193 */ unopTest(float f)194 static float unopTest(float f) { 195 f = -f; 196 return f; 197 } 198 convI(long l, float f, double d, float zero)199 static int[] convI(long l, float f, double d, float zero) { 200 int[] results = new int[6]; 201 results[0] = (int) l; 202 results[1] = (int) f; 203 results[2] = (int) d; 204 results[3] = (int) (1.0f / zero); // +inf 205 results[4] = (int) (-1.0f / zero); // -inf 206 results[5] = (int) ((1.0f / zero) / (1.0f / zero)); // NaN 207 return results; 208 } checkConvI(int[] results)209 static void checkConvI(int[] results) { 210 System.out.println("FloatMath.checkConvI"); 211 Main.assertTrue(results[0] == 0x44332211); 212 Main.assertTrue(results[1] == 123); 213 Main.assertTrue(results[2] == -3); 214 Main.assertTrue(results[3] == 0x7fffffff); 215 Main.assertTrue(results[4] == 0x80000000); 216 Main.assertTrue(results[5] == 0); 217 } 218 convL(int i, float f, double d, double zero)219 static long[] convL(int i, float f, double d, double zero) { 220 long[] results = new long[6]; 221 results[0] = (long) i; 222 results[1] = (long) f; 223 results[2] = (long) d; 224 results[3] = (long) (1.0 / zero); // +inf 225 results[4] = (long) (-1.0 / zero); // -inf 226 results[5] = (long) ((1.0 / zero) / (1.0 / zero)); // NaN 227 return results; 228 } checkConvL(long[] results)229 static void checkConvL(long[] results) { 230 System.out.println("FloatMath.checkConvL"); 231 Main.assertTrue(results[0] == 0xFFFFFFFF88776655L); 232 Main.assertTrue(results[1] == 123); 233 Main.assertTrue(results[2] == -3); 234 Main.assertTrue(results[3] == 0x7fffffffffffffffL); 235 Main.assertTrue(results[4] == 0x8000000000000000L); 236 Main.assertTrue(results[5] == 0); 237 } 238 convF(int i, long l, double d)239 static float[] convF(int i, long l, double d) { 240 float[] results = new float[3]; 241 results[0] = (float) i; 242 results[1] = (float) l; 243 results[2] = (float) d; 244 return results; 245 } checkConvF(float[] results)246 static void checkConvF(float[] results) { 247 System.out.println("FloatMath.checkConvF"); 248 // TODO: Main.assertTrue values 249 for (int i = 0; i < results.length; i++) 250 System.out.println(" " + i + ": " + results[i]); 251 System.out.println("-2.0054409E9, -8.6133031E18, -3.1415927"); 252 } 253 convD(int i, long l, float f)254 static double[] convD(int i, long l, float f) { 255 double[] results = new double[3]; 256 results[0] = (double) i; 257 results[1] = (double) l; 258 results[2] = (double) f; 259 return results; 260 } checkConvD(double[] results)261 static void checkConvD(double[] results) { 262 System.out.println("FloatMath.checkConvD"); 263 // TODO: Main.assertTrue values 264 for (int i = 0; i < results.length; i++) 265 System.out.println(" " + i + ": " + results[i]); 266 System.out.println("-2.005440939E9, -8.6133032459203287E18, 123.4560012817382"); 267 } 268 checkConsts()269 static void checkConsts() { 270 System.out.println("FloatMath.checkConsts"); 271 272 float f = 10.0f; // const/special 273 Main.assertTrue(f > 9.9 && f < 10.1); 274 275 double d = 10.0; // const-wide/special 276 Main.assertTrue(d > 9.9 && d < 10.1); 277 } 278 279 /* 280 * Determine if two floating point numbers are approximately equal. 281 * 282 * (Assumes that floating point is generally working, so we can't use 283 * this for the first set of tests.) 284 */ approxEqual(float a, float b, float maxDelta)285 static boolean approxEqual(float a, float b, float maxDelta) { 286 if (a > b) 287 return (a - b) < maxDelta; 288 else 289 return (b - a) < maxDelta; 290 } approxEqual(double a, double b, double maxDelta)291 static boolean approxEqual(double a, double b, double maxDelta) { 292 if (a > b) 293 return (a - b) < maxDelta; 294 else 295 return (b - a) < maxDelta; 296 } 297 298 /* 299 * Test some java.lang.Math functions. 300 * 301 * The method arguments are positive values. 302 */ jlmTests(float ff, double dd)303 static void jlmTests(float ff, double dd) { 304 System.out.println("FloatMath.jlmTests"); 305 306 Main.assertTrue(approxEqual(Math.abs(ff), ff, 0.001f)); 307 Main.assertTrue(approxEqual(Math.abs(-ff), ff, 0.001f)); 308 Main.assertTrue(approxEqual(Math.min(ff, -5.0f), -5.0f, 0.001f)); 309 Main.assertTrue(approxEqual(Math.max(ff, -5.0f), ff, 0.001f)); 310 311 Main.assertTrue(approxEqual(Math.abs(dd), dd, 0.001)); 312 Main.assertTrue(approxEqual(Math.abs(-dd), dd, 0.001)); 313 Main.assertTrue(approxEqual(Math.min(dd, -5.0), -5.0, 0.001)); 314 Main.assertTrue(approxEqual(Math.max(dd, -5.0), dd, 0.001)); 315 316 double sq = Math.sqrt(dd); 317 Main.assertTrue(approxEqual(sq*sq, dd, 0.001)); 318 319 Main.assertTrue(approxEqual(0.5403023058681398, Math.cos(1.0), 0.00000001)); 320 Main.assertTrue(approxEqual(0.8414709848078965, Math.sin(1.0), 0.00000001)); 321 } 322 run()323 public static void run() { 324 convTest(); 325 326 float[] floatResults; 327 double[] doubleResults; 328 int[] intResults; 329 long[] longResults; 330 331 floatResults = floatOperTest(70000.0f, -3.0f); 332 floatOperCheck(floatResults); 333 doubleResults = doubleOperTest(70000.0, -3.0); 334 doubleOperCheck(doubleResults); 335 336 intResults = convI(0x8877665544332211L, 123.456f, -3.1415926535, 0.0f); 337 checkConvI(intResults); 338 longResults = convL(0x88776655, 123.456f, -3.1415926535, 0.0); 339 checkConvL(longResults); 340 floatResults = convF(0x88776655, 0x8877665544332211L, -3.1415926535); 341 checkConvF(floatResults); 342 doubleResults = convD(0x88776655, 0x8877665544332211L, 123.456f); 343 checkConvD(doubleResults); 344 345 unopTest(123.456f); 346 347 checkConsts(); 348 349 jlmTests(3.14159f, 123456.78987654321); 350 } 351 } 352