1561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes/* 2561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * Licensed to the Apache Software Foundation (ASF) under one or more 3561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * contributor license agreements. See the NOTICE file distributed with 4561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * this work for additional information regarding copyright ownership. 5561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * The ASF licenses this file to You under the Apache License, Version 2.0 6561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * (the "License"); you may not use this file except in compliance with 7561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * the License. You may obtain a copy of the License at 8561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * 9561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * http://www.apache.org/licenses/LICENSE-2.0 10561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * 11561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * Unless required by applicable law or agreed to in writing, software 12561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * distributed under the License is distributed on an "AS IS" BASIS, 13561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * See the License for the specific language governing permissions and 15561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * limitations under the License. 16561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes */ 17561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 18561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughespackage org.apache.harmony.luni.tests.java.lang; 19561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 20561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughespublic class MathTest extends junit.framework.TestCase { 21561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 22561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes double HYP = Math.sqrt(2.0); 23561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 24561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes double OPP = 1.0; 25561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 26561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes double ADJ = 1.0; 27561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 28561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes /* Required to make previous preprocessor flags work - do not remove */ 29561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes int unused = 0; 30561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 31561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes /** 32561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * @tests java.lang.Math#abs(double) 33561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes */ 34561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes public void test_absD() { 35561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // Test for method double java.lang.Math.abs(double) 36561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 37561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertTrue("Incorrect double abs value", 38561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes (Math.abs(-1908.8976) == 1908.8976)); 39561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertTrue("Incorrect double abs value", 40561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes (Math.abs(1908.8976) == 1908.8976)); 41561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 42561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 43561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes /** 44561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * @tests java.lang.Math#abs(float) 45561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes */ 46561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes public void test_absF() { 47561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // Test for method float java.lang.Math.abs(float) 48561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertTrue("Incorrect float abs value", 49561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes (Math.abs(-1908.8976f) == 1908.8976f)); 50561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertTrue("Incorrect float abs value", 51561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes (Math.abs(1908.8976f) == 1908.8976f)); 52561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 53561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 54561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes /** 55561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * @tests java.lang.Math#abs(int) 56561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes */ 57561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes public void test_absI() { 58561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // Test for method int java.lang.Math.abs(int) 59561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertTrue("Incorrect int abs value", (Math.abs(-1908897) == 1908897)); 60561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertTrue("Incorrect int abs value", (Math.abs(1908897) == 1908897)); 61561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 62561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 63561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes /** 64561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * @tests java.lang.Math#abs(long) 65561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes */ 66561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes public void test_absJ() { 67561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // Test for method long java.lang.Math.abs(long) 68561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertTrue("Incorrect long abs value", 69561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes (Math.abs(-19088976000089L) == 19088976000089L)); 70561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertTrue("Incorrect long abs value", 71561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes (Math.abs(19088976000089L) == 19088976000089L)); 72561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 73561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 74561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes /** 75561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * @tests java.lang.Math#acos(double) 76561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes */ 77561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes public void test_acosD() { 78561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // Test for method double java.lang.Math.acos(double) 79561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes double r = Math.cos(Math.acos(ADJ / HYP)); 80561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes long lr = Double.doubleToLongBits(r); 81561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes long t = Double.doubleToLongBits(ADJ / HYP); 82561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertTrue("Returned incorrect arc cosine", lr == t || (lr + 1) == t 83561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes || (lr - 1) == t); 84561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 85561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 86561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes /** 87561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * @tests java.lang.Math#asin(double) 88561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes */ 89561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes public void test_asinD() { 90561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // Test for method double java.lang.Math.asin(double) 91561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes double r = Math.sin(Math.asin(OPP / HYP)); 92561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes long lr = Double.doubleToLongBits(r); 93561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes long t = Double.doubleToLongBits(OPP / HYP); 94561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertTrue("Returned incorrect arc sine", lr == t || (lr + 1) == t 95561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes || (lr - 1) == t); 96561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 97561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 98561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes /** 99561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * @tests java.lang.Math#atan(double) 100561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes */ 101561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes public void test_atanD() { 102561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // Test for method double java.lang.Math.atan(double) 103561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes double answer = Math.tan(Math.atan(1.0)); 104561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertTrue("Returned incorrect arc tangent: " + answer, answer <= 1.0 105561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes && answer >= 9.9999999999999983E-1); 106561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 107561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 108561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes /** 109561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * @tests java.lang.Math#atan2(double, double) 110561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes */ 111561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes public void test_atan2DD() { 112561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // Test for method double java.lang.Math.atan2(double, double) 113561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes double answer = Math.atan(Math.tan(1.0)); 114561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertTrue("Returned incorrect arc tangent: " + answer, answer <= 1.0 115561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes && answer >= 9.9999999999999983E-1); 116561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 117561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 118561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes /** 119561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * @tests java.lang.Math#cbrt(double) 120561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes */ 121561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes public void test_cbrt_D() { 122561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes //Test for special situations 123561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertTrue("Should return Double.NaN", Double.isNaN(Math 124561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .cbrt(Double.NaN))); 125561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Should return Double.POSITIVE_INFINITY", 126561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Double.POSITIVE_INFINITY, Math 127561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .cbrt(Double.POSITIVE_INFINITY), 0D); 128561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Should return Double.NEGATIVE_INFINITY", 129561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Double.NEGATIVE_INFINITY, Math 130561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .cbrt(Double.NEGATIVE_INFINITY), 0D); 131561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(Double.doubleToLongBits(0.0), Double.doubleToLongBits(Math 132561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .cbrt(0.0))); 133561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(Double.doubleToLongBits(+0.0), Double.doubleToLongBits(Math 134561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .cbrt(+0.0))); 135561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(Double.doubleToLongBits(-0.0), Double.doubleToLongBits(Math 136561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .cbrt(-0.0))); 137561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 138561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Should return 3.0", 3.0, Math.cbrt(27.0), 0D); 139561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Should return 23.111993172558684", 23.111993172558684, 140561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Math.cbrt(12345.6), 0D); 141561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Should return 5.643803094122362E102", 142561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 5.643803094122362E102, Math.cbrt(Double.MAX_VALUE), 0D); 143561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Should return 0.01", 0.01, Math.cbrt(0.000001), 0D); 144561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 145561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Should return -3.0", -3.0, Math.cbrt(-27.0), 0D); 146561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Should return -23.111993172558684", -23.111993172558684, 147561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Math.cbrt(-12345.6), 0D); 148561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Should return 1.7031839360032603E-108", 149561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1.7031839360032603E-108, Math.cbrt(Double.MIN_VALUE), 0D); 150561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Should return -0.01", -0.01, Math.cbrt(-0.000001), 0D); 151561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 152561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 153561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes /** 154561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * @tests java.lang.Math#ceil(double) 155561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes */ 156561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes public void test_ceilD() { 157561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // Test for method double java.lang.Math.ceil(double) 158561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Incorrect ceiling for double", 159561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 79, Math.ceil(78.89), 0); 160561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Incorrect ceiling for double", 161561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes -78, Math.ceil(-78.89), 0); 162561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 163561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 164561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes /** 165561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * cases for test_copySign_DD in MathTest/StrictMathTest 166561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes */ 167561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes static final double[] COPYSIGN_DD_CASES = new double[] { 168561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Double.POSITIVE_INFINITY, Double.MAX_VALUE, 3.4E302, 2.3, 169561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Double.MIN_NORMAL, Double.MIN_NORMAL / 2, Double.MIN_VALUE, +0.0, 170561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 0.0, -0.0, -Double.MIN_VALUE, -Double.MIN_NORMAL / 2, 171561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes -Double.MIN_NORMAL, -4.5, -3.4E102, -Double.MAX_VALUE, 172561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Double.NEGATIVE_INFINITY }; 173561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 174561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes /** 175561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * @tests {@link java.lang.Math#copySign(double, double)} 176561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * @since 1.6 177561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * 178561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes */ 179561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes @SuppressWarnings("boxing") 180561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes public void test_copySign_DD() { 181561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes for (int i = 0; i < COPYSIGN_DD_CASES.length; i++) { 182561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes final double magnitude = COPYSIGN_DD_CASES[i]; 183561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes final long absMagnitudeBits = Double.doubleToLongBits(Math 184561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .abs(magnitude)); 185561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes final long negMagnitudeBits = Double.doubleToLongBits(-Math 186561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .abs(magnitude)); 187561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 188561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // cases for NaN 189561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("If the sign is NaN, the result should be positive.", 190561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes absMagnitudeBits, Double.doubleToLongBits(Math.copySign( 191561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes magnitude, Double.NaN))); 192561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertTrue("The result should be NaN.", Double.isNaN(Math.copySign( 193561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Double.NaN, magnitude))); 194561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 195561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes for (int j = 0; j < COPYSIGN_DD_CASES.length; j++) { 196561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes final double sign = COPYSIGN_DD_CASES[j]; 197561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes final long resultBits = Double.doubleToLongBits(Math.copySign( 198561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes magnitude, sign)); 199561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 200561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes if (sign > 0 || Double.valueOf(+0.0).equals(sign) 201561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes || Double.valueOf(0.0).equals(sign)) { 202561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals( 203561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes "If the sign is positive, the result should be positive.", 204561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes absMagnitudeBits, resultBits); 205561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 206561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes if (sign < 0 || Double.valueOf(-0.0).equals(sign)) { 207561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals( 208561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes "If the sign is negative, the result should be negative.", 209561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes negMagnitudeBits, resultBits); 210561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 211561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 212561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 213561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 214561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertTrue("The result should be NaN.", Double.isNaN(Math.copySign( 215561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Double.NaN, Double.NaN))); 216561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 217561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes try { 218561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Math.copySign((Double) null, 2.3); 219561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes fail("Should throw NullPointerException"); 220561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } catch (NullPointerException e) { 221561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // Expected 222561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 223561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes try { 224561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Math.copySign(2.3, (Double) null); 225561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes fail("Should throw NullPointerException"); 226561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } catch (NullPointerException e) { 227561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // Expected 228561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 229561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes try { 230561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Math.copySign((Double) null, (Double) null); 231561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes fail("Should throw NullPointerException"); 232561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } catch (NullPointerException e) { 233561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // Expected 234561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 235561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 236561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 237561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes /** 238561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * cases for test_copySign_FF in MathTest/StrictMathTest 239561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes */ 240561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes static final float[] COPYSIGN_FF_CASES = new float[] { 241561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Float.POSITIVE_INFINITY, Float.MAX_VALUE, 3.4E12f, 2.3f, 242561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Float.MIN_NORMAL, Float.MIN_NORMAL / 2, Float.MIN_VALUE, +0.0f, 243561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 0.0f, -0.0f, -Float.MIN_VALUE, -Float.MIN_NORMAL / 2, 244561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes -Float.MIN_NORMAL, -4.5f, -5.6442E21f, -Float.MAX_VALUE, 245561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Float.NEGATIVE_INFINITY }; 246561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 247561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes /** 248561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * @tests {@link java.lang.Math#copySign(float, float)} 249561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * @since 1.6 250561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes */ 251561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes @SuppressWarnings("boxing") 252561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes public void test_copySign_FF() { 253561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes for (int i = 0; i < COPYSIGN_FF_CASES.length; i++) { 254561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes final float magnitude = COPYSIGN_FF_CASES[i]; 255561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes final int absMagnitudeBits = Float.floatToIntBits(Math 256561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .abs(magnitude)); 257561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes final int negMagnitudeBits = Float.floatToIntBits(-Math 258561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .abs(magnitude)); 259561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 260561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // cases for NaN 261561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("If the sign is NaN, the result should be positive.", 262561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes absMagnitudeBits, Float.floatToIntBits(Math.copySign( 263561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes magnitude, Float.NaN))); 264561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertTrue("The result should be NaN.", Float.isNaN(Math.copySign( 265561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Float.NaN, magnitude))); 266561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 267561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes for (int j = 0; j < COPYSIGN_FF_CASES.length; j++) { 268561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes final float sign = COPYSIGN_FF_CASES[j]; 269561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes final int resultBits = Float.floatToIntBits(Math.copySign( 270561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes magnitude, sign)); 271561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes if (sign > 0 || Float.valueOf(+0.0f).equals(sign) 272561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes || Float.valueOf(0.0f).equals(sign)) { 273561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals( 274561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes "If the sign is positive, the result should be positive.", 275561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes absMagnitudeBits, resultBits); 276561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 277561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes if (sign < 0 || Float.valueOf(-0.0f).equals(sign)) { 278561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals( 279561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes "If the sign is negative, the result should be negative.", 280561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes negMagnitudeBits, resultBits); 281561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 282561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 283561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 284561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 285561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertTrue("The result should be NaN.", Float.isNaN(Math.copySign( 286561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Float.NaN, Float.NaN))); 287561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 288561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes try { 289561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Math.copySign((Float) null, 2.3f); 290561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes fail("Should throw NullPointerException"); 291561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } catch (NullPointerException e) { 292561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // Expected 293561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 294561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes try { 295561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Math.copySign(2.3f, (Float) null); 296561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes fail("Should throw NullPointerException"); 297561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } catch (NullPointerException e) { 298561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // Expected 299561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 300561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes try { 301561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Math.copySign((Float) null, (Float) null); 302561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes fail("Should throw NullPointerException"); 303561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } catch (NullPointerException e) { 304561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // Expected 305561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 306561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 307561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 308561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes /** 309561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * @tests java.lang.Math#cos(double) 310561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes */ 311561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes public void test_cosD() { 312561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // Test for method double java.lang.Math.cos(double) 313561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Incorrect answer", 1.0, Math.cos(0), 0D); 314561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Incorrect answer", 0.5403023058681398, Math.cos(1), 0D); 315561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 316561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 317561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes /** 318561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * @tests java.lang.Math#cosh(double) 319561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes */ 320561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes public void test_cosh_D() { 321561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // Test for special situations 322561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertTrue(Double.isNaN(Math.cosh(Double.NaN))); 323561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Should return POSITIVE_INFINITY", 324561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Double.POSITIVE_INFINITY, Math.cosh(Double.POSITIVE_INFINITY), 0D); 325561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Should return POSITIVE_INFINITY", 326561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Double.POSITIVE_INFINITY, Math.cosh(Double.NEGATIVE_INFINITY), 0D); 327561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Should return 1.0", 1.0, Math.cosh(+0.0), 0D); 328561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Should return 1.0", 1.0, Math.cosh(-0.0), 0D); 329561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 330561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Should return POSITIVE_INFINITY", 331561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Double.POSITIVE_INFINITY, Math.cosh(1234.56), 0D); 332561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Should return POSITIVE_INFINITY", 333561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Double.POSITIVE_INFINITY, Math.cosh(-1234.56), 0D); 334561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Should return 1.0000000000005", 1.0000000000005, Math 335561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .cosh(0.000001), 0D); 336561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Should return 1.0000000000005", 1.0000000000005, Math 337561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .cosh(-0.000001), 0D); 338561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Should return 5.212214351945598", 5.212214351945598, Math 339561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .cosh(2.33482), 0D); 340561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 341561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Should return POSITIVE_INFINITY", 342561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Double.POSITIVE_INFINITY, Math.cosh(Double.MAX_VALUE), 0D); 343561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Should return 1.0", 1.0, Math.cosh(Double.MIN_VALUE), 0D); 344561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 345561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 346561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes /** 347561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * @tests java.lang.Math#exp(double) 348561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes */ 349561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes public void test_expD() { 350561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // Test for method double java.lang.Math.exp(double) 351561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertTrue("Incorrect answer returned for simple power", Math.abs(Math 352561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .exp(4D) 353561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes - Math.E * Math.E * Math.E * Math.E) < 0.1D); 354561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertTrue("Incorrect answer returned for larger power", Math.log(Math 355561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .abs(Math.exp(5.5D)) - 5.5D) < 10.0D); 356561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 357561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 358561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes /** 359561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * @tests java.lang.Math#expm1(double) 360561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes */ 361561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes public void test_expm1_D() { 362561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // Test for special cases 363561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertTrue("Should return NaN", Double.isNaN(Math.expm1(Double.NaN))); 364561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Should return POSITIVE_INFINITY", 365561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Double.POSITIVE_INFINITY, Math.expm1(Double.POSITIVE_INFINITY), 0D); 366561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Should return -1.0", -1.0, Math 367561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .expm1(Double.NEGATIVE_INFINITY), 0D); 368561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(Double.doubleToLongBits(0.0), Double.doubleToLongBits(Math 369561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .expm1(0.0))); 370561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(Double.doubleToLongBits(+0.0), Double 371561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .doubleToLongBits(Math.expm1(+0.0))); 372561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(Double.doubleToLongBits(-0.0), Double 373561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .doubleToLongBits(Math.expm1(-0.0))); 374561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 375561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Should return -9.999950000166666E-6", 376561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes -9.999950000166666E-6, Math.expm1(-0.00001), 0D); 377561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Should return 1.0145103074469635E60", 378561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1.0145103074469635E60, Math.expm1(138.16951162), 0D); 379561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Should return POSITIVE_INFINITY", 380561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Double.POSITIVE_INFINITY, Math 381561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .expm1(123456789123456789123456789.4521584223), 0D); 382561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Should return POSITIVE_INFINITY", 383561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Double.POSITIVE_INFINITY, Math.expm1(Double.MAX_VALUE), 0D); 384561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Should return MIN_VALUE", Double.MIN_VALUE, Math 385561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .expm1(Double.MIN_VALUE), 0D); 386561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 387561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 388561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes /** 389561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * @tests java.lang.Math#floor(double) 390561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes */ 391561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes public void test_floorD() { 392561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Incorrect floor for int", 42, Math.floor(42), 0); 393561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Incorrect floor for -int", -2, Math.floor(-2), 0); 394561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Incorrect floor for zero", 0d, Math.floor(0d), 0); 395561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 396561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Incorrect floor for +double", 78, Math.floor(78.89), 0); 397561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Incorrect floor for -double", -79, Math.floor(-78.89), 0); 398561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("floor large +double", 3.7314645675925406E19, Math.floor(3.7314645675925406E19), 0); 399561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("floor large -double", -8.173521839218E12, Math.floor(-8.173521839218E12), 0); 400561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("floor small double", 0.0d, Math.floor(1.11895241315E-102), 0); 401561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 402561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // Compare toString representations here since -0.0 = +0.0, and 403561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // NaN != NaN and we need to distinguish 404561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Floor failed for NaN", 405561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Double.toString(Double.NaN), Double.toString(Math.floor(Double.NaN))); 406561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Floor failed for +0.0", 407561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Double.toString(+0.0d), Double.toString(Math.floor(+0.0d))); 408561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Floor failed for -0.0", 409561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Double.toString(-0.0d), Double.toString(Math.floor(-0.0d))); 410561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Floor failed for +infinity", 411561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Double.toString(Double.POSITIVE_INFINITY), Double.toString(Math.floor(Double.POSITIVE_INFINITY))); 412561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Floor failed for -infinity", 413561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Double.toString(Double.NEGATIVE_INFINITY), Double.toString(Math.floor(Double.NEGATIVE_INFINITY))); 414561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 415561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 416561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes /** 417561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * cases for test_getExponent_D in MathTest/StrictMathTest 418561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes */ 419561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes static final double GETEXPONENT_D_CASES[] = new double[] { 420561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY, 421561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Double.MAX_VALUE, -Double.MAX_VALUE, 2.342E231, -2.342E231, 2800.0, 422561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes -2800.0, 5.323, -5.323, 1.323, -1.323, 0.623, -0.623, 0.323, 423561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes -0.323, Double.MIN_NORMAL * 24, -Double.MIN_NORMAL * 24, 424561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Double.MIN_NORMAL, -Double.MIN_NORMAL, Double.MIN_NORMAL / 2, 425561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes -Double.MIN_NORMAL / 2, Double.MIN_VALUE, -Double.MIN_VALUE, +0.0, 426561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 0.0, -0.0, Double.NaN }; 427561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 428561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes /** 429561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * result for test_getExponent_D in MathTest/StrictMathTest 430561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes */ 431561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes static final int GETEXPONENT_D_RESULTS[] = new int[] { 432561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Double.MAX_EXPONENT + 1, Double.MAX_EXPONENT + 1, 433561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Double.MAX_EXPONENT, Double.MAX_EXPONENT, 768, 768, 11, 11, 2, 2, 434561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 0, 0, -1, -1, -2, -2, -1018, -1018, Double.MIN_EXPONENT, 435561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Double.MIN_EXPONENT, Double.MIN_EXPONENT - 1, 436561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Double.MIN_EXPONENT - 1, Double.MIN_EXPONENT - 1, 437561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Double.MIN_EXPONENT - 1, Double.MIN_EXPONENT - 1, 438561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Double.MIN_EXPONENT - 1, Double.MIN_EXPONENT - 1, 439561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Double.MAX_EXPONENT + 1 }; 440561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 441561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes /** 442561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * @tests {@link java.lang.Math#getExponent(double)} 443561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * @since 1.6 444561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes */ 445561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes @SuppressWarnings("boxing") 446561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes public void test_getExponent_D() { 447561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes for (int i = 0; i < GETEXPONENT_D_CASES.length; i++) { 448561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes final double number = GETEXPONENT_D_CASES[i]; 449561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes final int result = GETEXPONENT_D_RESULTS[i]; 450561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Wrong result of getExponent(double).", result, Math 451561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .getExponent(number)); 452561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 453561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 454561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes try { 455561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Math.getExponent((Double) null); 456561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes fail("Should throw NullPointerException"); 457561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } catch (NullPointerException e) { 458561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // Expected 459561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 460561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 461561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 462561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes /** 463561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * cases for test_getExponent_F in MathTest/StrictMathTest 464561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes */ 465561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes static final float GETEXPONENT_F_CASES[] = new float[] { 466561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Float.POSITIVE_INFINITY, Float.NEGATIVE_INFINITY, Float.MAX_VALUE, 467561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes -Float.MAX_VALUE, 3.4256E23f, -3.4256E23f, 2800.0f, -2800.0f, 468561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 5.323f, -5.323f, 1.323f, -1.323f, 0.623f, -0.623f, 0.323f, -0.323f, 469561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Float.MIN_NORMAL * 24, -Float.MIN_NORMAL * 24, Float.MIN_NORMAL, 470561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes -Float.MIN_NORMAL, Float.MIN_NORMAL / 2, -Float.MIN_NORMAL / 2, 471561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Float.MIN_VALUE, -Float.MIN_VALUE, +0.0f, 0.0f, -0.0f, Float.NaN,1,Float.MIN_NORMAL * 1.5f }; 472561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 473561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes /** 474561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * result for test_getExponent_F in MathTest/StrictMathTest 475561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes */ 476561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes static final int GETEXPONENT_F_RESULTS[] = new int[] { 477561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Float.MAX_EXPONENT + 1, Float.MAX_EXPONENT + 1, Float.MAX_EXPONENT, 478561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Float.MAX_EXPONENT, 78, 78, 11, 11, 2, 2, 0, 0, -1, -1, -2, -2, 479561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes -122, -122, Float.MIN_EXPONENT, Float.MIN_EXPONENT, 480561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Float.MIN_EXPONENT - 1, Float.MIN_EXPONENT - 1, 481561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Float.MIN_EXPONENT - 1, Float.MIN_EXPONENT - 1, 482561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Float.MIN_EXPONENT - 1, Float.MIN_EXPONENT - 1, 483561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Float.MIN_EXPONENT - 1, Float.MAX_EXPONENT + 1,0,Float.MIN_EXPONENT }; 484561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 485561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes /** 486561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * @tests {@link java.lang.Math#getExponent(float)} 487561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * @since 1.6 488561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes */ 489561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes @SuppressWarnings("boxing") 490561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes public void test_getExponent_F() { 491561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes for (int i = 0; i < GETEXPONENT_F_CASES.length; i++) { 492561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes final float number = GETEXPONENT_F_CASES[i]; 493561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes final int result = GETEXPONENT_F_RESULTS[i]; 494561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Wrong result of getExponent(float).", result, Math 495561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .getExponent(number)); 496561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 497561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes try { 498561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Math.getExponent((Float) null); 499561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes fail("Should throw NullPointerException"); 500561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } catch (NullPointerException e) { 501561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // Expected 502561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 503561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 504561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 505561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes /** 506561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * @tests java.lang.Math#hypot(double, double) 507561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes */ 508561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes public void test_hypot_DD() { 509561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // Test for special cases 510561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Should return POSITIVE_INFINITY", 511561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Double.POSITIVE_INFINITY, Math.hypot(Double.POSITIVE_INFINITY, 512561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1.0), 0D); 513561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Should return POSITIVE_INFINITY", 514561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Double.POSITIVE_INFINITY, Math.hypot(Double.NEGATIVE_INFINITY, 515561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 123.324), 0D); 516561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Should return POSITIVE_INFINITY", 517561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Double.POSITIVE_INFINITY, Math.hypot(-758.2587, 518561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Double.POSITIVE_INFINITY), 0D); 519561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Should return POSITIVE_INFINITY", 520561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Double.POSITIVE_INFINITY, Math.hypot(5687.21, 521561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Double.NEGATIVE_INFINITY), 0D); 522561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Should return POSITIVE_INFINITY", 523561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Double.POSITIVE_INFINITY, Math.hypot(Double.POSITIVE_INFINITY, 524561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Double.NEGATIVE_INFINITY), 0D); 525561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Should return POSITIVE_INFINITY", 526561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Double.POSITIVE_INFINITY, Math.hypot(Double.NEGATIVE_INFINITY, 527561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Double.POSITIVE_INFINITY), 0D); 528561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertTrue("Should be NaN", Double.isNaN(Math.hypot(Double.NaN, 529561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 2342301.89843))); 530561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertTrue("Should be NaN", Double.isNaN(Math.hypot(-345.2680, 531561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Double.NaN))); 532561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 533561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Should return 2396424.905416697", 2396424.905416697, Math 534561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .hypot(12322.12, -2396393.2258), 0D); 535561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Should return 138.16958070558556", 138.16958070558556, 536561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Math.hypot(-138.16951162, 0.13817035864), 0D); 537561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Should return 1.7976931348623157E308", 538561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1.7976931348623157E308, Math.hypot(Double.MAX_VALUE, 211370.35), 0D); 539561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Should return 5413.7185", 5413.7185, Math.hypot( 540561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes -5413.7185, Double.MIN_VALUE), 0D); 541561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 542561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 543561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes /** 544561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * @tests java.lang.Math#IEEEremainder(double, double) 545561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes */ 546561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes public void test_IEEEremainderDD() { 547561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // Test for method double java.lang.Math.IEEEremainder(double, double) 548561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Incorrect remainder returned", 549561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 0.0, Math.IEEEremainder(1.0, 1.0), 0D); 550561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertTrue("Incorrect remainder returned", Math.IEEEremainder(1.32, 551561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 89.765) >= 1.4705063220631647E-2 552561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes || Math.IEEEremainder(1.32, 89.765) >= 1.4705063220631649E-2); 553561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 554561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 555561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes /** 556561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * @tests java.lang.Math#log(double) 557561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes */ 558561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes public void test_logD() { 559561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // Test for method double java.lang.Math.log(double) 560561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes for (double d = 10; d >= -10; d -= 0.5) { 561561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes double answer = Math.log(Math.exp(d)); 562561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertTrue("Answer does not equal expected answer for d = " + d 563561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes + " answer = " + answer, Math.abs(answer - d) <= Math 564561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .abs(d * 0.00000001)); 565561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 566561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 567561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 568561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes /** 569561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * @tests java.lang.Math#log10(double) 570561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes */ 571561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes @SuppressWarnings("boxing") 572561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes public void test_log10_D() { 573561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // Test for special cases 574561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertTrue(Double.isNaN(Math.log10(Double.NaN))); 575561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertTrue(Double.isNaN(Math.log10(-2541.05745687234187532))); 576561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertTrue(Double.isNaN(Math.log10(-0.1))); 577561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(Double.POSITIVE_INFINITY, Math.log10(Double.POSITIVE_INFINITY)); 578561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(Double.NEGATIVE_INFINITY, Math.log10(0.0)); 579561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(Double.NEGATIVE_INFINITY, Math.log10(+0.0)); 580561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(Double.NEGATIVE_INFINITY, Math.log10(-0.0)); 581561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 582561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(3.0, Math.log10(1000.0)); 583561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(14.0, Math.log10(Math.pow(10, 14))); 584561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(3.7389561269540406, Math.log10(5482.2158)); 585561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(14.661551142893833, Math.log10(458723662312872.125782332587)); 586561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(-0.9083828622192334, Math.log10(0.12348583358871)); 587561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(308.25471555991675, Math.log10(Double.MAX_VALUE)); 588561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(-323.3062153431158, Math.log10(Double.MIN_VALUE)); 589561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 590561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 591561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes /** 592561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * @tests java.lang.Math#log1p(double) 593561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes */ 594561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes public void test_log1p_D() { 595561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // Test for special cases 596561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertTrue("Should return NaN", Double.isNaN(Math.log1p(Double.NaN))); 597561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertTrue("Should return NaN", Double.isNaN(Math.log1p(-32.0482175))); 598561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Should return POSITIVE_INFINITY", 599561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Double.POSITIVE_INFINITY, Math.log1p(Double.POSITIVE_INFINITY), 0D); 600561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(Double.doubleToLongBits(0.0), Double.doubleToLongBits(Math 601561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .log1p(0.0))); 602561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(Double.doubleToLongBits(+0.0), Double 603561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .doubleToLongBits(Math.log1p(+0.0))); 604561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(Double.doubleToLongBits(-0.0), Double 605561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .doubleToLongBits(Math.log1p(-0.0))); 606561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 607561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Should return -0.2941782295312541", -0.2941782295312541, 608561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Math.log1p(-0.254856327), 0D); 609561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Should return 7.368050685564151", 7.368050685564151, Math 610561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .log1p(1583.542), 0D); 611561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Should return 0.4633708685409921", 0.4633708685409921, 612561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Math.log1p(0.5894227), 0D); 613561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Should return 709.782712893384", 709.782712893384, Math 614561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .log1p(Double.MAX_VALUE), 0D); 615561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Should return Double.MIN_VALUE", Double.MIN_VALUE, Math 616561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .log1p(Double.MIN_VALUE), 0D); 617561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 618561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 619561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes /** 620561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * @tests java.lang.Math#max(double, double) 621561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes */ 622561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes public void test_maxDD() { 623561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // Test for method double java.lang.Math.max(double, double) 624561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Incorrect double max value", 1908897.6000089, Math.max(-1908897.6000089, 625561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1908897.6000089), 0D); 626561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Incorrect double max value", 627561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1908897.6000089, Math.max(2.0, 1908897.6000089), 0D); 628561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Incorrect double max value", -2.0, Math.max(-2.0, 629561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes -1908897.6000089), 0D); 630561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 631561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // Compare toString representations here since -0.0 = +0.0, and 632561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // NaN != NaN and we need to distinguish 633561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Max failed for NaN", 634561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Double.toString(Double.NaN), Double.toString(Math.max(Double.NaN, 42.0d))); 635561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Max failed for NaN", 636561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Double.toString(Double.NaN), Double.toString(Math.max(42.0d, Double.NaN))); 637561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Max failed for 0.0", 638561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Double.toString(+0.0d), Double.toString(Math.max(+0.0d, -0.0d))); 639561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Max failed for 0.0", 640561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Double.toString(+0.0d), Double.toString(Math.max(-0.0d, +0.0d))); 641561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Max failed for -0.0d", 642561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Double.toString(-0.0d), Double.toString(Math.max(-0.0d, -0.0d))); 643561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Max failed for 0.0", 644561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Double.toString(+0.0d), Double.toString(Math.max(+0.0d, +0.0d))); 645561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 646561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 647561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes /** 648561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * @tests java.lang.Math#max(float, float) 649561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes */ 650561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes public void test_maxFF() { 651561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // Test for method float java.lang.Math.max(float, float) 652561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertTrue("Incorrect float max value", Math.max(-1908897.600f, 653561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1908897.600f) == 1908897.600f); 654561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertTrue("Incorrect float max value", 655561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Math.max(2.0f, 1908897.600f) == 1908897.600f); 656561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertTrue("Incorrect float max value", 657561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Math.max(-2.0f, -1908897.600f) == -2.0f); 658561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 659561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // Compare toString representations here since -0.0 = +0.0, and 660561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // NaN != NaN and we need to distinguish 661561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Max failed for NaN", 662561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Float.toString(Float.NaN), Float.toString(Math.max(Float.NaN, 42.0f))); 663561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Max failed for NaN", 664561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Float.toString(Float.NaN), Float.toString(Math.max(42.0f, Float.NaN))); 665561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Max failed for 0.0", 666561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Float.toString(+0.0f), Float.toString(Math.max(+0.0f, -0.0f))); 667561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Max failed for 0.0", 668561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Float.toString(+0.0f), Float.toString(Math.max(-0.0f, +0.0f))); 669561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Max failed for -0.0f", 670561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Float.toString(-0.0f), Float.toString(Math.max(-0.0f, -0.0f))); 671561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Max failed for 0.0", 672561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Float.toString(+0.0f), Float.toString(Math.max(+0.0f, +0.0f))); 673561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 674561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 675561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes /** 676561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * @tests java.lang.Math#max(int, int) 677561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes */ 678561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes public void test_maxII() { 679561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // Test for method int java.lang.Math.max(int, int) 680561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Incorrect int max value", 681561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 19088976, Math.max(-19088976, 19088976)); 682561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Incorrect int max value", 683561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 19088976, Math.max(20, 19088976)); 684561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Incorrect int max value", -20, Math.max(-20, -19088976)); 685561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 686561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 687561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes /** 688561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * @tests java.lang.Math#max(long, long) 689561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes */ 690561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes public void test_maxJJ() { 691561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // Test for method long java.lang.Math.max(long, long) 692561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Incorrect long max value", 19088976000089L, Math.max(-19088976000089L, 693561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 19088976000089L)); 694561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Incorrect long max value", 695561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 19088976000089L, Math.max(20, 19088976000089L)); 696561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Incorrect long max value", 697561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes -20, Math.max(-20, -19088976000089L)); 698561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 699561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 700561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes /** 701561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * @tests java.lang.Math#min(double, double) 702561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes */ 703561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes public void test_minDD() { 704561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // Test for method double java.lang.Math.min(double, double) 705561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Incorrect double min value", -1908897.6000089, Math.min(-1908897.6000089, 706561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1908897.6000089), 0D); 707561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Incorrect double min value", 708561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 2.0, Math.min(2.0, 1908897.6000089), 0D); 709561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Incorrect double min value", -1908897.6000089, Math.min(-2.0, 710561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes -1908897.6000089), 0D); 711561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Incorrect double min value", 1.0d, Math.min(1.0d, 1.0d)); 712561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 713561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // Compare toString representations here since -0.0 = +0.0, and 714561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // NaN != NaN and we need to distinguish 715561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Min failed for NaN", 716561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Double.toString(Double.NaN), Double.toString(Math.min(Double.NaN, 42.0d))); 717561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Min failed for NaN", 718561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Double.toString(Double.NaN), Double.toString(Math.min(42.0d, Double.NaN))); 719561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Min failed for -0.0", 720561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Double.toString(-0.0d), Double.toString(Math.min(+0.0d, -0.0d))); 721561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Min failed for -0.0", 722561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Double.toString(-0.0d), Double.toString(Math.min(-0.0d, +0.0d))); 723561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Min failed for -0.0d", 724561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Double.toString(-0.0d), Double.toString(Math.min(-0.0d, -0.0d))); 725561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Min failed for 0.0", 726561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Double.toString(+0.0d), Double.toString(Math.min(+0.0d, +0.0d))); 727561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 728561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 729561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes /** 730561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * @tests java.lang.Math#min(float, float) 731561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes */ 732561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes public void test_minFF() { 733561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // Test for method float java.lang.Math.min(float, float) 734561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertTrue("Incorrect float min value", Math.min(-1908897.600f, 735561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1908897.600f) == -1908897.600f); 736561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertTrue("Incorrect float min value", 737561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Math.min(2.0f, 1908897.600f) == 2.0f); 738561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertTrue("Incorrect float min value", 739561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Math.min(-2.0f, -1908897.600f) == -1908897.600f); 740561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Incorrect float min value", 1.0f, Math.min(1.0f, 1.0f)); 741561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 742561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // Compare toString representations here since -0.0 = +0.0, and 743561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // NaN != NaN and we need to distinguish 744561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Min failed for NaN", 745561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Float.toString(Float.NaN), Float.toString(Math.min(Float.NaN, 42.0f))); 746561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Min failed for NaN", 747561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Float.toString(Float.NaN), Float.toString(Math.min(42.0f, Float.NaN))); 748561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Min failed for -0.0", 749561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Float.toString(-0.0f), Float.toString(Math.min(+0.0f, -0.0f))); 750561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Min failed for -0.0", 751561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Float.toString(-0.0f), Float.toString(Math.min(-0.0f, +0.0f))); 752561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Min failed for -0.0f", 753561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Float.toString(-0.0f), Float.toString(Math.min(-0.0f, -0.0f))); 754561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Min failed for 0.0", 755561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Float.toString(+0.0f), Float.toString(Math.min(+0.0f, +0.0f))); 756561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 757561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 758561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes /** 759561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * @tests java.lang.Math#min(int, int) 760561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes */ 761561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes public void test_minII() { 762561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // Test for method int java.lang.Math.min(int, int) 763561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Incorrect int min value", 764561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes -19088976, Math.min(-19088976, 19088976)); 765561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Incorrect int min value", 20, Math.min(20, 19088976)); 766561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Incorrect int min value", 767561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes -19088976, Math.min(-20, -19088976)); 768561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 769561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 770561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 771561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes /** 772561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * @tests java.lang.Math#min(long, long) 773561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes */ 774561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes public void test_minJJ() { 775561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // Test for method long java.lang.Math.min(long, long) 776561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Incorrect long min value", -19088976000089L, Math.min(-19088976000089L, 777561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 19088976000089L)); 778561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Incorrect long min value", 779561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 20, Math.min(20, 19088976000089L)); 780561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Incorrect long min value", 781561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes -19088976000089L, Math.min(-20, -19088976000089L)); 782561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 783561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 784561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes /** 785561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * start number cases for test_nextAfter_DD in MathTest/StrictMathTest 786561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * NEXTAFTER_DD_START_CASES[i][0] is the start number 787561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * NEXTAFTER_DD_START_CASES[i][1] is the nextUp of start number 788561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * NEXTAFTER_DD_START_CASES[i][2] is the nextDown of start number 789561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes */ 790561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes static final double NEXTAFTER_DD_START_CASES[][] = new double[][] { 791561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes { 3.4, 3.4000000000000004, 3.3999999999999995 }, 792561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes { -3.4, -3.3999999999999995, -3.4000000000000004 }, 793561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes { 3.4233E109, 3.4233000000000005E109, 3.4232999999999996E109 }, 794561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes { -3.4233E109, -3.4232999999999996E109, -3.4233000000000005E109 }, 795561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes { +0.0, Double.MIN_VALUE, -Double.MIN_VALUE }, 796561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes { 0.0, Double.MIN_VALUE, -Double.MIN_VALUE }, 797561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes { -0.0, Double.MIN_VALUE, -Double.MIN_VALUE }, 798561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes { Double.MIN_VALUE, 1.0E-323, +0.0 }, 799561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes { -Double.MIN_VALUE, -0.0, -1.0E-323 }, 800561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes { Double.MIN_NORMAL, 2.225073858507202E-308, 2.225073858507201E-308 }, 801561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes { -Double.MIN_NORMAL, -2.225073858507201E-308, 802561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes -2.225073858507202E-308 }, 803561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes { Double.MAX_VALUE, Double.POSITIVE_INFINITY, 804561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1.7976931348623155E308 }, 805561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes { -Double.MAX_VALUE, -1.7976931348623155E308, 806561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Double.NEGATIVE_INFINITY }, 807561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes { Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY, 808561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Double.MAX_VALUE }, 809561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes { Double.NEGATIVE_INFINITY, -Double.MAX_VALUE, 810561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Double.NEGATIVE_INFINITY } }; 811561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 812561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes /** 813561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * direction number cases for test_nextAfter_DD/test_nextAfter_FD in 814561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * MathTest/StrictMathTest 815561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes */ 816561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes static final double NEXTAFTER_DD_FD_DIRECTION_CASES[] = new double[] { 817561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Double.POSITIVE_INFINITY, Double.MAX_VALUE, 8.8, 3.4, 1.4, 818561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Double.MIN_NORMAL, Double.MIN_NORMAL / 2, Double.MIN_VALUE, +0.0, 819561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 0.0, -0.0, -Double.MIN_VALUE, -Double.MIN_NORMAL / 2, 820561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes -Double.MIN_NORMAL, -1.4, -3.4, -8.8, -Double.MAX_VALUE, 821561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Double.NEGATIVE_INFINITY }; 822561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 823561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes /** 824561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * @tests {@link java.lang.Math#nextAfter(double, double)} 825561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * @since 1.6 826561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes */ 827561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes @SuppressWarnings("boxing") 828561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes public void test_nextAfter_DD() { 829561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // test for most cases without exception 830561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes for (int i = 0; i < NEXTAFTER_DD_START_CASES.length; i++) { 831561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes final double start = NEXTAFTER_DD_START_CASES[i][0]; 832561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes final long nextUpBits = Double 833561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .doubleToLongBits(NEXTAFTER_DD_START_CASES[i][1]); 834561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes final long nextDownBits = Double 835561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .doubleToLongBits(NEXTAFTER_DD_START_CASES[i][2]); 836561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 837561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes for (int j = 0; j < NEXTAFTER_DD_FD_DIRECTION_CASES.length; j++) { 838561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes final double direction = NEXTAFTER_DD_FD_DIRECTION_CASES[j]; 839561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes final long resultBits = Double.doubleToLongBits(Math.nextAfter( 840561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes start, direction)); 841561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes final long directionBits = Double.doubleToLongBits(direction); 842561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes if (direction > start) { 843561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Result should be next up-number.", 844561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes nextUpBits, resultBits); 845561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } else if (direction < start) { 846561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Result should be next down-number.", 847561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes nextDownBits, resultBits); 848561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } else { 849561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Result should be direction.", directionBits, 850561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes resultBits); 851561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 852561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 853561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 854561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 855561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // test for cases with NaN 856561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes for (int i = 0; i < NEXTAFTER_DD_START_CASES.length; i++) { 857561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertTrue("The result should be NaN.", Double.isNaN(Math 858561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .nextAfter(NEXTAFTER_DD_START_CASES[i][0], Double.NaN))); 859561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 860561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes for (int i = 0; i < NEXTAFTER_DD_FD_DIRECTION_CASES.length; i++) { 861561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertTrue("The result should be NaN.", Double.isNaN(Math 862561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .nextAfter(Double.NaN, NEXTAFTER_DD_FD_DIRECTION_CASES[i]))); 863561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 864561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertTrue("The result should be NaN.", Double.isNaN(Math.nextAfter( 865561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Double.NaN, Double.NaN))); 866561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 867561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // test for exception 868561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes try { 869561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Math.nextAfter((Double) null, 2.3); 870561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes fail("Should throw NullPointerException"); 871561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } catch (NullPointerException e) { 872561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // Expected 873561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 874561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes try { 875561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Math.nextAfter(2.3, (Double) null); 876561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes fail("Should throw NullPointerException"); 877561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } catch (NullPointerException e) { 878561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // Expected 879561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 880561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes try { 881561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Math.nextAfter((Double) null, (Double) null); 882561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes fail("Should throw NullPointerException"); 883561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } catch (NullPointerException e) { 884561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // Expected 885561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 886561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 887561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 888561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes /** 889561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * start number cases for test_nextAfter_FD in MathTest/StrictMathTest 890561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * NEXTAFTER_FD_START_CASES[i][0] is the start number 891561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * NEXTAFTER_FD_START_CASES[i][1] is the nextUp of start number 892561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * NEXTAFTER_FD_START_CASES[i][2] is the nextDown of start number 893561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes */ 894561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes static final float NEXTAFTER_FD_START_CASES[][] = new float[][] { 895561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes { 3.4f, 3.4000003f, 3.3999999f }, 896561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes { -3.4f, -3.3999999f, -3.4000003f }, 897561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes { 3.4233E19f, 3.4233002E19f, 3.4232998E19f }, 898561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes { -3.4233E19f, -3.4232998E19f, -3.4233002E19f }, 899561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes { +0.0f, Float.MIN_VALUE, -Float.MIN_VALUE }, 900561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes { 0.0f, Float.MIN_VALUE, -Float.MIN_VALUE }, 901561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes { -0.0f, Float.MIN_VALUE, -Float.MIN_VALUE }, 902561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes { Float.MIN_VALUE, 2.8E-45f, +0.0f }, 903561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes { -Float.MIN_VALUE, -0.0f, -2.8E-45f }, 904561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes { Float.MIN_NORMAL, 1.1754945E-38f, 1.1754942E-38f }, 905561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes { -Float.MIN_NORMAL, -1.1754942E-38f, -1.1754945E-38f }, 906561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes { Float.MAX_VALUE, Float.POSITIVE_INFINITY, 3.4028233E38f }, 907561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes { -Float.MAX_VALUE, -3.4028233E38f, Float.NEGATIVE_INFINITY }, 908561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes { Float.POSITIVE_INFINITY, Float.POSITIVE_INFINITY, Float.MAX_VALUE }, 909561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes { Float.NEGATIVE_INFINITY, -Float.MAX_VALUE, 910561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Float.NEGATIVE_INFINITY } }; 911561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 912561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes /** 913561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * @tests {@link java.lang.Math#nextAfter(float, double)} 914561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * @since 1.6 915561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes */ 916561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes @SuppressWarnings("boxing") 917561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes public void test_nextAfter_FD() { 918561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // test for most cases without exception 919561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes for (int i = 0; i < NEXTAFTER_FD_START_CASES.length; i++) { 920561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes final float start = NEXTAFTER_FD_START_CASES[i][0]; 921561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes final int nextUpBits = Float 922561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .floatToIntBits(NEXTAFTER_FD_START_CASES[i][1]); 923561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes final int nextDownBits = Float 924561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .floatToIntBits(NEXTAFTER_FD_START_CASES[i][2]); 925561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 926561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes for (int j = 0; j < NEXTAFTER_DD_FD_DIRECTION_CASES.length; j++) { 927561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes final double direction = NEXTAFTER_DD_FD_DIRECTION_CASES[j]; 928561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes final int resultBits = Float.floatToIntBits(Math.nextAfter( 929561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes start, direction)); 930561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes if (direction > start) { 931561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Result should be next up-number.", 932561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes nextUpBits, resultBits); 933561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } else if (direction < start) { 934561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Result should be next down-number.", 935561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes nextDownBits, resultBits); 936561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } else { 937561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes final int equivalentBits = Float.floatToIntBits(new Float( 938561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes direction)); 939561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals( 940561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes "Result should be a number equivalent to direction.", 941561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes equivalentBits, resultBits); 942561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 943561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 944561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 945561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 946561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // test for cases with NaN 947561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes for (int i = 0; i < NEXTAFTER_FD_START_CASES.length; i++) { 948561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertTrue("The result should be NaN.", Float.isNaN(Math.nextAfter( 949561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes NEXTAFTER_FD_START_CASES[i][0], Float.NaN))); 950561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 951561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes for (int i = 0; i < NEXTAFTER_DD_FD_DIRECTION_CASES.length; i++) { 952561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertTrue("The result should be NaN.", Float.isNaN(Math.nextAfter( 953561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Float.NaN, NEXTAFTER_DD_FD_DIRECTION_CASES[i]))); 954561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 955561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertTrue("The result should be NaN.", Float.isNaN(Math.nextAfter( 956561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Float.NaN, Float.NaN))); 957561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 958561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // test for exception 959561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes try { 960561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Math.nextAfter((Float) null, 2.3); 961561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes fail("Should throw NullPointerException"); 962561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } catch (NullPointerException e) { 963561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // Expected 964561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 965561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes try { 966561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Math.nextAfter(2.3, (Float) null); 967561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes fail("Should throw NullPointerException"); 968561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } catch (NullPointerException e) { 969561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // Expected 970561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 971561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes try { 972561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Math.nextAfter((Float) null, (Float) null); 973561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes fail("Should throw NullPointerException"); 974561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } catch (NullPointerException e) { 975561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // Expected 976561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 977561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 978561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 979561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes /** 980561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * @tests {@link java.lang.Math#nextUp(double)} 981561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * @since 1.6 982561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes */ 983561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes @SuppressWarnings("boxing") 984561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes public void test_nextUp_D() { 985561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // This method is semantically equivalent to nextAfter(d, 986561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // Double.POSITIVE_INFINITY), 987561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // so we use the data of test_nextAfter_DD 988561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes for (int i = 0; i < NEXTAFTER_DD_START_CASES.length; i++) { 989561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes final double start = NEXTAFTER_DD_START_CASES[i][0]; 990561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes final long nextUpBits = Double 991561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .doubleToLongBits(NEXTAFTER_DD_START_CASES[i][1]); 992561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes final long resultBits = Double.doubleToLongBits(Math.nextUp(start)); 993561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Result should be next up-number.", nextUpBits, 994561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes resultBits); 995561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 996561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 997561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // test for cases with NaN 998561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertTrue("The result should be NaN.", Double.isNaN(Math 999561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .nextUp(Double.NaN))); 1000561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1001561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // test for exception 1002561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes try { 1003561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Math.nextUp((Double) null); 1004561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes fail("Should throw NullPointerException"); 1005561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } catch (NullPointerException e) { 1006561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // Expected 1007561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 1008561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 1009561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1010561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes /** 1011561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * @tests {@link java.lang.Math#nextUp(float)} 1012561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * @since 1.6 1013561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes */ 1014561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes @SuppressWarnings("boxing") 1015561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes public void test_nextUp_F() { 1016561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // This method is semantically equivalent to nextAfter(f, 1017561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // Float.POSITIVE_INFINITY), 1018561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // so we use the data of test_nextAfter_FD 1019561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes for (int i = 0; i < NEXTAFTER_FD_START_CASES.length; i++) { 1020561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes final float start = NEXTAFTER_FD_START_CASES[i][0]; 1021561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes final int nextUpBits = Float 1022561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .floatToIntBits(NEXTAFTER_FD_START_CASES[i][1]); 1023561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes final int resultBits = Float.floatToIntBits(Math.nextUp(start)); 1024561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Result should be next up-number.", nextUpBits, 1025561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes resultBits); 1026561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 1027561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1028561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // test for cases with NaN 1029561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertTrue("The result should be NaN.", Float.isNaN(Math 1030561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .nextUp(Float.NaN))); 1031561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1032561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // test for exception 1033561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes try { 1034561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Math.nextUp((Float) null); 1035561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes fail("Should throw NullPointerException"); 1036561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } catch (NullPointerException e) { 1037561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // Expected 1038561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 1039561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 1040561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1041561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes /** 1042561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * @tests java.lang.Math#pow(double, double) 1043561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes */ 1044561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes public void test_powDD() { 1045561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // Test for method double java.lang.Math.pow(double, double) 1046561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes double NZERO = longTodouble(doubleTolong(0.0) ^ 0x8000000000000000L); 1047561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes double p1 = 1.0; 1048561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes double p2 = 2.0; 1049561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes double p3 = 3.0; 1050561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes double p4 = 4.0; 1051561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes double p5 = 5.0; 1052561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes double p6 = 6.0; 1053561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes double p7 = 7.0; 1054561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes double p8 = 8.0; 1055561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes double p9 = 9.0; 1056561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes double p10 = 10.0; 1057561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes double p11 = 11.0; 1058561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes double p12 = 12.0; 1059561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes double p13 = 13.0; 1060561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes double p14 = 14.0; 1061561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes double p15 = 15.0; 1062561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes double p16 = 16.0; 1063561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes double[] values = { p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, 1064561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes p13, p14, p15, p16 }; 1065561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1066561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes for (int x = 0; x < values.length; x++) { 1067561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes double dval = values[x]; 1068561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes double nagateDval = negateDouble(dval); 1069561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes if (nagateDval == Double.NaN) { 1070561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes continue; 1071561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 1072561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1073561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // If the second argument is positive or negative zero, then the 1074561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // result is 1.0. 1075561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Result should be Math.pow(" + dval 1076561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes + ",-0.0)=+1.0", 1.0, Math.pow(dval, NZERO)); 1077561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Result should be Math.pow(" + nagateDval 1078561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes + ",-0.0)=+1.0", 1.0, Math.pow(nagateDval, NZERO)); 1079561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Result should be Math.pow(" + dval 1080561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes + ",+0.0)=+1.0", 1.0, Math.pow(dval, +0.0)); 1081561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Result should be Math.pow(" + nagateDval 1082561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes + ",+0.0)=+1.0", 1.0, Math.pow(nagateDval, +0.0)); 1083561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1084561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // If the second argument is 1.0, then the result is the same as the 1085561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // first argument. 1086561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Result should be Math.pow(" + dval + "," + 1.0 + ")=" 1087561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes + dval, dval, Math.pow(dval, 1.0)); 1088561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Result should be Math.pow(" + nagateDval + "," + 1.0 1089561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes + ")=" + nagateDval, nagateDval, Math.pow(nagateDval, 1.0)); 1090561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1091561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // If the second argument is NaN, then the result is NaN. 1092561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Result should be Math.pow(" + dval + "," + Double.NaN 1093561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes + ")=" + Double.NaN, Double.NaN, Math.pow(dval, Double.NaN)); 1094561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Result should be Math.pow(" + nagateDval + "," 1095561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes + Double.NaN + ")=" + Double.NaN, Double.NaN, Math.pow(nagateDval, 1096561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Double.NaN)); 1097561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1098561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes if (dval > 1) { 1099561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // If the first argument is NaN and the second argument is 1100561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // nonzero, 1101561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // then the result is NaN. 1102561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Result should be Math.pow(" + Double.NaN + "," 1103561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes + dval + ")=" + Double.NaN, Double.NaN, Math.pow(Double.NaN, dval)); 1104561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Result should be Math.pow(" + Double.NaN + "," 1105561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes + nagateDval + ")=" + Double.NaN, Double.NaN, Math.pow(Double.NaN, 1106561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes nagateDval)); 1107561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1108561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes /* 1109561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * If the first argument is positive zero and the second 1110561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * argument is greater than zero, or the first argument is 1111561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * positive infinity and the second argument is less than zero, 1112561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * then the result is positive zero. 1113561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes */ 1114561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Result should be Math.pow(" + 0.0 + "," + dval 1115561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes + ")=" + 0.0, +0.0, Math.pow(0.0, dval)); 1116561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Result should be Math.pow(" 1117561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes + Double.POSITIVE_INFINITY + "," + nagateDval + ")=" 1118561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes + 0.0, +0.0, Math.pow(Double.POSITIVE_INFINITY, nagateDval)); 1119561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1120561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes /* 1121561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * If the first argument is positive zero and the second 1122561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * argument is less than zero, or the first argument is positive 1123561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * infinity and the second argument is greater than zero, then 1124561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * the result is positive infinity. 1125561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes */ 1126561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Result should be Math.pow(" + 0.0 + "," 1127561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes + nagateDval + ")=" + Double.POSITIVE_INFINITY,Double.POSITIVE_INFINITY, 1128561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Math.pow(0.0, nagateDval)); 1129561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Result should be Math.pow(" 1130561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes + Double.POSITIVE_INFINITY + "," + dval + ")=" 1131561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes + Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY, Math.pow( 1132561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Double.POSITIVE_INFINITY, dval)); 1133561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1134561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // Not a finite odd integer 1135561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes if (dval % 2 == 0) { 1136561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes /* 1137561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * If the first argument is negative zero and the second 1138561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * argument is greater than zero but not a finite odd 1139561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * integer, or the first argument is negative infinity and 1140561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * the second argument is less than zero but not a finite 1141561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * odd integer, then the result is positive zero. 1142561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes */ 1143561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Result should be Math.pow(" + NZERO + "," 1144561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes + dval + ")=" + 0.0, +0.0, Math.pow(NZERO, dval)); 1145561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Result should be Math.pow(" 1146561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes + Double.NEGATIVE_INFINITY + "," + nagateDval 1147561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes + ")=" + 0.0, +0.0, Math.pow(Double.NEGATIVE_INFINITY, 1148561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes nagateDval)); 1149561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1150561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes /* 1151561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * If the first argument is negative zero and the second 1152561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * argument is less than zero but not a finite odd integer, 1153561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * or the first argument is negative infinity and the second 1154561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * argument is greater than zero but not a finite odd 1155561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * integer, then the result is positive infinity. 1156561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes */ 1157561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Result should be Math.pow(" + NZERO + "," 1158561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes + nagateDval + ")=" + Double.POSITIVE_INFINITY,Double.POSITIVE_INFINITY, 1159561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Math.pow(NZERO, nagateDval)); 1160561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Result should be Math.pow(" 1161561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes + Double.NEGATIVE_INFINITY + "," + dval + ")=" 1162561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes + Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY, Math.pow( 1163561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Double.NEGATIVE_INFINITY, dval)); 1164561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 1165561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1166561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // finite odd integer 1167561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes if (dval % 2 != 0) { 1168561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes /* 1169561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * If the first argument is negative zero and the second 1170561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * argument is a positive finite odd integer, or the first 1171561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * argument is negative infinity and the second argument is 1172561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * a negative finite odd integer, then the result is 1173561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * negative zero. 1174561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes */ 1175561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Result should be Math.pow(" + NZERO + "," 1176561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes + dval + ")=" + NZERO, NZERO, Math.pow(NZERO, dval)); 1177561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Result should be Math.pow(" 1178561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes + Double.NEGATIVE_INFINITY + "," + nagateDval 1179561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes + ")=" + NZERO, NZERO, Math.pow(Double.NEGATIVE_INFINITY, 1180561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes nagateDval)); 1181561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes /* 1182561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * If the first argument is negative zero and the second 1183561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * argument is a negative finite odd integer, or the first 1184561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * argument is negative infinity and the second argument is 1185561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * a positive finite odd integer then the result is negative 1186561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * infinity. 1187561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes */ 1188561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Result should be Math.pow(" + NZERO + "," 1189561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes + nagateDval + ")=" + Double.NEGATIVE_INFINITY,Double.NEGATIVE_INFINITY, 1190561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Math.pow(NZERO, nagateDval)); 1191561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Result should be Math.pow(" 1192561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes + Double.NEGATIVE_INFINITY + "," + dval + ")=" 1193561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes + Double.NEGATIVE_INFINITY, Double.NEGATIVE_INFINITY, Math.pow( 1194561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Double.NEGATIVE_INFINITY, dval)); 1195561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 1196561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1197561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes /** 1198561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * 1. If the first argument is finite and less than zero if the 1199561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * second argument is a finite even integer, the result is equal 1200561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * to the result of raising the absolute value of the first 1201561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * argument to the power of the second argument 1202561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * 1203561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * 2. if the second argument is a finite odd integer, the result is equal to the 1204561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * negative of the result of raising the absolute value of the 1205561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * first argument to the power of the second argument 1206561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * 1207561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * 3. if the second argument is finite and not an integer, then the result 1208561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * is NaN. 1209561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes */ 1210561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes for (int j = 1; j < values.length; j++) { 1211561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes double jval = values[j]; 1212561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes if (jval % 2.0 == 0.0) { 1213561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("" + nagateDval + " " + jval, Math.pow( 1214561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes dval, jval), Math.pow(nagateDval, jval)); 1215561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } else { 1216561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("" + nagateDval + " " + jval, -1.0 1217561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * Math.pow(dval, jval), Math.pow(nagateDval, 1218561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes jval)); 1219561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 1220561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(Double.NaN, Math 1221561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .pow(nagateDval, jval / 0.5467)); 1222561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(Double.NaN, Math.pow(nagateDval, -1.0 * jval 1223561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes / 0.5467)); 1224561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 1225561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 1226561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1227561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // If the absolute value of the first argument equals 1 and the 1228561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // second argument is infinite, then the result is NaN. 1229561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes if (dval == 1) { 1230561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Result should be Math.pow(" + dval + "," 1231561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes + Double.POSITIVE_INFINITY + ")=" + Double.NaN, Double.NaN, Math 1232561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .pow(dval, Double.POSITIVE_INFINITY)); 1233561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Result should be Math.pow(" + dval + "," 1234561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes + Double.NEGATIVE_INFINITY + ")=" + Double.NaN, Double.NaN, Math 1235561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .pow(dval, Double.NEGATIVE_INFINITY)); 1236561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1237561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Result should be Math.pow(" + nagateDval + "," 1238561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes + Double.POSITIVE_INFINITY + ")=" + Double.NaN, Double.NaN, Math 1239561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .pow(nagateDval, Double.POSITIVE_INFINITY)); 1240561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Result should be Math.pow(" + nagateDval + "," 1241561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes + Double.NEGATIVE_INFINITY + ")=" + Double.NaN, Double.NaN, Math 1242561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .pow(nagateDval, Double.NEGATIVE_INFINITY)); 1243561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 1244561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1245561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes if (dval > 1) { 1246561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes /* 1247561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * If the absolute value of the first argument is greater than 1 1248561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * and the second argument is positive infinity, or the absolute 1249561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * value of the first argument is less than 1 and the second 1250561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * argument is negative infinity, then the result is positive 1251561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * infinity. 1252561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes */ 1253561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Result should be Math.pow(" + dval + "," 1254561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes + Double.POSITIVE_INFINITY + ")=" 1255561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes + Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY, Math.pow(dval, 1256561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Double.POSITIVE_INFINITY)); 1257561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1258561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Result should be Math.pow(" + nagateDval + "," 1259561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes + Double.NEGATIVE_INFINITY + ")=" 1260561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes + Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY, Math.pow(-0.13456, 1261561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Double.NEGATIVE_INFINITY)); 1262561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1263561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes /* 1264561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * If the absolute value of the first argument is greater than 1 1265561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * and the second argument is negative infinity, or the absolute 1266561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * value of the first argument is less than 1 and the second 1267561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * argument is positive infinity, then the result is positive 1268561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * zero. 1269561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes */ 1270561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Result should be Math.pow(" + dval + "," 1271561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes + Double.NEGATIVE_INFINITY + ")= +0.0", +0.0, Math.pow(dval, 1272561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Double.NEGATIVE_INFINITY)); 1273561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Result should be Math.pow(" + nagateDval + "," 1274561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes + Double.POSITIVE_INFINITY + ")= +0.0", +0.0, Math.pow( 1275561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes -0.13456, Double.POSITIVE_INFINITY)); 1276561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 1277561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1278561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Result should be Math.pow(" + 0.0 + "," + dval + ")=" 1279561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes + 0.0, 0.0, Math.pow(0.0, dval)); 1280561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Result should be Math.pow(" + Double.NaN + "," + dval 1281561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes + ")=" + Double.NaN, Double.NaN, Math.pow(Double.NaN, dval)); 1282561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 1283561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertTrue("pow returned incorrect value", 1284561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes (long) Math.pow(2, 8) == 256l); 1285561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertTrue("pow returned incorrect value", 1286561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Math.pow(2, -8) == 0.00390625d); 1287561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Incorrect root returned1", 1288561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 2, Math.sqrt(Math.pow(Math.sqrt(2), 4)), 0); 1289561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1290561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(Double.NEGATIVE_INFINITY, Math.pow(-10.0, 3.093403029238847E15)); 1291561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(Double.POSITIVE_INFINITY, Math.pow(10.0, 3.093403029238847E15)); 1292561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 1293561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1294561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes private double longTodouble(long longvalue) { 1295561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes return Double.longBitsToDouble(longvalue); 1296561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 1297561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1298561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes private long doubleTolong(double doublevalue) { 1299561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes return Double.doubleToLongBits(doublevalue); 1300561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 1301561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1302561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes private double negateDouble(double doublevalue) { 1303561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes return doublevalue * -1.0; 1304561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 1305561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1306561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes /** 1307561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * @tests java.lang.Math#rint(double) 1308561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes */ 1309561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes public void test_rintD() { 1310561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // Test for method double java.lang.Math.rint(double) 1311561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Failed to round properly - up to odd", 1312561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 3.0, Math.rint(2.9), 0D); 1313561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertTrue("Failed to round properly - NaN", Double.isNaN(Math 1314561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .rint(Double.NaN))); 1315561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Failed to round properly down to even", 1316561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 2.0, Math.rint(2.1), 0D); 1317561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertTrue("Failed to round properly " + 2.5 + " to even", Math 1318561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .rint(2.5) == 2.0); 1319561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertTrue("Failed to round properly " + (+0.0d), 1320561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Math.rint(+0.0d) == +0.0d); 1321561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertTrue("Failed to round properly " + (-0.0d), 1322561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Math.rint(-0.0d) == -0.0d); 1323561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 1324561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1325561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes /** 1326561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * @tests java.lang.Math#round(double) 1327561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes */ 1328561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes public void test_roundD() { 1329561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // Test for method long java.lang.Math.round(double) 1330561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Incorrect rounding of a float", -91, Math.round(-90.89d)); 1331561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 1332561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1333561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes /** 1334561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * @tests java.lang.Math#round(float) 1335561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes */ 1336561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes public void test_roundF() { 1337561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // Test for method int java.lang.Math.round(float) 1338561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Incorrect rounding of a float", -91, Math.round(-90.89f)); 1339561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 1340561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1341561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes /** 1342561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * @tests {@link java.lang.Math#scalb(double, int)} 1343561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * @since 1.6 1344561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes */ 1345561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes @SuppressWarnings("boxing") 1346561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes public void test_scalb_DI() { 1347561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // result is normal 1348561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(4.1422946304E7, Math.scalb(1.2345, 25)); 1349561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(3.679096698760986E-8, Math.scalb(1.2345, -25)); 1350561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(1.2345, Math.scalb(1.2345, 0)); 1351561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(7868514.304, Math.scalb(0.2345, 25)); 1352561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1353561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes double normal = Math.scalb(0.2345, -25); 1354561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(6.98864459991455E-9, normal); 1355561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // precision kept 1356561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(0.2345, Math.scalb(normal, 25)); 1357561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1358561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(0.2345, Math.scalb(0.2345, 0)); 1359561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(-4.1422946304E7, Math.scalb(-1.2345, 25)); 1360561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(-6.98864459991455E-9, Math.scalb(-0.2345, -25)); 1361561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(2.0, Math.scalb(Double.MIN_NORMAL / 2, 1024)); 1362561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(64.0, Math.scalb(Double.MIN_VALUE, 1080)); 1363561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(234, Math.getExponent(Math.scalb(1.0, 234))); 1364561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(3.9999999999999996, Math.scalb(Double.MAX_VALUE, 1365561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Double.MIN_EXPONENT)); 1366561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1367561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // result is near infinity 1368561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes double halfMax = Math.scalb(1.0, Double.MAX_EXPONENT); 1369561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(8.98846567431158E307, halfMax); 1370561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(Double.MAX_VALUE, halfMax - Math.ulp(halfMax) + halfMax); 1371561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(Double.POSITIVE_INFINITY, halfMax + halfMax); 1372561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(1.7976931348623155E308, Math.scalb(1.0 - Math.ulp(1.0), 1373561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Double.MAX_EXPONENT + 1)); 1374561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(Double.POSITIVE_INFINITY, Math.scalb(1.0 - Math.ulp(1.0), 1375561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Double.MAX_EXPONENT + 2)); 1376561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1377561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes halfMax = Math.scalb(-1.0, Double.MAX_EXPONENT); 1378561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(-8.98846567431158E307, halfMax); 1379561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(-Double.MAX_VALUE, halfMax + Math.ulp(halfMax) + halfMax); 1380561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(Double.NEGATIVE_INFINITY, halfMax + halfMax); 1381561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1382561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(Double.POSITIVE_INFINITY, Math.scalb(0.345, 1234)); 1383561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(Double.POSITIVE_INFINITY, Math.scalb(44.345E102, 934)); 1384561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(Double.NEGATIVE_INFINITY, Math.scalb(-44.345E102, 934)); 1385561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1386561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(Double.POSITIVE_INFINITY, Math.scalb( 1387561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Double.MIN_NORMAL / 2, 4000)); 1388561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(Double.POSITIVE_INFINITY, Math.scalb(Double.MIN_VALUE, 1389561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 8000)); 1390561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(Double.POSITIVE_INFINITY, Math.scalb(Double.MAX_VALUE, 1)); 1391561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(Double.POSITIVE_INFINITY, Math.scalb( 1392561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Double.POSITIVE_INFINITY, 0)); 1393561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(Double.POSITIVE_INFINITY, Math.scalb( 1394561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Double.POSITIVE_INFINITY, -1)); 1395561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(Double.NEGATIVE_INFINITY, Math.scalb( 1396561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Double.NEGATIVE_INFINITY, -1)); 1397561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(Double.NEGATIVE_INFINITY, Math.scalb( 1398561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Double.NEGATIVE_INFINITY, Double.MIN_EXPONENT)); 1399561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1400561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // result is subnormal/zero 1401561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes long posZeroBits = Double.doubleToLongBits(+0.0); 1402561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes long negZeroBits = Double.doubleToLongBits(-0.0); 1403561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(posZeroBits, Double.doubleToLongBits(Math.scalb(+0.0, 1404561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Integer.MAX_VALUE))); 1405561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(posZeroBits, Double.doubleToLongBits(Math 1406561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .scalb(+0.0, -123))); 1407561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(posZeroBits, Double.doubleToLongBits(Math.scalb(+0.0, 0))); 1408561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(negZeroBits, Double 1409561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .doubleToLongBits(Math.scalb(-0.0, 123))); 1410561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(negZeroBits, Double.doubleToLongBits(Math.scalb(-0.0, 1411561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Integer.MIN_VALUE))); 1412561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1413561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(Double.MIN_VALUE, Math.scalb(1.0, -1074)); 1414561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(posZeroBits, Double.doubleToLongBits(Math 1415561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .scalb(1.0, -1075))); 1416561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(negZeroBits, Double.doubleToLongBits(Math.scalb(-1.0, 1417561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes -1075))); 1418561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1419561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // precision lost 1420561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(Math.scalb(21.405, -1078), Math.scalb(21.405, -1079)); 1421561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(Double.MIN_VALUE, Math.scalb(21.405, -1079)); 1422561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(-Double.MIN_VALUE, Math.scalb(-21.405, -1079)); 1423561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(posZeroBits, Double.doubleToLongBits(Math.scalb(21.405, 1424561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes -1080))); 1425561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(negZeroBits, Double.doubleToLongBits(Math.scalb(-21.405, 1426561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes -1080))); 1427561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(posZeroBits, Double.doubleToLongBits(Math.scalb( 1428561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Double.MIN_VALUE, -1))); 1429561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(negZeroBits, Double.doubleToLongBits(Math.scalb( 1430561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes -Double.MIN_VALUE, -1))); 1431561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(Double.MIN_VALUE, Math.scalb(Double.MIN_NORMAL, -52)); 1432561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(posZeroBits, Double.doubleToLongBits(Math.scalb( 1433561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Double.MIN_NORMAL, -53))); 1434561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(negZeroBits, Double.doubleToLongBits(Math.scalb( 1435561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes -Double.MIN_NORMAL, -53))); 1436561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(Double.MIN_VALUE, Math.scalb(Double.MAX_VALUE, -2098)); 1437561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(posZeroBits, Double.doubleToLongBits(Math.scalb( 1438561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Double.MAX_VALUE, -2099))); 1439561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(negZeroBits, Double.doubleToLongBits(Math.scalb( 1440561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes -Double.MAX_VALUE, -2099))); 1441561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(Double.MIN_VALUE, Math.scalb(Double.MIN_NORMAL / 3, -51)); 1442561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(posZeroBits, Double.doubleToLongBits(Math.scalb( 1443561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Double.MIN_NORMAL / 3, -52))); 1444561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(negZeroBits, Double.doubleToLongBits(Math.scalb( 1445561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes -Double.MIN_NORMAL / 3, -52))); 1446561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes double subnormal = Math.scalb(Double.MIN_NORMAL / 3, -25); 1447561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(2.2104123E-316, subnormal); 1448561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // precision lost 1449561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertFalse(Double.MIN_NORMAL / 3 == Math.scalb(subnormal, 25)); 1450561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1451561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // NaN 1452561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertTrue(Double.isNaN(Math.scalb(Double.NaN, 1))); 1453561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertTrue(Double.isNaN(Math.scalb(Double.NaN, 0))); 1454561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertTrue(Double.isNaN(Math.scalb(Double.NaN, -120))); 1455561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1456561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(1283457024, Double.doubleToLongBits(Math.scalb( 1457561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Double.MIN_VALUE * 153, 23))); 1458561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(-9223372035571318784L, Double.doubleToLongBits(Math.scalb( 1459561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes -Double.MIN_VALUE * 153, 23))); 1460561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(36908406321184768L, Double.doubleToLongBits(Math.scalb( 1461561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Double.MIN_VALUE * 153, 52))); 1462561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(-9186463630533591040L, Double.doubleToLongBits(Math.scalb( 1463561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes -Double.MIN_VALUE * 153, 52))); 1464561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1465561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // test for exception 1466561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes try { 1467561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Math.scalb((Double) null, (Integer) null); 1468561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes fail("Should throw NullPointerException"); 1469561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } catch (NullPointerException e) { 1470561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // Expected 1471561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 1472561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes try { 1473561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Math.scalb(1.0, (Integer) null); 1474561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes fail("Should throw NullPointerException"); 1475561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } catch (NullPointerException e) { 1476561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // Expected 1477561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 1478561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes try { 1479561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Math.scalb((Double) null, 1); 1480561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes fail("Should throw NullPointerException"); 1481561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } catch (NullPointerException e) { 1482561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // Expected 1483561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 1484561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1485561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes long b1em1022 = 0x0010000000000000L; // bit representation of 1486561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // Double.MIN_NORMAL 1487561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes long b1em1023 = 0x0008000000000000L; // bit representation of half of 1488561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // Double.MIN_NORMAL 1489561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // assert exact identity 1490561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(b1em1023, Double.doubleToLongBits(Math.scalb(Double 1491561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .longBitsToDouble(b1em1022), -1))); 1492561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 1493561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1494561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes /** 1495561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * @tests {@link java.lang.Math#scalb(float, int)} 1496561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * @since 1.6 1497561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes */ 1498561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes @SuppressWarnings("boxing") 1499561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes public void test_scalb_FI() { 1500561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // result is normal 1501561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(4.1422946304E7f, Math.scalb(1.2345f, 25)); 1502561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(3.679096698760986E-8f, Math.scalb(1.2345f, -25)); 1503561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(1.2345f, Math.scalb(1.2345f, 0)); 1504561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(7868514.304f, Math.scalb(0.2345f, 25)); 1505561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1506561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes float normal = Math.scalb(0.2345f, -25); 1507561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(6.98864459991455E-9f, normal); 1508561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // precision kept 1509561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(0.2345f, Math.scalb(normal, 25)); 1510561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1511561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(0.2345f, Math.scalb(0.2345f, 0)); 1512561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(-4.1422946304E7f, Math.scalb(-1.2345f, 25)); 1513561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(-6.98864459991455E-9f, Math.scalb(-0.2345f, -25)); 1514561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(2.0f, Math.scalb(Float.MIN_NORMAL / 2, 128)); 1515561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(64.0f, Math.scalb(Float.MIN_VALUE, 155)); 1516561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(34, Math.getExponent(Math.scalb(1.0f, 34))); 1517561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(3.9999998f, Math 1518561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .scalb(Float.MAX_VALUE, Float.MIN_EXPONENT)); 1519561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1520561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // result is near infinity 1521561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes float halfMax = Math.scalb(1.0f, Float.MAX_EXPONENT); 1522561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(1.7014118E38f, halfMax); 1523561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(Float.MAX_VALUE, halfMax - Math.ulp(halfMax) + halfMax); 1524561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(Float.POSITIVE_INFINITY, halfMax + halfMax); 1525561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(3.4028233E38f, Math.scalb(1.0f - Math.ulp(1.0f), 1526561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Float.MAX_EXPONENT + 1)); 1527561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(Float.POSITIVE_INFINITY, Math.scalb(1.0f - Math.ulp(1.0f), 1528561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Float.MAX_EXPONENT + 2)); 1529561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1530561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes halfMax = Math.scalb(-1.0f, Float.MAX_EXPONENT); 1531561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(-1.7014118E38f, halfMax); 1532561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(-Float.MAX_VALUE, halfMax + Math.ulp(halfMax) + halfMax); 1533561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(Float.NEGATIVE_INFINITY, halfMax + halfMax); 1534561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1535561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(Float.POSITIVE_INFINITY, Math.scalb(0.345f, 1234)); 1536561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(Float.POSITIVE_INFINITY, Math.scalb(44.345E10f, 934)); 1537561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(Float.NEGATIVE_INFINITY, Math.scalb(-44.345E10f, 934)); 1538561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1539561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(Float.POSITIVE_INFINITY, Math.scalb(Float.MIN_NORMAL / 2, 1540561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 400)); 1541561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(Float.POSITIVE_INFINITY, Math.scalb(Float.MIN_VALUE, 800)); 1542561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(Float.POSITIVE_INFINITY, Math.scalb(Float.MAX_VALUE, 1)); 1543561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(Float.POSITIVE_INFINITY, Math.scalb( 1544561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Float.POSITIVE_INFINITY, 0)); 1545561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(Float.POSITIVE_INFINITY, Math.scalb( 1546561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Float.POSITIVE_INFINITY, -1)); 1547561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(Float.NEGATIVE_INFINITY, Math.scalb( 1548561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Float.NEGATIVE_INFINITY, -1)); 1549561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(Float.NEGATIVE_INFINITY, Math.scalb( 1550561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Float.NEGATIVE_INFINITY, Float.MIN_EXPONENT)); 1551561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1552561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // result is subnormal/zero 1553561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes int posZeroBits = Float.floatToIntBits(+0.0f); 1554561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes int negZeroBits = Float.floatToIntBits(-0.0f); 1555561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(posZeroBits, Float.floatToIntBits(Math.scalb(+0.0f, 1556561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Integer.MAX_VALUE))); 1557561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(posZeroBits, Float.floatToIntBits(Math.scalb(+0.0f, -123))); 1558561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(posZeroBits, Float.floatToIntBits(Math.scalb(+0.0f, 0))); 1559561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(negZeroBits, Float.floatToIntBits(Math.scalb(-0.0f, 123))); 1560561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(negZeroBits, Float.floatToIntBits(Math.scalb(-0.0f, 1561561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Integer.MIN_VALUE))); 1562561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1563561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(Float.MIN_VALUE, Math.scalb(1.0f, -149)); 1564561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(posZeroBits, Float.floatToIntBits(Math.scalb(1.0f, -150))); 1565561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(negZeroBits, Float.floatToIntBits(Math.scalb(-1.0f, -150))); 1566561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1567561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // precision lost 1568561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(Math.scalb(21.405f, -154), Math.scalb(21.405f, -153)); 1569561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(Float.MIN_VALUE, Math.scalb(21.405f, -154)); 1570561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(-Float.MIN_VALUE, Math.scalb(-21.405f, -154)); 1571561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(posZeroBits, Float.floatToIntBits(Math 1572561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .scalb(21.405f, -155))); 1573561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(negZeroBits, Float.floatToIntBits(Math.scalb(-21.405f, 1574561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes -155))); 1575561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(posZeroBits, Float.floatToIntBits(Math.scalb( 1576561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Float.MIN_VALUE, -1))); 1577561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(negZeroBits, Float.floatToIntBits(Math.scalb( 1578561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes -Float.MIN_VALUE, -1))); 1579561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(Float.MIN_VALUE, Math.scalb(Float.MIN_NORMAL, -23)); 1580561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(posZeroBits, Float.floatToIntBits(Math.scalb( 1581561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Float.MIN_NORMAL, -24))); 1582561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(negZeroBits, Float.floatToIntBits(Math.scalb( 1583561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes -Float.MIN_NORMAL, -24))); 1584561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(Float.MIN_VALUE, Math.scalb(Float.MAX_VALUE, -277)); 1585561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(posZeroBits, Float.floatToIntBits(Math.scalb( 1586561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Float.MAX_VALUE, -278))); 1587561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(negZeroBits, Float.floatToIntBits(Math.scalb( 1588561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes -Float.MAX_VALUE, -278))); 1589561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(Float.MIN_VALUE, Math.scalb(Float.MIN_NORMAL / 3, -22)); 1590561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(posZeroBits, Float.floatToIntBits(Math.scalb( 1591561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Float.MIN_NORMAL / 3, -23))); 1592561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(negZeroBits, Float.floatToIntBits(Math.scalb( 1593561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes -Float.MIN_NORMAL / 3, -23))); 1594561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes float subnormal = Math.scalb(Float.MIN_NORMAL / 3, -11); 1595561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(1.913E-42f, subnormal); 1596561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // precision lost 1597561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertFalse(Float.MIN_NORMAL / 3 == Math.scalb(subnormal, 11)); 1598561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1599561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(68747264, Float.floatToIntBits(Math.scalb( 1600561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Float.MIN_VALUE * 153, 23))); 1601561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(-2078736384, Float.floatToIntBits(Math.scalb( 1602561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes -Float.MIN_VALUE * 153, 23))); 1603561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1604561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(4896, Float.floatToIntBits(Math.scalb( 1605561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Float.MIN_VALUE * 153, 5))); 1606561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(-2147478752, Float.floatToIntBits(Math.scalb( 1607561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes -Float.MIN_VALUE * 153, 5))); 1608561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1609561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // NaN 1610561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertTrue(Float.isNaN(Math.scalb(Float.NaN, 1))); 1611561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertTrue(Float.isNaN(Math.scalb(Float.NaN, 0))); 1612561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertTrue(Float.isNaN(Math.scalb(Float.NaN, -120))); 1613561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1614561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // test for exception 1615561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes try { 1616561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Math.scalb((Float) null, (Integer) null); 1617561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes fail("Should throw NullPointerException"); 1618561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } catch (NullPointerException e) { 1619561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // Expected 1620561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 1621561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes try { 1622561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Math.scalb(1.0f, (Integer) null); 1623561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes fail("Should throw NullPointerException"); 1624561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } catch (NullPointerException e) { 1625561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // Expected 1626561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 1627561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes try { 1628561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Math.scalb((Float) null, 1); 1629561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes fail("Should throw NullPointerException"); 1630561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } catch (NullPointerException e) { 1631561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // Expected 1632561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 1633561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1634561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes int b1em126 = 0x00800000; // bit representation of Float.MIN_NORMAL 1635561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes int b1em127 = 0x00400000; // bit representation of half 1636561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // Float.MIN_NORMAL 1637561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // assert exact identity 1638561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(b1em127, Float.floatToIntBits(Math.scalb(Float 1639561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .intBitsToFloat(b1em126), -1))); 1640561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 1641561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1642561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes /** 1643561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * @tests java.lang.Math#signum(double) 1644561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes */ 1645561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes public void test_signum_D() { 1646561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertTrue(Double.isNaN(Math.signum(Double.NaN))); 1647561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertTrue(Double.isNaN(Math.signum(Double.NaN))); 1648561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(Double.doubleToLongBits(0.0), Double.doubleToLongBits(Math 1649561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .signum(0.0))); 1650561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(Double.doubleToLongBits(+0.0), Double 1651561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .doubleToLongBits(Math.signum(+0.0))); 1652561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(Double.doubleToLongBits(-0.0), Double 1653561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .doubleToLongBits(Math.signum(-0.0))); 1654561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1655561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(1.0, Math.signum(253681.2187962), 0D); 1656561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(-1.0, Math.signum(-125874693.56), 0D); 1657561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(1.0, Math.signum(1.2587E-308), 0D); 1658561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(-1.0, Math.signum(-1.2587E-308), 0D); 1659561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1660561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(1.0, Math.signum(Double.MAX_VALUE), 0D); 1661561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(1.0, Math.signum(Double.MIN_VALUE), 0D); 1662561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(-1.0, Math.signum(-Double.MAX_VALUE), 0D); 1663561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(-1.0, Math.signum(-Double.MIN_VALUE), 0D); 1664561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(1.0, Math.signum(Double.POSITIVE_INFINITY), 0D); 1665561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(-1.0, Math.signum(Double.NEGATIVE_INFINITY), 0D); 1666561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 1667561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1668561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes /** 1669561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * @tests java.lang.Math#signum(float) 1670561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes */ 1671561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes public void test_signum_F() { 1672561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertTrue(Float.isNaN(Math.signum(Float.NaN))); 1673561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(Float.floatToIntBits(0.0f), Float 1674561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .floatToIntBits(Math.signum(0.0f))); 1675561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(Float.floatToIntBits(+0.0f), Float 1676561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .floatToIntBits(Math.signum(+0.0f))); 1677561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(Float.floatToIntBits(-0.0f), Float 1678561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .floatToIntBits(Math.signum(-0.0f))); 1679561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1680561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(1.0f, Math.signum(253681.2187962f), 0f); 1681561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(-1.0f, Math.signum(-125874693.56f), 0f); 1682561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(1.0f, Math.signum(1.2587E-11f), 0f); 1683561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(-1.0f, Math.signum(-1.2587E-11f), 0f); 1684561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1685561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(1.0f, Math.signum(Float.MAX_VALUE), 0f); 1686561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(1.0f, Math.signum(Float.MIN_VALUE), 0f); 1687561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(-1.0f, Math.signum(-Float.MAX_VALUE), 0f); 1688561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(-1.0f, Math.signum(-Float.MIN_VALUE), 0f); 1689561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(1.0f, Math.signum(Float.POSITIVE_INFINITY), 0f); 1690561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(-1.0f, Math.signum(Float.NEGATIVE_INFINITY), 0f); 1691561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 1692561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1693561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes /** 1694561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * @tests java.lang.Math#sin(double) 1695561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes */ 1696561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes public void test_sinD() { 1697561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // Test for method double java.lang.Math.sin(double) 1698561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Incorrect answer", 0.0, Math.sin(0), 0D); 1699561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Incorrect answer", 0.8414709848078965, Math.sin(1), 0D); 1700561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 1701561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1702561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes /** 1703561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * @tests java.lang.Math#sinh(double) 1704561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes */ 1705561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes public void test_sinh_D() { 1706561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // Test for special situations 1707561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertTrue("Should return NaN", Double.isNaN(Math.sinh(Double.NaN))); 1708561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Should return POSITIVE_INFINITY", 1709561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Double.POSITIVE_INFINITY, Math.sinh(Double.POSITIVE_INFINITY), 0D); 1710561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Should return NEGATIVE_INFINITY", 1711561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Double.NEGATIVE_INFINITY, Math.sinh(Double.NEGATIVE_INFINITY), 0D); 1712561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(Double.doubleToLongBits(0.0), Double.doubleToLongBits(Math 1713561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .sinh(0.0))); 1714561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(Double.doubleToLongBits(+0.0), Double 1715561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .doubleToLongBits(Math.sinh(+0.0))); 1716561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(Double.doubleToLongBits(-0.0), Double 1717561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .doubleToLongBits(Math.sinh(-0.0))); 1718561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1719561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Should return POSITIVE_INFINITY", 1720561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Double.POSITIVE_INFINITY, Math.sinh(1234.56), 0D); 1721561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Should return NEGATIVE_INFINITY", 1722561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Double.NEGATIVE_INFINITY, Math.sinh(-1234.56), 0D); 1723561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Should return 1.0000000000001666E-6", 1724561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1.0000000000001666E-6, Math.sinh(0.000001), 0D); 1725561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Should return -1.0000000000001666E-6", 1726561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes -1.0000000000001666E-6, Math.sinh(-0.000001), 0D); 1727561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Should return 5.115386441963859", 5.115386441963859, Math 1728561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .sinh(2.33482), 0D); 1729561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Should return POSITIVE_INFINITY", 1730561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Double.POSITIVE_INFINITY, Math.sinh(Double.MAX_VALUE), 0D); 1731561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Should return 4.9E-324", 4.9E-324, Math 1732561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .sinh(Double.MIN_VALUE), 0D); 1733561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 1734561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1735561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes /** 1736561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * @tests java.lang.Math#sqrt(double) 1737561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes */ 1738561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes public void test_sqrtD() { 1739561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // Test for method double java.lang.Math.sqrt(double) 1740561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Incorrect root returned2", 7, Math.sqrt(49), 0); 1741561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 1742561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1743561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes /** 1744561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * @tests java.lang.Math#tan(double) 1745561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes */ 1746561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes public void test_tanD() { 1747561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // Test for method double java.lang.Math.tan(double) 1748561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Incorrect answer", 0.0, Math.tan(0), 0D); 1749561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Incorrect answer", 1.5574077246549023, Math.tan(1), 0D); 1750561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1751561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 1752561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1753561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes /** 1754561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * @tests java.lang.Math#tanh(double) 1755561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes */ 1756561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes public void test_tanh_D() { 1757561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // Test for special situations 1758561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertTrue("Should return NaN", Double.isNaN(Math.tanh(Double.NaN))); 1759561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Should return +1.0", +1.0, Math 1760561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .tanh(Double.POSITIVE_INFINITY), 0D); 1761561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Should return -1.0", -1.0, Math 1762561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .tanh(Double.NEGATIVE_INFINITY), 0D); 1763561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(Double.doubleToLongBits(0.0), Double.doubleToLongBits(Math 1764561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .tanh(0.0))); 1765561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(Double.doubleToLongBits(+0.0), Double 1766561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .doubleToLongBits(Math.tanh(+0.0))); 1767561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(Double.doubleToLongBits(-0.0), Double 1768561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .doubleToLongBits(Math.tanh(-0.0))); 1769561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1770561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Should return 1.0", 1.0, Math.tanh(1234.56), 0D); 1771561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Should return -1.0", -1.0, Math.tanh(-1234.56), 0D); 1772561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Should return 9.999999999996666E-7", 1773561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 9.999999999996666E-7, Math.tanh(0.000001), 0D); 1774561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Should return 0.981422884124941", 0.981422884124941, Math 1775561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .tanh(2.33482), 0D); 1776561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Should return 1.0", 1.0, Math.tanh(Double.MAX_VALUE), 0D); 1777561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Should return 4.9E-324", 4.9E-324, Math 1778561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .tanh(Double.MIN_VALUE), 0D); 1779561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 1780561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1781561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes /** 1782561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * @tests java.lang.Math#random() 1783561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes */ 1784561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes public void test_random() { 1785561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // There isn't a place for these tests so just stick them here 1786561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Wrong value E", 1787561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 4613303445314885481L, Double.doubleToLongBits(Math.E)); 1788561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Wrong value PI", 1789561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 4614256656552045848L, Double.doubleToLongBits(Math.PI)); 1790561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1791561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes for (int i = 500; i >= 0; i--) { 1792561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes double d = Math.random(); 1793561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertTrue("Generated number is out of range: " + d, d >= 0.0 1794561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes && d < 1.0); 1795561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 1796561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 1797561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1798561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes /** 1799561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * @tests java.lang.Math#toRadians(double) 1800561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes */ 1801561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes public void test_toRadiansD() { 1802561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes for (double d = 500; d >= 0; d -= 1.0) { 1803561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes double converted = Math.toDegrees(Math.toRadians(d)); 1804561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertTrue("Converted number not equal to original. d = " + d, 1805561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes converted >= d * 0.99999999 && converted <= d * 1.00000001); 1806561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 1807561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 1808561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1809561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes /** 1810561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * @tests java.lang.Math#toDegrees(double) 1811561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes */ 1812561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes public void test_toDegreesD() { 1813561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes for (double d = 500; d >= 0; d -= 1.0) { 1814561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes double converted = Math.toRadians(Math.toDegrees(d)); 1815561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertTrue("Converted number not equal to original. d = " + d, 1816561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes converted >= d * 0.99999999 && converted <= d * 1.00000001); 1817561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 1818561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 1819561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1820561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes /** 1821561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * @tests java.lang.Math#ulp(double) 1822561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes */ 1823561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes @SuppressWarnings("boxing") 1824561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes public void test_ulp_D() { 1825561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // Test for special cases 1826561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertTrue("Should return NaN", Double.isNaN(Math.ulp(Double.NaN))); 1827561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Returned incorrect value", Double.POSITIVE_INFINITY, Math 1828561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .ulp(Double.POSITIVE_INFINITY), 0D); 1829561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Returned incorrect value", Double.POSITIVE_INFINITY, Math 1830561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .ulp(Double.NEGATIVE_INFINITY), 0D); 1831561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Returned incorrect value", Double.MIN_VALUE, Math 1832561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .ulp(0.0), 0D); 1833561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Returned incorrect value", Double.MIN_VALUE, Math 1834561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .ulp(+0.0), 0D); 1835561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Returned incorrect value", Double.MIN_VALUE, Math 1836561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .ulp(-0.0), 0D); 1837561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Returned incorrect value", Math.pow(2, 971), Math 1838561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .ulp(Double.MAX_VALUE), 0D); 1839561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Returned incorrect value", Math.pow(2, 971), Math 1840561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .ulp(-Double.MAX_VALUE), 0D); 1841561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1842561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Returned incorrect value", Double.MIN_VALUE, Math 1843561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .ulp(Double.MIN_VALUE), 0D); 1844561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Returned incorrect value", Double.MIN_VALUE, Math 1845561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .ulp(-Double.MIN_VALUE), 0D); 1846561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1847561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Returned incorrect value", 2.220446049250313E-16, Math 1848561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .ulp(1.0), 0D); 1849561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Returned incorrect value", 2.220446049250313E-16, Math 1850561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .ulp(-1.0), 0D); 1851561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Returned incorrect value", 2.2737367544323206E-13, Math 1852561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .ulp(1153.0), 0D); 1853561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 1854561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1855561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes /** 1856561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * @tests java.lang.Math#ulp(float) 1857561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes */ 1858561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes @SuppressWarnings("boxing") 1859561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes public void test_ulp_f() { 1860561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // Test for special cases 1861561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertTrue("Should return NaN", Float.isNaN(Math.ulp(Float.NaN))); 1862561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Returned incorrect value", Float.POSITIVE_INFINITY, Math 1863561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .ulp(Float.POSITIVE_INFINITY), 0f); 1864561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Returned incorrect value", Float.POSITIVE_INFINITY, Math 1865561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .ulp(Float.NEGATIVE_INFINITY), 0f); 1866561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Returned incorrect value", Float.MIN_VALUE, Math 1867561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .ulp(0.0f), 0f); 1868561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Returned incorrect value", Float.MIN_VALUE, Math 1869561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .ulp(+0.0f), 0f); 1870561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Returned incorrect value", Float.MIN_VALUE, Math 1871561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .ulp(-0.0f), 0f); 1872561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Returned incorrect value", 2.028241E31f, Math 1873561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .ulp(Float.MAX_VALUE), 0f); 1874561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Returned incorrect value", 2.028241E31f, Math 1875561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .ulp(-Float.MAX_VALUE), 0f); 1876561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1877561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Returned incorrect value", 1.4E-45f, Math 1878561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .ulp(Float.MIN_VALUE), 0f); 1879561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Returned incorrect value", 1.4E-45f, Math 1880561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .ulp(-Float.MIN_VALUE), 0f); 1881561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1882561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Returned incorrect value", 1.1920929E-7f, Math.ulp(1.0f), 1883561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 0f); 1884561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Returned incorrect value", 1.1920929E-7f, 1885561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Math.ulp(-1.0f), 0f); 1886561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Returned incorrect value", 1.2207031E-4f, Math 1887561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .ulp(1153.0f), 0f); 1888561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals("Returned incorrect value", 5.6E-45f, Math 1889561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .ulp(9.403954E-38f), 0f); 1890561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 1891561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1892561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes /** 1893561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * @tests {@link java.lang.Math#shiftIntBits(int, int)} 1894561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * 1895561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * @since 1.6 1896561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes */ 1897561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes public void test_shiftIntBits_II() { 1898561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes class Tuple { 1899561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes public int result; 1900561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1901561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes public int value; 1902561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1903561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes public int factor; 1904561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1905561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes public Tuple(int result, int value, int factor) { 1906561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes this.result = result; 1907561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes this.value = value; 1908561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes this.factor = factor; 1909561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 1910561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 1911561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes final Tuple[] TUPLES = new Tuple[] { 1912561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // sub-normal to sub-normal 1913561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes new Tuple(0x00000000, 0x00000001, -1), 1914561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // round to even 1915561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes new Tuple(0x00000002, 0x00000003, -1), 1916561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // round to even 1917561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes new Tuple(0x00000001, 0x00000005, -3), 1918561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // round to infinity 1919561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes new Tuple(0x00000002, 0x0000000d, -3), 1920561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // round to infinity 1921561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1922561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // normal to sub-normal 1923561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes new Tuple(0x00000002, 0x01a00000, -24), 1924561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // round to even 1925561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes new Tuple(0x00000004, 0x01e00000, -24), 1926561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // round to even 1927561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes new Tuple(0x00000003, 0x01c80000, -24), 1928561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // round to infinity 1929561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes new Tuple(0x00000004, 0x01e80000, -24), 1930561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // round to infinity 1931561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes }; 1932561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes for (int i = 0; i < TUPLES.length; ++i) { 1933561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Tuple tuple = TUPLES[i]; 1934561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(tuple.result, Float.floatToIntBits(Math.scalb(Float 1935561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .intBitsToFloat(tuple.value), tuple.factor))); 1936561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(tuple.result, Float.floatToIntBits(-Math.scalb(-Float 1937561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes .intBitsToFloat(tuple.value), tuple.factor))); 1938561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 1939561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 1940561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1941561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes /** 1942561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * @tests {@link java.lang.Math#shiftLongBits(long, long)} 1943561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * 1944561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * Round result to nearest value on precision lost. 1945561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * 1946561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes * @since 1.6 1947561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes */ 1948561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes public void test_shiftLongBits_LL() { 1949561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes class Tuple { 1950561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes public long result; 1951561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1952561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes public long value; 1953561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1954561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes public int factor; 1955561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1956561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes public Tuple(long result, long value, int factor) { 1957561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes this.result = result; 1958561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes this.value = value; 1959561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes this.factor = factor; 1960561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 1961561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 1962561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes final Tuple[] TUPLES = new Tuple[] { 1963561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // sub-normal to sub-normal 1964561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes new Tuple(0x00000000L, 0x00000001L, -1), 1965561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes //round to even 1966561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes new Tuple(0x00000002L, 0x00000003L, -1), 1967561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes //round to even 1968561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes new Tuple(0x00000001L, 0x00000005L, -3), 1969561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes //round to infinity 1970561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes new Tuple(0x00000002L, 0x0000000dL, -3), 1971561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes //round to infinity 1972561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes 1973561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes // normal to sub-normal 1974561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes new Tuple(0x0000000000000002L, 0x0034000000000000L, -53), // round to even 1975561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes new Tuple(0x0000000000000004L, 0x003c000000000000L, -53), // round to even 1976561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes new Tuple(0x0000000000000003L, 0x0035000000000000L, -53), // round to infinity 1977561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes new Tuple(0x0000000000000004L, 0x003d000000000000L, -53), // round to infinity 1978561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes }; 1979561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes for (int i = 0; i < TUPLES.length; ++i) { 1980561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Tuple tuple = TUPLES[i]; 1981561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(tuple.result, Double.doubleToLongBits(Math.scalb( 1982561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes Double.longBitsToDouble(tuple.value), tuple.factor))); 1983561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes assertEquals(tuple.result, Double.doubleToLongBits(-Math.scalb( 1984561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes -Double.longBitsToDouble(tuple.value), tuple.factor))); 1985561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 1986561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes } 1987561ee011997c6c2f1befbfaa9d5f0a99771c1d63Elliott Hughes} 1988