1 /*
2 * Copyright (c) 2003, 2012, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 */
23
24 /*
25 * @test
26 * @bug 4851625 4900189 4939441
27 * @summary Tests for {Math, StrictMath}.{sinh, cosh, tanh}
28 * @author Joseph D. Darcy
29 */
30
31 import sun.misc.DoubleConsts;
32
33 public class HyperbolicTests {
34 private HyperbolicTests(){}
35
36 static final double NaNd = Double.NaN;
37
38 /**
39 * Test accuracy of {Math, StrictMath}.sinh. The specified
40 * accuracy is 2.5 ulps.
41 *
42 * The defintion of sinh(x) is
43 *
44 * (e^x - e^(-x))/2
45 *
46 * The series expansion of sinh(x) =
47 *
48 * x + x^3/3! + x^5/5! + x^7/7! +...
49 *
50 * Therefore,
51 *
52 * 1. For large values of x sinh(x) ~= signum(x)*exp(|x|)/2
53 *
54 * 2. For small values of x, sinh(x) ~= x.
55 *
56 * Additionally, sinh is an odd function; sinh(-x) = -sinh(x).
57 *
58 */
59 static int testSinh() {
60 int failures = 0;
61 /*
62 * Array elements below generated using a quad sinh
63 * implementation. Rounded to a double, the quad result
64 * *should* be correctly rounded, unless we are quite unlucky.
65 * Assuming the quad value is a correctly rounded double, the
66 * allowed error is 3.0 ulps instead of 2.5 since the quad
67 * value rounded to double can have its own 1/2 ulp error.
68 */
69 double [][] testCases = {
70 // x sinh(x)
71 {0.0625, 0.06254069805219182172183988501029229},
72 {0.1250, 0.12532577524111545698205754229137154},
73 {0.1875, 0.18860056562029018382047025055167585},
74 {0.2500, 0.25261231680816830791412515054205787},
75 {0.3125, 0.31761115611357728583959867611490292},
76 {0.3750, 0.38385106791361456875429567642050245},
77 {0.4375, 0.45159088610312053032509815226723017},
78 {0.5000, 0.52109530549374736162242562641149155},
79 {0.5625, 0.59263591611468777373870867338492247},
80 {0.6250, 0.66649226445661608227260655608302908},
81 {0.6875, 0.74295294580567543571442036910465007},
82 {0.7500, 0.82231673193582998070366163444691386},
83 {0.8125, 0.90489373856606433650504536421491368},
84 {0.8750, 0.99100663714429475605317427568995231},
85 {0.9375, 1.08099191569306394011007867453992548},
86 {1.0000, 1.17520119364380145688238185059560082},
87 {1.0625, 1.27400259579739321279181130344911907},
88 {1.1250, 1.37778219077984075760379987065228373},
89 {1.1875, 1.48694549961380717221109202361777593},
90 {1.2500, 1.60191908030082563790283030151221415},
91 {1.3125, 1.72315219460596010219069206464391528},
92 {1.3750, 1.85111856355791532419998548438506416},
93 {1.4375, 1.98631821852425112898943304217629457},
94 {1.5000, 2.12927945509481749683438749467763195},
95 {1.5625, 2.28056089740825247058075476705718764},
96 {1.6250, 2.44075368098794353221372986997161132},
97 {1.6875, 2.61048376261693140366028569794027603},
98 {1.7500, 2.79041436627764265509289122308816092},
99 {1.8125, 2.98124857471401377943765253243875520},
100 {1.8750, 3.18373207674259205101326780071803724},
101 {1.9375, 3.39865608104779099764440244167531810},
102 {2.0000, 3.62686040784701876766821398280126192},
103 {2.0625, 3.86923677050642806693938384073620450},
104 {2.1250, 4.12673225993027252260441410537905269},
105 {2.1875, 4.40035304533919660406976249684469164},
106 {2.2500, 4.69116830589833069188357567763552003},
107 {2.3125, 5.00031440855811351554075363240262157},
108 {2.3750, 5.32899934843284576394645856548481489},
109 {2.4375, 5.67850746906785056212578751630266858},
110 {2.5000, 6.05020448103978732145032363835040319},
111 {2.5625, 6.44554279850040875063706020260185553},
112 {2.6250, 6.86606721451642172826145238779845813},
113 {2.6875, 7.31342093738196587585692115636603571},
114 {2.7500, 7.78935201149073201875513401029935330},
115 {2.8125, 8.29572014785741787167717932988491961},
116 {2.8750, 8.83450399097893197351853322827892144},
117 {2.9375, 9.40780885043076394429977972921690859},
118 {3.0000, 10.01787492740990189897459361946582867},
119 {3.0625, 10.66708606836969224165124519209968368},
120 {3.1250, 11.35797907995166028304704128775698426},
121 {3.1875, 12.09325364161259019614431093344260209},
122 {3.2500, 12.87578285468067003959660391705481220},
123 {3.3125, 13.70862446906136798063935858393686525},
124 {3.3750, 14.59503283146163690015482636921657975},
125 {3.4375, 15.53847160182039311025096666980558478},
126 {3.5000, 16.54262728763499762495673152901249743},
127 {3.5625, 17.61142364906941482858466494889121694},
128 {3.6250, 18.74903703113232171399165788088277979},
129 {3.6875, 19.95991268283598684128844120984214675},
130 {3.7500, 21.24878212710338697364101071825171163},
131 {3.8125, 22.62068164929685091969259499078125023},
132 {3.8750, 24.08097197661255803883403419733891573},
133 {3.9375, 25.63535922523855307175060244757748997},
134 {4.0000, 27.28991719712775244890827159079382096},
135 {4.0625, 29.05111111351106713777825462100160185},
136 {4.1250, 30.92582287788986031725487699744107092},
137 {4.1875, 32.92137796722343190618721270937061472},
138 {4.2500, 35.04557405638942942322929652461901154},
139 {4.3125, 37.30671148776788628118833357170042385},
140 {4.3750, 39.71362570500944929025069048612806024},
141 {4.4375, 42.27572177772344954814418332587050658},
142 {4.5000, 45.00301115199178562180965680564371424},
143 {4.5625, 47.90615077031205065685078058248081891},
144 {4.6250, 50.99648471383193131253995134526177467},
145 {4.6875, 54.28608852959281437757368957713936555},
146 {4.7500, 57.78781641599226874961859781628591635},
147 {4.8125, 61.51535145084362283008545918273109379},
148 {4.8750, 65.48325905829987165560146562921543361},
149 {4.9375, 69.70704392356508084094318094283346381},
150 {5.0000, 74.20321057778875897700947199606456364},
151 {5.0625, 78.98932788987998983462810080907521151},
152 {5.1250, 84.08409771724448958901392613147384951},
153 {5.1875, 89.50742798369883598816307922895346849},
154 {5.2500, 95.28051047011540739630959111303975956},
155 {5.3125, 101.42590362176666730633859252034238987},
156 {5.3750, 107.96762069594029162704530843962700133},
157 {5.4375, 114.93122359426386042048760580590182604},
158 {5.5000, 122.34392274639096192409774240457730721},
159 {5.5625, 130.23468343534638291488502321709913206},
160 {5.6250, 138.63433897999898233879574111119546728},
161 {5.6875, 147.57571121692522056519568264304815790},
162 {5.7500, 157.09373875244884423880085377625986165},
163 {5.8125, 167.22561348600435888568183143777868662},
164 {5.8750, 178.01092593829229887752609866133883987},
165 {5.9375, 189.49181995209921964640216682906501778},
166 {6.0000, 201.71315737027922812498206768797872263},
167 {6.0625, 214.72269333437984291483666459592578915},
168 {6.1250, 228.57126288889537420461281285729970085},
169 {6.1875, 243.31297962030799867970551767086092471},
170 {6.2500, 259.00544710710289911522315435345489966},
171 {6.3125, 275.70998400700299790136562219920451185},
172 {6.3750, 293.49186366095654566861661249898332253},
173 {6.4375, 312.42056915013535342987623229485223434},
174 {6.5000, 332.57006480258443156075705566965111346},
175 {6.5625, 354.01908521044116928437570109827956007},
176 {6.6250, 376.85144288706511933454985188849781703},
177 {6.6875, 401.15635576625530823119100750634165252},
178 {6.7500, 427.02879582326538080306830640235938517},
179 {6.8125, 454.56986017986077163530945733572724452},
180 {6.8750, 483.88716614351897894746751705315210621},
181 {6.9375, 515.09527172439720070161654727225752288},
182 {7.0000, 548.31612327324652237375611757601851598},
183 {7.0625, 583.67953198942753384680988096024373270},
184 {7.1250, 621.32368116099280160364794462812762880},
185 {7.1875, 661.39566611888784148449430491465857519},
186 {7.2500, 704.05206901515336623551137120663358760},
187 {7.3125, 749.45957067108712382864538206200700256},
188 {7.3750, 797.79560188617531521347351754559776282},
189 {7.4375, 849.24903675279739482863565789325699416},
190 {7.5000, 904.02093068584652953510919038935849651},
191 {7.5625, 962.32530605113249628368993221570636328},
192 {7.6250, 1024.38998846242707559349318193113614698},
193 {7.6875, 1090.45749701500081956792547346904792325},
194 {7.7500, 1160.78599193425808533255719118417856088},
195 {7.8125, 1235.65028334242796895820912936318532502},
196 {7.8750, 1315.34290508508890654067255740428824014},
197 {7.9375, 1400.17525781352742299995139486063802583},
198 {8.0000, 1490.47882578955018611587663903188144796},
199 {8.0625, 1586.60647216744061169450001100145859236},
200 {8.1250, 1688.93381781440241350635231605477507900},
201 {8.1875, 1797.86070905726094477721128358866360644},
202 {8.2500, 1913.81278009067446281883262689250118009},
203 {8.3125, 2037.24311615199935553277163192983440062},
204 {8.3750, 2168.63402396170125867037749369723761636},
205 {8.4375, 2308.49891634734644432370720900969004306},
206 {8.5000, 2457.38431841538268239359965370719928775},
207 {8.5625, 2615.87200310986940554256648824234335262},
208 {8.6250, 2784.58126450289932429469130598902487336},
209 {8.6875, 2964.17133769964321637973459949999057146},
210 {8.7500, 3155.34397481384944060352507473513108710},
211 {8.8125, 3358.84618707947841898217318996045550438},
212 {8.8750, 3575.47316381333288862617411467285480067},
213 {8.9375, 3806.07137963459383403903729660349293583},
214 {9.0000, 4051.54190208278996051522359589803425598},
215 {9.0625, 4312.84391255878980330955246931164633615},
216 {9.1250, 4590.99845434696991399363282718106006883},
217 {9.1875, 4887.09242236403719571363798584676797558},
218 {9.2500, 5202.28281022453561319352901552085348309},
219 {9.3125, 5537.80123121853803935727335892054791265},
220 {9.3750, 5894.95873086734181634245918412592155656},
221 {9.4375, 6275.15090986233399457103055108344546942},
222 {9.5000, 6679.86337740502119410058225086262108741},
223 {9.5625, 7110.67755625726876329967852256934334025},
224 {9.6250, 7569.27686218510919585241049433331592115},
225 {9.6875, 8057.45328194243077504648484392156371121},
226 {9.7500, 8577.11437549816065709098061006273039092},
227 {9.8125, 9130.29072986829727910801024120918114778},
228 {9.8750, 9719.14389367880274015504995181862860062},
229 {9.9375, 10345.97482346383208590278839409938269134},
230 {10.0000, 11013.23287470339337723652455484636420303},
231 };
232
233 for(int i = 0; i < testCases.length; i++) {
234 double [] testCase = testCases[i];
235 failures += testSinhCaseWithUlpDiff(testCase[0],
236 testCase[1],
237 3.0);
238 }
239
240 double [][] specialTestCases = {
241 {0.0, 0.0},
242 {NaNd, NaNd},
243 {Double.longBitsToDouble(0x7FF0000000000001L), NaNd},
244 {Double.longBitsToDouble(0xFFF0000000000001L), NaNd},
245 {Double.longBitsToDouble(0x7FF8555555555555L), NaNd},
246 {Double.longBitsToDouble(0xFFF8555555555555L), NaNd},
247 {Double.longBitsToDouble(0x7FFFFFFFFFFFFFFFL), NaNd},
248 {Double.longBitsToDouble(0xFFFFFFFFFFFFFFFFL), NaNd},
249 {Double.longBitsToDouble(0x7FFDeadBeef00000L), NaNd},
250 {Double.longBitsToDouble(0xFFFDeadBeef00000L), NaNd},
251 {Double.longBitsToDouble(0x7FFCafeBabe00000L), NaNd},
252 {Double.longBitsToDouble(0xFFFCafeBabe00000L), NaNd},
253 {Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY}
254 };
255
256 for(int i = 0; i < specialTestCases.length; i++) {
257 failures += testSinhCaseWithUlpDiff(specialTestCases[i][0],
258 specialTestCases[i][1],
259 0.0);
260 }
261
262 // For powers of 2 less than 2^(-27), the second and
263 // subsequent terms of the Taylor series expansion will get
264 // rounded away since |n-n^3| > 53, the binary precision of a
265 // double significand.
266
267 for(int i = DoubleConsts.MIN_SUB_EXPONENT; i < -27; i++) {
268 double d = Math.scalb(2.0, i);
269
270 // Result and expected are the same.
271 failures += testSinhCaseWithUlpDiff(d, d, 2.5);
272 }
273
274 // For values of x larger than 22, the e^(-x) term is
275 // insignificant to the floating-point result. Util exp(x)
276 // overflows around 709.8, sinh(x) ~= exp(x)/2; will will test
277 // 10000 values in this range.
278
279 long trans22 = Double.doubleToLongBits(22.0);
280 // (approximately) largest value such that exp shouldn't
281 // overflow
282 long transExpOvfl = Double.doubleToLongBits(Math.nextDown(709.7827128933841));
283
284 for(long i = trans22;
285 i < transExpOvfl;
286 i +=(transExpOvfl-trans22)/10000) {
287
288 double d = Double.longBitsToDouble(i);
289
290 // Allow 3.5 ulps of error to deal with error in exp.
291 failures += testSinhCaseWithUlpDiff(d, StrictMath.exp(d)*0.5, 3.5);
292 }
293
294 // (approximately) largest value such that sinh shouldn't
295 // overflow.
296 long transSinhOvfl = Double.doubleToLongBits(710.4758600739439);
297
298 // Make sure sinh(x) doesn't overflow as soon as exp(x)
299 // overflows.
300
301 /*
302 * For large values of x, sinh(x) ~= 0.5*(e^x). Therefore,
303 *
304 * sinh(x) ~= e^(ln 0.5) * e^x = e^(x + ln 0.5)
305 *
306 * So, we can calculate the approximate expected result as
307 * exp(x + -0.693147186). However, this sum suffers from
308 * roundoff, limiting the accuracy of the approximation. The
309 * accuracy can be improved by recovering the rounded-off
310 * information. Since x is larger than ln(0.5), the trailing
311 * bits of ln(0.5) get rounded away when the two values are
312 * added. However, high-order bits of ln(0.5) that
313 * contribute to the sum can be found:
314 *
315 * offset = log(0.5);
316 * effective_offset = (x + offset) - x; // exact subtraction
317 * rounded_away_offset = offset - effective_offset; // exact subtraction
318 *
319 * Therefore, the product
320 *
321 * exp(x + offset)*exp(rounded_away_offset)
322 *
323 * will be a better approximation to the exact value of
324 *
325 * e^(x + offset)
326 *
327 * than exp(x+offset) alone. (The expected result cannot be
328 * computed as exp(x)*exp(offset) since exp(x) by itself would
329 * overflow to infinity.)
330 */
331 double offset = StrictMath.log(0.5);
332 for(long i = transExpOvfl+1; i < transSinhOvfl;
333 i += (transSinhOvfl-transExpOvfl)/1000 ) {
334 double input = Double.longBitsToDouble(i);
335
336 double expected =
337 StrictMath.exp(input + offset) *
338 StrictMath.exp( offset - ((input + offset) - input) );
339
340 failures += testSinhCaseWithUlpDiff(input, expected, 4.0);
341 }
342
343 // sinh(x) overflows for values greater than 710; in
344 // particular, it overflows for all 2^i, i > 10.
345 for(int i = 10; i <= DoubleConsts.MAX_EXPONENT; i++) {
346 double d = Math.scalb(2.0, i);
347
348 // Result and expected are the same.
349 failures += testSinhCaseWithUlpDiff(d,
350 Double.POSITIVE_INFINITY, 0.0);
351 }
352
353 return failures;
354 }
355
356 public static int testSinhCaseWithTolerance(double input,
357 double expected,
358 double tolerance) {
359 int failures = 0;
360 failures += Tests.testTolerance("Math.sinh(double)",
361 input, Math.sinh(input),
362 expected, tolerance);
363 failures += Tests.testTolerance("Math.sinh(double)",
364 -input, Math.sinh(-input),
365 -expected, tolerance);
366
367 failures += Tests.testTolerance("StrictMath.sinh(double)",
368 input, StrictMath.sinh(input),
369 expected, tolerance);
370 failures += Tests.testTolerance("StrictMath.sinh(double)",
371 -input, StrictMath.sinh(-input),
372 -expected, tolerance);
373 return failures;
374 }
375
376 public static int testSinhCaseWithUlpDiff(double input,
377 double expected,
378 double ulps) {
379 int failures = 0;
380 failures += Tests.testUlpDiff("Math.sinh(double)",
381 input, Math.sinh(input),
382 expected, ulps);
383 failures += Tests.testUlpDiff("Math.sinh(double)",
384 -input, Math.sinh(-input),
385 -expected, ulps);
386
387 failures += Tests.testUlpDiff("StrictMath.sinh(double)",
388 input, StrictMath.sinh(input),
389 expected, ulps);
390 failures += Tests.testUlpDiff("StrictMath.sinh(double)",
391 -input, StrictMath.sinh(-input),
392 -expected, ulps);
393 return failures;
394 }
395
396
397 /**
398 * Test accuracy of {Math, StrictMath}.cosh. The specified
399 * accuracy is 2.5 ulps.
400 *
401 * The defintion of cosh(x) is
402 *
403 * (e^x + e^(-x))/2
404 *
405 * The series expansion of cosh(x) =
406 *
407 * 1 + x^2/2! + x^4/4! + x^6/6! +...
408 *
409 * Therefore,
410 *
411 * 1. For large values of x cosh(x) ~= exp(|x|)/2
412 *
413 * 2. For small values of x, cosh(x) ~= 1.
414 *
415 * Additionally, cosh is an even function; cosh(-x) = cosh(x).
416 *
417 */
418 static int testCosh() {
419 int failures = 0;
420 /*
421 * Array elements below generated using a quad cosh
422 * implementation. Rounded to a double, the quad result
423 * *should* be correctly rounded, unless we are quite unlucky.
424 * Assuming the quad value is a correctly rounded double, the
425 * allowed error is 3.0 ulps instead of 2.5 since the quad
426 * value rounded to double can have its own 1/2 ulp error.
427 */
428 double [][] testCases = {
429 // x cosh(x)
430 {0.0625, 1.001953760865667607841550709632597376},
431 {0.1250, 1.007822677825710859846949685520422223},
432 {0.1875, 1.017629683800690526835115759894757615},
433 {0.2500, 1.031413099879573176159295417520378622},
434 {0.3125, 1.049226785060219076999158096606305793},
435 {0.3750, 1.071140346704586767299498015567016002},
436 {0.4375, 1.097239412531012567673453832328262160},
437 {0.5000, 1.127625965206380785226225161402672030},
438 {0.5625, 1.162418740845610783505338363214045218},
439 {0.6250, 1.201753692975606324229229064105075301},
440 {0.6875, 1.245784523776616395403056980542275175},
441 {0.7500, 1.294683284676844687841708185390181730},
442 {0.8125, 1.348641048647144208352285714214372703},
443 {0.8750, 1.407868656822803158638471458026344506},
444 {0.9375, 1.472597542369862933336886403008640891},
445 {1.0000, 1.543080634815243778477905620757061497},
446 {1.0625, 1.619593348374367728682469968448090763},
447 {1.1250, 1.702434658138190487400868008124755757},
448 {1.1875, 1.791928268324866464246665745956119612},
449 {1.2500, 1.888423877161015738227715728160051696},
450 {1.3125, 1.992298543335143985091891077551921106},
451 {1.3750, 2.103958159362661802010972984204389619},
452 {1.4375, 2.223839037619709260803023946704272699},
453 {1.5000, 2.352409615243247325767667965441644201},
454 {1.5625, 2.490172284559350293104864895029231913},
455 {1.6250, 2.637665356192137582275019088061812951},
456 {1.6875, 2.795465162524235691253423614360562624},
457 {1.7500, 2.964188309728087781773608481754531801},
458 {1.8125, 3.144494087167972176411236052303565201},
459 {1.8750, 3.337087043587520514308832278928116525},
460 {1.9375, 3.542719740149244276729383650503145346},
461 {2.0000, 3.762195691083631459562213477773746099},
462 {2.0625, 3.996372503438463642260225717607554880},
463 {2.1250, 4.246165228196992140600291052990934410},
464 {2.1875, 4.512549935859540340856119781585096760},
465 {2.2500, 4.796567530460195028666793366876218854},
466 {2.3125, 5.099327816921939817643745917141739051},
467 {2.3750, 5.422013837643509250646323138888569746},
468 {2.4375, 5.765886495263270945949271410819116399},
469 {2.5000, 6.132289479663686116619852312817562517},
470 {2.5625, 6.522654518468725462969589397439224177},
471 {2.6250, 6.938506971550673190999796241172117288},
472 {2.6875, 7.381471791406976069645686221095397137},
473 {2.7500, 7.853279872697439591457564035857305647},
474 {2.8125, 8.355774815752725814638234943192709129},
475 {2.8750, 8.890920130482709321824793617157134961},
476 {2.9375, 9.460806908834119747071078865866737196},
477 {3.0000, 10.067661995777765841953936035115890343},
478 {3.0625, 10.713856690753651225304006562698007312},
479 {3.1250, 11.401916013575067700373788969458446177},
480 {3.1875, 12.134528570998387744547733730974713055},
481 {3.2500, 12.914557062512392049483503752322408761},
482 {3.3125, 13.745049466398732213877084541992751273},
483 {3.3750, 14.629250949773302934853381428660210721},
484 {3.4375, 15.570616549147269180921654324879141947},
485 {3.5000, 16.572824671057316125696517821376119469},
486 {3.5625, 17.639791465519127930722105721028711044},
487 {3.6250, 18.775686128468677200079039891415789429},
488 {3.6875, 19.984947192985946987799359614758598457},
489 {3.7500, 21.272299872959396081877161903352144126},
490 {3.8125, 22.642774526961913363958587775566619798},
491 {3.8750, 24.101726314486257781049388094955970560},
492 {3.9375, 25.654856121347151067170940701379544221},
493 {4.0000, 27.308232836016486629201989612067059978},
494 {4.0625, 29.068317063936918520135334110824828950},
495 {4.1250, 30.941986372478026192360480044849306606},
496 {4.1875, 32.936562165180269851350626768308756303},
497 {4.2500, 35.059838290298428678502583470475012235},
498 {4.3125, 37.320111495433027109832850313172338419},
499 {4.3750, 39.726213847251883288518263854094284091},
500 {4.4375, 42.287547242982546165696077854963452084},
501 {4.5000, 45.014120148530027928305799939930642658},
502 {4.5625, 47.916586706774825161786212701923307169},
503 {4.6250, 51.006288368867753140854830589583165950},
504 {4.6875, 54.295298211196782516984520211780624960},
505 {4.7500, 57.796468111195389383795669320243166117},
506 {4.8125, 61.523478966332915041549750463563672435},
507 {4.8750, 65.490894152518731617237739112888213645},
508 {4.9375, 69.714216430810089539924900313140922323},
509 {5.0000, 74.209948524787844444106108044487704798},
510 {5.0625, 78.995657605307475581204965926043112946},
511 {5.1250, 84.090043934600961683400343038519519678},
512 {5.1875, 89.513013937957834087706670952561002466},
513 {5.2500, 95.285757988514588780586084642381131013},
514 {5.3125, 101.430833209098212357990123684449846912},
515 {5.3750, 107.972251614673824873137995865940755392},
516 {5.4375, 114.935573939814969189535554289886848550},
517 {5.5000, 122.348009517829425991091207107262038316},
518 {5.5625, 130.238522601820409078244923165746295574},
519 {5.6250, 138.637945543134998069351279801575968875},
520 {5.6875, 147.579099269447055276899288971207106581},
521 {5.7500, 157.096921533245353905868840194264636395},
522 {5.8125, 167.228603431860671946045256541679445836},
523 {5.8750, 178.013734732486824390148614309727161925},
524 {5.9375, 189.494458570056311567917444025807275896},
525 {6.0000, 201.715636122455894483405112855409538488},
526 {6.0625, 214.725021906554080628430756558271312513},
527 {6.1250, 228.573450380013557089736092321068279231},
528 {6.1875, 243.315034578039208138752165587134488645},
529 {6.2500, 259.007377561239126824465367865430519592},
530 {6.3125, 275.711797500835732516530131577254654076},
531 {6.3750, 293.493567280752348242602902925987643443},
532 {6.4375, 312.422169552825597994104814531010579387},
533 {6.5000, 332.571568241777409133204438572983297292},
534 {6.5625, 354.020497560858198165985214519757890505},
535 {6.6250, 376.852769667496146326030849450983914197},
536 {6.6875, 401.157602161123700280816957271992998156},
537 {6.7500, 427.029966702886171977469256622451185850},
538 {6.8125, 454.570960119471524953536004647195906721},
539 {6.8750, 483.888199441157626584508920036981010995},
540 {6.9375, 515.096242417696720610477570797503766179},
541 {7.0000, 548.317035155212076889964120712102928484},
542 {7.0625, 583.680388623257719787307547662358502345},
543 {7.1250, 621.324485894002926216918634755431456031},
544 {7.1875, 661.396422095589629755266517362992812037},
545 {7.2500, 704.052779189542208784574955807004218856},
546 {7.3125, 749.460237818184878095966335081928645934},
547 {7.3750, 797.796228612873763671070863694973560629},
548 {7.4375, 849.249625508044731271830060572510241864},
549 {7.5000, 904.021483770216677368692292389446994987},
550 {7.5625, 962.325825625814651122171697031114091993},
551 {7.6250, 1024.390476557670599008492465853663578558},
552 {7.6875, 1090.457955538048482588540574008226583335},
553 {7.7500, 1160.786422676798661020094043586456606003},
554 {7.8125, 1235.650687987597295222707689125107720568},
555 {7.8750, 1315.343285214046776004329388551335841550},
556 {7.9375, 1400.175614911635999247504386054087931958},
557 {8.0000, 1490.479161252178088627715460421007179728},
558 {8.0625, 1586.606787305415349050508956232945539108},
559 {8.1250, 1688.934113859132470361718199038326340668},
560 {8.1875, 1797.860987165547537276364148450577336075},
561 {8.2500, 1913.813041349231764486365114317586148767},
562 {8.3125, 2037.243361581700856522236313401822532385},
563 {8.3750, 2168.634254521568851112005905503069409349},
564 {8.4375, 2308.499132938297821208734949028296170563},
565 {8.5000, 2457.384521883751693037774022640629666294},
566 {8.5625, 2615.872194250713123494312356053193077854},
567 {8.6250, 2784.581444063104750127653362960649823247},
568 {8.6875, 2964.171506380845754878370650565756538203},
569 {8.7500, 3155.344133275174556354775488913749659006},
570 {8.8125, 3358.846335940117183452010789979584950102},
571 {8.8750, 3575.473303654961482727206202358956274888},
572 {8.9375, 3806.071511003646460448021740303914939059},
573 {9.0000, 4051.542025492594047194773093534725371440},
574 {9.0625, 4312.844028491571841588188869958240355518},
575 {9.1250, 4590.998563255739769060078863130940205710},
576 {9.1875, 4887.092524674358252509551443117048351290},
577 {9.2500, 5202.282906336187674588222835339193136030},
578 {9.3125, 5537.801321507079474415176386655744387251},
579 {9.3750, 5894.958815685577062811620236195525504885},
580 {9.4375, 6275.150989541692149890530417987358096221},
581 {9.5000, 6679.863452256851081801173722051940058824},
582 {9.5625, 7110.677626574055535297758456126491707647},
583 {9.6250, 7569.276928241617224537226019600213961572},
584 {9.6875, 8057.453343996777301036241026375049070162},
585 {9.7500, 8577.114433792824387959788368429252257664},
586 {9.8125, 9130.290784631065880205118262838330689429},
587 {9.8750, 9719.143945123662919857326995631317996715},
588 {9.9375, 10345.974871791805753327922796701684092861},
589 {10.0000, 11013.232920103323139721376090437880844591},
590 };
591
592 for(int i = 0; i < testCases.length; i++) {
593 double [] testCase = testCases[i];
594 failures += testCoshCaseWithUlpDiff(testCase[0],
595 testCase[1],
596 3.0);
597 }
598
599
600 double [][] specialTestCases = {
601 {0.0, 1.0},
602 {NaNd, NaNd},
603 {Double.longBitsToDouble(0x7FF0000000000001L), NaNd},
604 {Double.longBitsToDouble(0xFFF0000000000001L), NaNd},
605 {Double.longBitsToDouble(0x7FF8555555555555L), NaNd},
606 {Double.longBitsToDouble(0xFFF8555555555555L), NaNd},
607 {Double.longBitsToDouble(0x7FFFFFFFFFFFFFFFL), NaNd},
608 {Double.longBitsToDouble(0xFFFFFFFFFFFFFFFFL), NaNd},
609 {Double.longBitsToDouble(0x7FFDeadBeef00000L), NaNd},
610 {Double.longBitsToDouble(0xFFFDeadBeef00000L), NaNd},
611 {Double.longBitsToDouble(0x7FFCafeBabe00000L), NaNd},
612 {Double.longBitsToDouble(0xFFFCafeBabe00000L), NaNd},
613 {Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY}
614 };
615
616 for(int i = 0; i < specialTestCases.length; i++ ) {
617 failures += testCoshCaseWithUlpDiff(specialTestCases[i][0],
618 specialTestCases[i][1],
619 0.0);
620 }
621
622 // For powers of 2 less than 2^(-27), the second and
623 // subsequent terms of the Taylor series expansion will get
624 // rounded.
625
626 for(int i = DoubleConsts.MIN_SUB_EXPONENT; i < -27; i++) {
627 double d = Math.scalb(2.0, i);
628
629 // Result and expected are the same.
630 failures += testCoshCaseWithUlpDiff(d, 1.0, 2.5);
631 }
632
633 // For values of x larger than 22, the e^(-x) term is
634 // insignificant to the floating-point result. Util exp(x)
635 // overflows around 709.8, cosh(x) ~= exp(x)/2; will will test
636 // 10000 values in this range.
637
638 long trans22 = Double.doubleToLongBits(22.0);
639 // (approximately) largest value such that exp shouldn't
640 // overflow
641 long transExpOvfl = Double.doubleToLongBits(Math.nextDown(709.7827128933841));
642
643 for(long i = trans22;
644 i < transExpOvfl;
645 i +=(transExpOvfl-trans22)/10000) {
646
647 double d = Double.longBitsToDouble(i);
648
649 // Allow 3.5 ulps of error to deal with error in exp.
650 failures += testCoshCaseWithUlpDiff(d, StrictMath.exp(d)*0.5, 3.5);
651 }
652
653 // (approximately) largest value such that cosh shouldn't
654 // overflow.
655 long transCoshOvfl = Double.doubleToLongBits(710.4758600739439);
656
657 // Make sure sinh(x) doesn't overflow as soon as exp(x)
658 // overflows.
659
660 /*
661 * For large values of x, cosh(x) ~= 0.5*(e^x). Therefore,
662 *
663 * cosh(x) ~= e^(ln 0.5) * e^x = e^(x + ln 0.5)
664 *
665 * So, we can calculate the approximate expected result as
666 * exp(x + -0.693147186). However, this sum suffers from
667 * roundoff, limiting the accuracy of the approximation. The
668 * accuracy can be improved by recovering the rounded-off
669 * information. Since x is larger than ln(0.5), the trailing
670 * bits of ln(0.5) get rounded away when the two values are
671 * added. However, high-order bits of ln(0.5) that
672 * contribute to the sum can be found:
673 *
674 * offset = log(0.5);
675 * effective_offset = (x + offset) - x; // exact subtraction
676 * rounded_away_offset = offset - effective_offset; // exact subtraction
677 *
678 * Therefore, the product
679 *
680 * exp(x + offset)*exp(rounded_away_offset)
681 *
682 * will be a better approximation to the exact value of
683 *
684 * e^(x + offset)
685 *
686 * than exp(x+offset) alone. (The expected result cannot be
687 * computed as exp(x)*exp(offset) since exp(x) by itself would
688 * overflow to infinity.)
689 */
690 double offset = StrictMath.log(0.5);
691 for(long i = transExpOvfl+1; i < transCoshOvfl;
692 i += (transCoshOvfl-transExpOvfl)/1000 ) {
693 double input = Double.longBitsToDouble(i);
694
695 double expected =
696 StrictMath.exp(input + offset) *
697 StrictMath.exp( offset - ((input + offset) - input) );
698
699 failures += testCoshCaseWithUlpDiff(input, expected, 4.0);
700 }
701
702 // cosh(x) overflows for values greater than 710; in
703 // particular, it overflows for all 2^i, i > 10.
704 for(int i = 10; i <= DoubleConsts.MAX_EXPONENT; i++) {
705 double d = Math.scalb(2.0, i);
706
707 // Result and expected are the same.
708 failures += testCoshCaseWithUlpDiff(d,
709 Double.POSITIVE_INFINITY, 0.0);
710 }
711 return failures;
712 }
713
714 public static int testCoshCaseWithTolerance(double input,
715 double expected,
716 double tolerance) {
717 int failures = 0;
718 failures += Tests.testTolerance("Math.cosh(double)",
719 input, Math.cosh(input),
720 expected, tolerance);
721 failures += Tests.testTolerance("Math.cosh(double)",
722 -input, Math.cosh(-input),
723 expected, tolerance);
724
725 failures += Tests.testTolerance("StrictMath.cosh(double)",
726 input, StrictMath.cosh(input),
727 expected, tolerance);
728 failures += Tests.testTolerance("StrictMath.cosh(double)",
729 -input, StrictMath.cosh(-input),
730 expected, tolerance);
731 return failures;
732 }
733
734 public static int testCoshCaseWithUlpDiff(double input,
735 double expected,
736 double ulps) {
737 int failures = 0;
738 failures += Tests.testUlpDiff("Math.cosh(double)",
739 input, Math.cosh(input),
740 expected, ulps);
741 failures += Tests.testUlpDiff("Math.cosh(double)",
742 -input, Math.cosh(-input),
743 expected, ulps);
744
745 failures += Tests.testUlpDiff("StrictMath.cosh(double)",
746 input, StrictMath.cosh(input),
747 expected, ulps);
748 failures += Tests.testUlpDiff("StrictMath.cosh(double)",
749 -input, StrictMath.cosh(-input),
750 expected, ulps);
751 return failures;
752 }
753
754
755 /**
756 * Test accuracy of {Math, StrictMath}.tanh. The specified
757 * accuracy is 2.5 ulps.
758 *
759 * The defintion of tanh(x) is
760 *
761 * (e^x - e^(-x))/(e^x + e^(-x))
762 *
763 * The series expansion of tanh(x) =
764 *
765 * x - x^3/3 + 2x^5/15 - 17x^7/315 + ...
766 *
767 * Therefore,
768 *
769 * 1. For large values of x tanh(x) ~= signum(x)
770 *
771 * 2. For small values of x, tanh(x) ~= x.
772 *
773 * Additionally, tanh is an odd function; tanh(-x) = -tanh(x).
774 *
775 */
776 static int testTanh() {
777 int failures = 0;
778 /*
779 * Array elements below generated using a quad sinh
780 * implementation. Rounded to a double, the quad result
781 * *should* be correctly rounded, unless we are quite unlucky.
782 * Assuming the quad value is a correctly rounded double, the
783 * allowed error is 3.0 ulps instead of 2.5 since the quad
784 * value rounded to double can have its own 1/2 ulp error.
785 */
786 double [][] testCases = {
787 // x tanh(x)
788 {0.0625, 0.06241874674751251449014289119421133},
789 {0.1250, 0.12435300177159620805464727580589271},
790 {0.1875, 0.18533319990813951753211997502482787},
791 {0.2500, 0.24491866240370912927780113149101697},
792 {0.3125, 0.30270972933210848724239738970991712},
793 {0.3750, 0.35835739835078594631936023155315807},
794 {0.4375, 0.41157005567402245143207555859415687},
795 {0.5000, 0.46211715726000975850231848364367256},
796 {0.5625, 0.50982997373525658248931213507053130},
797 {0.6250, 0.55459972234938229399903909532308371},
798 {0.6875, 0.59637355547924233984437303950726939},
799 {0.7500, 0.63514895238728731921443435731249638},
800 {0.8125, 0.67096707420687367394810954721913358},
801 {0.8750, 0.70390560393662106058763026963135371},
802 {0.9375, 0.73407151960434149263991588052503660},
803 {1.0000, 0.76159415595576488811945828260479366},
804 {1.0625, 0.78661881210869761781941794647736081},
805 {1.1250, 0.80930107020178101206077047354332696},
806 {1.1875, 0.82980190998595952708572559629034476},
807 {1.2500, 0.84828363995751289761338764670750445},
808 {1.3125, 0.86490661772074179125443141102709751},
809 {1.3750, 0.87982669965198475596055310881018259},
810 {1.4375, 0.89319334040035153149249598745889365},
811 {1.5000, 0.90514825364486643824230369645649557},
812 {1.5625, 0.91582454416876231820084311814416443},
813 {1.6250, 0.92534622531174107960457166792300374},
814 {1.6875, 0.93382804322259173763570528576138652},
815 {1.7500, 0.94137553849728736226942088377163687},
816 {1.8125, 0.94808528560440629971240651310180052},
817 {1.8750, 0.95404526017994877009219222661968285},
818 {1.9375, 0.95933529331468249183399461756952555},
819 {2.0000, 0.96402758007581688394641372410092317},
820 {2.0625, 0.96818721657637057702714316097855370},
821 {2.1250, 0.97187274591350905151254495374870401},
822 {2.1875, 0.97513669829362836159665586901156483},
823 {2.2500, 0.97802611473881363992272924300618321},
824 {2.3125, 0.98058304703705186541999427134482061},
825 {2.3750, 0.98284502917257603002353801620158861},
826 {2.4375, 0.98484551746427837912703608465407824},
827 {2.5000, 0.98661429815143028888127603923734964},
828 {2.5625, 0.98817786228751240824802592958012269},
829 {2.6250, 0.98955974861288320579361709496051109},
830 {2.6875, 0.99078085564125158320311117560719312},
831 {2.7500, 0.99185972456820774534967078914285035},
832 {2.8125, 0.99281279483715982021711715899682324},
833 {2.8750, 0.99365463431502962099607366282699651},
834 {2.9375, 0.99439814606575805343721743822723671},
835 {3.0000, 0.99505475368673045133188018525548849},
836 {3.0625, 0.99563456710930963835715538507891736},
837 {3.1250, 0.99614653067334504917102591131792951},
838 {3.1875, 0.99659855517712942451966113109487039},
839 {3.2500, 0.99699763548652601693227592643957226},
840 {3.3125, 0.99734995516557367804571991063376923},
841 {3.3750, 0.99766097946988897037219469409451602},
842 {3.4375, 0.99793553792649036103161966894686844},
843 {3.5000, 0.99817789761119870928427335245061171},
844 {3.5625, 0.99839182812874152902001617480606320},
845 {3.6250, 0.99858065920179882368897879066418294},
846 {3.6875, 0.99874733168378115962760304582965538},
847 {3.7500, 0.99889444272615280096784208280487888},
848 {3.8125, 0.99902428575443546808677966295308778},
849 {3.8750, 0.99913888583735077016137617231569011},
850 {3.9375, 0.99924003097049627100651907919688313},
851 {4.0000, 0.99932929973906704379224334434172499},
852 {4.0625, 0.99940808577297384603818654530731215},
853 {4.1250, 0.99947761936180856115470576756499454},
854 {4.1875, 0.99953898655601372055527046497863955},
855 {4.2500, 0.99959314604388958696521068958989891},
856 {4.3125, 0.99964094406130644525586201091350343},
857 {4.3750, 0.99968312756179494813069349082306235},
858 {4.4375, 0.99972035584870534179601447812936151},
859 {4.5000, 0.99975321084802753654050617379050162},
860 {4.5625, 0.99978220617994689112771768489030236},
861 {4.6250, 0.99980779516900105210240981251048167},
862 {4.6875, 0.99983037791655283849546303868853396},
863 {4.7500, 0.99985030754497877753787358852000255},
864 {4.8125, 0.99986789571029070417475400133989992},
865 {4.8750, 0.99988341746867772271011794614780441},
866 {4.9375, 0.99989711557251558205051185882773206},
867 {5.0000, 0.99990920426259513121099044753447306},
868 {5.0625, 0.99991987261554158551063867262784721},
869 {5.1250, 0.99992928749851651137225712249720606},
870 {5.1875, 0.99993759617721206697530526661105307},
871 {5.2500, 0.99994492861777083305830639416802036},
872 {5.3125, 0.99995139951851344080105352145538345},
873 {5.3750, 0.99995711010315817210152906092289064},
874 {5.4375, 0.99996214970350792531554669737676253},
875 {5.5000, 0.99996659715630380963848952941756868},
876 {5.5625, 0.99997052203605101013786592945475432},
877 {5.6250, 0.99997398574306704793434088941484766},
878 {5.6875, 0.99997704246374583929961850444364696},
879 {5.7500, 0.99997974001803825215761760428815437},
880 {5.8125, 0.99998212060739040166557477723121777},
881 {5.8750, 0.99998422147482750993344503195672517},
882 {5.9375, 0.99998607548749972326220227464612338},
883 {6.0000, 0.99998771165079557056434885235523206},
884 {6.0625, 0.99998915556205996764518917496149338},
885 {6.1250, 0.99999042981101021976277974520745310},
886 {6.1875, 0.99999155433311068015449574811497719},
887 {6.2500, 0.99999254672143162687722782398104276},
888 {6.3125, 0.99999342250186907900400800240980139},
889 {6.3750, 0.99999419537602957780612639767025158},
890 {6.4375, 0.99999487743557848265406225515388994},
891 {6.5000, 0.99999547935140419285107893831698753},
892 {6.5625, 0.99999601054055694588617385671796346},
893 {6.6250, 0.99999647931357331502887600387959900},
894 {6.6875, 0.99999689300449080997594368612277442},
895 {6.7500, 0.99999725808558628431084200832778748},
896 {6.8125, 0.99999758026863294516387464046135924},
897 {6.8750, 0.99999786459425991170635407313276785},
898 {6.9375, 0.99999811551081218572759991597586905},
899 {7.0000, 0.99999833694394467173571641595066708},
900 {7.0625, 0.99999853235803894918375164252059190},
901 {7.1250, 0.99999870481040359014665019356422927},
902 {7.1875, 0.99999885699910593255108365463415411},
903 {7.2500, 0.99999899130518359709674536482047025},
904 {7.3125, 0.99999910982989611769943303422227663},
905 {7.3750, 0.99999921442759946591163427422888252},
906 {7.4375, 0.99999930673475777603853435094943258},
907 {7.5000, 0.99999938819554614875054970643513124},
908 {7.5625, 0.99999946008444508183970109263856958},
909 {7.6250, 0.99999952352618001331402589096040117},
910 {7.6875, 0.99999957951331792817413683491979752},
911 {7.7500, 0.99999962892179632633374697389145081},
912 {7.8125, 0.99999967252462750190604116210421169},
913 {7.8750, 0.99999971100399253750324718031574484},
914 {7.9375, 0.99999974496191422474977283863588658},
915 {8.0000, 0.99999977492967588981001883295636840},
916 {8.0625, 0.99999980137613348259726597081723424},
917 {8.1250, 0.99999982471505097353529823063673263},
918 {8.1875, 0.99999984531157382142423402736529911},
919 {8.2500, 0.99999986348794179107425910499030547},
920 {8.3125, 0.99999987952853049895833839645847571},
921 {8.3750, 0.99999989368430056302584289932834041},
922 {8.4375, 0.99999990617672396471542088609051728},
923 {8.5000, 0.99999991720124905211338798152800748},
924 {8.5625, 0.99999992693035839516545287745322387},
925 {8.6250, 0.99999993551626733394129009365703767},
926 {8.6875, 0.99999994309330543951799157347876934},
927 {8.7500, 0.99999994978001814614368429416607424},
928 {8.8125, 0.99999995568102143535399207289008504},
929 {8.8750, 0.99999996088863858914831986187674522},
930 {8.9375, 0.99999996548434461974481685677429908},
931 {9.0000, 0.99999996954004097447930211118358244},
932 {9.0625, 0.99999997311918045901919121395899372},
933 {9.1250, 0.99999997627775997868467948564005257},
934 {9.1875, 0.99999997906519662964368381583648379},
935 {9.2500, 0.99999998152510084671976114264303159},
936 {9.3125, 0.99999998369595870397054673668361266},
937 {9.3750, 0.99999998561173404286033236040150950},
938 {9.4375, 0.99999998730239984852716512979473289},
939 {9.5000, 0.99999998879440718770812040917618843},
940 {9.5625, 0.99999999011109904501789298212541698},
941 {9.6250, 0.99999999127307553219220251303121960},
942 {9.6875, 0.99999999229851618412119275358396363},
943 {9.7500, 0.99999999320346438410630581726217930},
944 {9.8125, 0.99999999400207836827291739324060736},
945 {9.8750, 0.99999999470685273619047001387577653},
946 {9.9375, 0.99999999532881393331131526966058758},
947 {10.0000, 0.99999999587769276361959283713827574},
948 };
949
950 for(int i = 0; i < testCases.length; i++) {
951 double [] testCase = testCases[i];
952 failures += testTanhCaseWithUlpDiff(testCase[0],
953 testCase[1],
954 3.0);
955 }
956
957
958 double [][] specialTestCases = {
959 {0.0, 0.0},
960 {NaNd, NaNd},
961 {Double.longBitsToDouble(0x7FF0000000000001L), NaNd},
962 {Double.longBitsToDouble(0xFFF0000000000001L), NaNd},
963 {Double.longBitsToDouble(0x7FF8555555555555L), NaNd},
964 {Double.longBitsToDouble(0xFFF8555555555555L), NaNd},
965 {Double.longBitsToDouble(0x7FFFFFFFFFFFFFFFL), NaNd},
966 {Double.longBitsToDouble(0xFFFFFFFFFFFFFFFFL), NaNd},
967 {Double.longBitsToDouble(0x7FFDeadBeef00000L), NaNd},
968 {Double.longBitsToDouble(0xFFFDeadBeef00000L), NaNd},
969 {Double.longBitsToDouble(0x7FFCafeBabe00000L), NaNd},
970 {Double.longBitsToDouble(0xFFFCafeBabe00000L), NaNd},
971 {Double.POSITIVE_INFINITY, 1.0}
972 };
973
974 for(int i = 0; i < specialTestCases.length; i++) {
975 failures += testTanhCaseWithUlpDiff(specialTestCases[i][0],
976 specialTestCases[i][1],
977 0.0);
978 }
979
980 // For powers of 2 less than 2^(-27), the second and
981 // subsequent terms of the Taylor series expansion will get
982 // rounded away since |n-n^3| > 53, the binary precision of a
983 // double significand.
984
985 for(int i = DoubleConsts.MIN_SUB_EXPONENT; i < -27; i++) {
986 double d = Math.scalb(2.0, i);
987
988 // Result and expected are the same.
989 failures += testTanhCaseWithUlpDiff(d, d, 2.5);
990 }
991
992 // For values of x larger than 22, tanh(x) is 1.0 in double
993 // floating-point arithmetic.
994
995 for(int i = 22; i < 32; i++) {
996 failures += testTanhCaseWithUlpDiff(i, 1.0, 2.5);
997 }
998
999 for(int i = 5; i <= DoubleConsts.MAX_EXPONENT; i++) {
1000 double d = Math.scalb(2.0, i);
1001
1002 failures += testTanhCaseWithUlpDiff(d, 1.0, 2.5);
1003 }
1004
1005 return failures;
1006 }
1007
1008 public static int testTanhCaseWithTolerance(double input,
1009 double expected,
1010 double tolerance) {
1011 int failures = 0;
1012 failures += Tests.testTolerance("Math.tanh(double",
1013 input, Math.tanh(input),
1014 expected, tolerance);
1015 failures += Tests.testTolerance("Math.tanh(double",
1016 -input, Math.tanh(-input),
1017 -expected, tolerance);
1018
1019 failures += Tests.testTolerance("StrictMath.tanh(double",
1020 input, StrictMath.tanh(input),
1021 expected, tolerance);
1022 failures += Tests.testTolerance("StrictMath.tanh(double",
1023 -input, StrictMath.tanh(-input),
1024 -expected, tolerance);
1025 return failures;
1026 }
1027
1028 public static int testTanhCaseWithUlpDiff(double input,
1029 double expected,
1030 double ulps) {
1031 int failures = 0;
1032
1033 failures += Tests.testUlpDiffWithAbsBound("Math.tanh(double)",
1034 input, Math.tanh(input),
1035 expected, ulps, 1.0);
1036 failures += Tests.testUlpDiffWithAbsBound("Math.tanh(double)",
1037 -input, Math.tanh(-input),
1038 -expected, ulps, 1.0);
1039
1040 failures += Tests.testUlpDiffWithAbsBound("StrictMath.tanh(double)",
1041 input, StrictMath.tanh(input),
1042 expected, ulps, 1.0);
1043 failures += Tests.testUlpDiffWithAbsBound("StrictMath.tanh(double)",
1044 -input, StrictMath.tanh(-input),
1045 -expected, ulps, 1.0);
1046 return failures;
1047 }
1048
1049
1050 public static void main(String argv[]) {
1051 int failures = 0;
1052
1053 failures += testSinh();
1054 failures += testCosh();
1055 failures += testTanh();
1056
1057 if (failures > 0) {
1058 System.err.println("Testing the hyperbolic functions incurred "
1059 + failures + " failures.");
1060 throw new RuntimeException();
1061 }
1062 }
1063
1064 }