1 #Region "Microsoft.VisualBasic::c3596bb305a11d1630b4a5182304e5eb, Microsoft.VisualBasic.Core\Language\Language\Java\JavaMath.vb"
2
3     ' Author:
4     
5     '       asuka (amethyst.asuka@gcmodeller.org)
6     '       xie (genetics@smrucc.org)
7     '       xieguigang (xie.guigang@live.com)
8     
9     ' Copyright (c) 2018 GPL3 Licensed
10     
11     
12     ' GNU GENERAL PUBLIC LICENSE (GPL3)
13     
14     
15     ' This program is free software: you can redistribute it and/or modify
16     ' it under the terms of the GNU General Public License as published by
17     ' the Free Software Foundation, either version 3 of the License, or
18     ' (at your option) any later version.
19     
20     ' This program is distributed in the hope that it will be useful,
21     ' but WITHOUT ANY WARRANTY; without even the implied warranty of
22     ' MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
23     ' GNU General Public License for more details.
24     
25     ' You should have received a copy of the GNU General Public License
26     ' along with this program. If not, see <http://www.gnu.org/licenses/>.
27
28
29
30     ' /********************************************************************************/
31
32     ' Summaries:
33
34     '     Module JavaMath
35     
36     '         Function: (+4 Overloads) abs, acos, (+2 Overloads) addExact, asin, atan
37     '                   atan2, ceil, cos, cosh, (+2 Overloads) decrementExact
38     '                   exp, floor, (+2 Overloads) floorDiv, (+2 Overloads) floorMod, IEEEremainder
39     '                   (+2 Overloads) incrementExact, log, log10, Log1m, log1p
40     '                   (+2 Overloads) max, (+2 Overloads) min, (+2 Overloads) multiplyExact, (+2 Overloads) negateExact, pow
41     '                   random, sin, sinh, sqrt, (+2 Overloads) subtractExact
42     '                   tan, tanh, toDegrees, toIntExact, toRadians
43     '         Class RandomNumberGeneratorHolder
44     
45     
46     
47     
48     
49     
50     ' /********************************************************************************/
51
52 #End Region
53
54 Imports sys = System.Math
55
56 '
57 ' * Copyright (c) 1994, 2013, Oracle and/or its affiliates. All rights reserved.
58 ' * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
59 ' *
60 ' *
61 ' *
62 ' *
63 ' *
64 ' *
65 ' *
66 ' *
67 ' *
68 ' *
69 ' *
70 ' *
71 ' *
72 ' *
73 ' *
74 ' *
75 ' *
76 ' *
77 ' *
78 ' *
79
80
81 Namespace Language.Java
82
83     ''' <summary>
84     ''' The class {@code Math} contains methods for performing basic
85     ''' numeric operations such as the elementary exponential, logarithm,
86     ''' square root, and trigonometric functions.
87     ''' 
88     ''' Unlike some of the numeric methods of class
89     ''' {@code StrictMath}, all implementations of the equivalent
90     ''' functions of class {@code Math} are not defined to return the
91     ''' bit-for-bit same results.  This relaxation permits
92     ''' better-performing implementations where strict reproducibility is
93     ''' not required.
94     ''' 
95     ''' By default many of the {@code Math} methods simply call
96     ''' the equivalent method in {@code StrictMath} for their
97     ''' implementation.  Code generators are encouraged to use
98     ''' platform-specific native libraries or microprocessor instructions,
99     ''' where available, to provide higher-performance implementations of
100     ''' {@code Math} methods.  Such higher-performance
101     ''' implementations still must conform to the specification for
102     ''' {@code Math}.
103     ''' 
104     ''' The quality of implementation specifications concern two
105     ''' properties, accuracy of the returned result and monotonicity of the
106     ''' method.  Accuracy of the floating-point {@code Math} methods is
107     ''' measured in terms of _ulps_, units in the last place.  For a
108     ''' given floating-point format, an #ulp(double) ulp of a
109     ''' specific real number value is the distance between the two
110     ''' floating-point values bracketing that numerical value.  When
111     ''' discussing the accuracy of a method as a whole rather than at a
112     ''' specific argument, the number of ulps cited is for the worst-case
113     ''' error at any argument.  If a method always has an error less than
114     ''' 0.5 ulps, the method always returns the floating-point number
115     ''' nearest the exact result; such a method is _correctly
116     ''' rounded_.  A correctly rounded method is generally the best a
117     ''' floating-point approximation can be; however, it is impractical for
118     ''' many floating-point methods to be correctly rounded.  Instead, for
119     ''' the {@code Math} [Class], a larger error bound of 1 or 2 ulps is
120     ''' allowed for certain methods.  Informally, with a 1 ulp error bound,
121     ''' when the exact result is a representable number, the exact result
122     ''' should be returned as the computed result; otherwise, either of the
123     ''' two floating-point values which bracket the exact result may be
124     ''' returned.  For exact results large in magnitude, one of the
125     ''' endpoints of the bracket may be infinite.  Besides accuracy at
126     ''' individual arguments, maintaining proper relations between the
127     ''' method at different arguments is also important.  Therefore, most
128     ''' methods with more than 0.5 ulp errors are required to be
129     ''' _semi-monotonic_: whenever the mathematical function is
130     ''' non-decreasing, so is the floating-point approximation, likewise,
131     ''' whenever the mathematical function is non-increasing, so is the
132     ''' floating-point approximation.  Not all approximations that have 1
133     ''' ulp accuracy will automatically meet the monotonicity requirements.
134     ''' 
135     ''' 
136     ''' The platform uses signed two's complement integer arithmetic with
137     ''' int and long primitive types.  The developer should choose
138     ''' the primitive type to ensure that arithmetic operations consistently
139     ''' produce correct results, which in some cases means the operations
140     ''' will not overflow the range of values of the computation.
141     ''' The best practice is to choose the primitive type and algorithm to avoid
142     ''' overflow. In cases where the size is {@code int} or {@code long} and
143     ''' overflow errors need to be detected, the methods {@code addExact},
144     ''' {@code subtractExact}, {@code multiplyExact}, and {@code toIntExact}
145     ''' throw an {@code ArithmeticException} when the results overflow.
146     ''' For other arithmetic operations such as divide, absolute value,
147     ''' increment, decrement, and negation overflow occurs only with
148     ''' a specific minimum or maximum value and should be checked against
149     ''' the minimum or maximum as appropriate.
150     ''' 
151     ''' @author  unascribed
152     ''' @author  Joseph D. Darcy
153     ''' @since   JDK1.0
154     ''' </summary>
155     Public Module JavaMath
156
157         ''' <summary>
158         ''' The {@code double} value that is closer than any other to
159         ''' _e_, the base of the natural logarithms.
160         ''' </summary>
161         Public Const E As Double = 2.7182818284590451
162
163         ''' <summary>
164         ''' The {@code double} value that is closer than any other to
165         ''' _pi_, the ratio of the circumference of a circle to its
166         ''' diameter.
167         ''' </summary>
168         Public Const PI As Double = 3.1415926535897931
169
170         ''' <summary>
171         ''' Returns the trigonometric sine of an angle.  Special cases:
172         ''' + If the argument is NaN or an infinity, then the
173         ''' result is NaN.
174         ''' + If the argument is zero, then the result is a zero with the
175         ''' same sign as the argument.
176         ''' 
177         ''' The computed result must be within 1 ulp of the exact result.
178         ''' Results must be semi-monotonic.
179         ''' </summary>
180         ''' <param name="a">   an angle, in radians. </param>
181         ''' <returns>  the sine of the argument. </returns>
182         Public Function sin(a As DoubleAs Double
183             Return sys.Sin(a) ' default impl. delegates to StrictMath
184         End Function
185
186         ''' <summary>
187         ''' Returns the trigonometric cosine of an angle. Special cases:
188         ''' + If the argument is NaN or an infinity, then the
189         ''' result is NaN.
190         ''' 
191         ''' The computed result must be within 1 ulp of the exact result.
192         ''' Results must be semi-monotonic.
193         ''' </summary>
194         ''' <param name="a">   an angle, in radians. </param>
195         ''' <returns>  the cosine of the argument. </returns>
196         Public Function cos(a As DoubleAs Double
197             Return sys.Cos(a) ' default impl. delegates to StrictMath
198         End Function
199
200         ''' <summary>
201         ''' Returns the trigonometric tangent of an angle.  Special cases:
202         ''' + If the argument is NaN or an infinity, then the result
203         ''' is NaN.
204         ''' + If the argument is zero, then the result is a zero with the
205         ''' same sign as the argument.
206         ''' 
207         ''' The computed result must be within 1 ulp of the exact result.
208         ''' Results must be semi-monotonic.
209         ''' </summary>
210         ''' <param name="a">   an angle, in radians. </param>
211         ''' <returns>  the tangent of the argument. </returns>
212         Public Function tan(a As DoubleAs Double
213             Return sys.Tan(a) ' default impl. delegates to StrictMath
214         End Function
215
216         ''' <summary>
217         ''' Returns the arc sine of a value; the returned angle is in the
218         ''' range -_pi_/2 through _pi_/2.  Special cases:
219         ''' + If the argument is NaN or its absolute value is greater
220         ''' than 1, then the result is NaN.
221         ''' + If the argument is zero, then the result is a zero with the
222         ''' same sign as the argument.
223         ''' 
224         ''' The computed result must be within 1 ulp of the exact result.
225         ''' Results must be semi-monotonic.
226         ''' </summary>
227         ''' <param name="a">   the value whose arc sine is to be returned. </param>
228         ''' <returns>  the arc sine of the argument. </returns>
229         Public Function asin(a As DoubleAs Double
230             Return sys.Asin(a) ' default impl. delegates to StrictMath
231         End Function
232
233         ''' <summary>
234         ''' Returns the arc cosine of a value; the returned angle is in the
235         ''' range 0.0 through _pi_.  Special case:
236         ''' + If the argument is NaN or its absolute value is greater
237         ''' than 1, then the result is NaN.
238         ''' 
239         ''' The computed result must be within 1 ulp of the exact result.
240         ''' Results must be semi-monotonic.
241         ''' </summary>
242         ''' <param name="a">   the value whose arc cosine is to be returned. </param>
243         ''' <returns>  the arc cosine of the argument. </returns>
244         Public Function acos(a As DoubleAs Double
245             Return sys.Acos(a) ' default impl. delegates to StrictMath
246         End Function
247
248         ''' <summary>
249         ''' Returns the arc tangent of a value; the returned angle is in the
250         ''' range -_pi_/2 through _pi_/2.  Special cases:
251         ''' + If the argument is NaN, then the result is NaN.
252         ''' + If the argument is zero, then the result is a zero with the
253         ''' same sign as the argument.
254         ''' 
255         ''' The computed result must be within 1 ulp of the exact result.
256         ''' Results must be semi-monotonic.
257         ''' </summary>
258         ''' <param name="a">   the value whose arc tangent is to be returned. </param>
259         ''' <returns>  the arc tangent of the argument. </returns>
260         Public Function atan(a As DoubleAs Double
261             Return sys.Atan(a) ' default impl. delegates to StrictMath
262         End Function
263
264         ''' <summary>
265         ''' Converts an angle measured in degrees to an approximately
266         ''' equivalent angle measured in radians.  The conversion from
267         ''' degrees to radians is generally inexact.
268         ''' </summary>
269         ''' <param name="angdeg">   an angle, in degrees </param>
270         ''' <returns>  the measurement of the angle {@code angdeg}
271         '''          in radians.
272         ''' @since   1.2 </returns>
273         Public Function toRadians(angdeg As DoubleAs Double
274             Return angdeg / 180.0 * PI
275         End Function
276
277         ''' <summary>
278         ''' Converts an angle measured in radians to an approximately
279         ''' equivalent angle measured in degrees.  The conversion from
280         ''' radians to degrees is generally inexact; users should
281         ''' _not_ expect {@code cos(toRadians(90.0))} to exactly
282         ''' equal {@code 0.0}.
283         ''' </summary>
284         ''' <param name="angrad">   an angle, in radians </param>
285         ''' <returns>  the measurement of the angle {@code angrad}
286         '''          in degrees.
287         ''' @since   1.2 </returns>
288         Public Function toDegrees(angrad As DoubleAs Double
289             Return angrad * 180.0 / PI
290         End Function
291
292         ''' <summary>
293         ''' Returns Euler's number _e_ raised to the power of a
294         ''' {@code double} value.  Special cases:
295         ''' + If the argument is NaN, the result is NaN.
296         ''' + If the argument is positive infinity, then the result is
297         ''' positive infinity.
298         ''' + If the argument is negative infinity, then the result is
299         ''' positive zero.
300         ''' 
301         ''' The computed result must be within 1 ulp of the exact result.
302         ''' Results must be semi-monotonic.
303         ''' </summary>
304         ''' <param name="a">   the exponent to raise _e_ to. </param>
305         ''' <returns>  the value _e_{@code a},
306         '''          where _e_ is the base of the natural logarithms. </returns>
307         Public Function exp(a As DoubleAs Double
308             Return sys.Exp(a) ' default impl. delegates to StrictMath
309         End Function
310
311         ''' <summary>
312         ''' Returns the natural logarithm (base _e_) of a {@code double}
313         ''' value.  Special cases:
314         ''' + If the argument is NaN or less than zero, then the result
315         ''' is NaN.
316         ''' + If the argument is positive infinity, then the result is
317         ''' positive infinity.
318         ''' + If the argument is positive zero or negative zero, then the
319         ''' result is negative infinity.
320         ''' 
321         ''' The computed result must be within 1 ulp of the exact result.
322         ''' Results must be semi-monotonic.
323         ''' </summary>
324         ''' <param name="a">   a value </param>
325         ''' <returns>  the value ln {@code a}, the natural logarithm of
326         '''          {@code a}. </returns>
327         Public Function log(a As DoubleAs Double
328             Return sys.Log(a) ' default impl. delegates to StrictMath
329         End Function
330
331         ''' <summary>
332         ''' Returns the base 10 logarithm of a {@code double} value.
333         ''' Special cases:
334         ''' 
335         ''' + If the argument is NaN or less than zero, then the result
336         ''' is NaN.
337         ''' + If the argument is positive infinity, then the result is
338         ''' positive infinity.
339         ''' + If the argument is positive zero or negative zero, then the
340         ''' result is negative infinity.
341         ''' +  If the argument is equal to 10<sup>_n_</sup> for
342         ''' integer _n_, then the result is _n_.
343         ''' 
344         ''' 
345         ''' The computed result must be within 1 ulp of the exact result.
346         ''' Results must be semi-monotonic.
347         ''' </summary>
348         ''' <param name="a">   a value </param>
349         ''' <returns>  the base 10 logarithm of  {@code a}.
350         ''' @since 1.5 </returns>
351         Public Function log10(a As DoubleAs Double
352             Return sys.Log10(a) ' default impl. delegates to StrictMath
353         End Function
354
355         ''' <summary>
356         ''' Returns the correctly rounded positive square root of a
357         ''' {@code double} value.
358         ''' Special cases:
359         ''' + If the argument is NaN or less than zero, then the result
360         ''' is NaN.
361         ''' + If the argument is positive infinity, then the result is positive
362         ''' infinity.
363         ''' + If the argument is positive zero or negative zero, then the
364         ''' result is the same as the argument.
365         ''' Otherwise, the result is the {@code double} value closest to
366         ''' the true mathematical square root of the argument value.
367         ''' </summary>
368         ''' <param name="a">   a value. </param>
369         ''' <returns>  the positive square root of {@code a}.
370         '''          If the argument is NaN or less than zero, the result is NaN. </returns>
371         Public Function sqrt(a As DoubleAs Double
372             Return sys.Sqrt(a) ' default impl. delegates to StrictMath
373             Note that hardware sqrt instructions
374             ' frequently can be directly used by JITs
375             ' and should be much faster than doing
376             ' sys.sqrt in software.
377         End Function
378
379         '''' <summary>
380         '''' Returns the cube root of a {@code double} value.  For
381         '''' positive finite {@code x}, {@code cbrt(-x) ==
382         '''' -cbrt(x)}; that is, the cube root of a negative value is
383         '''' the negative of the cube root of that value's magnitude.
384         '''' 
385         '''' Special cases:
386         '''' 
387         '''' 
388         '''' 
389         '''' + If the argument is NaN, then the result is NaN.
390         '''' 
391         '''' + If the argument is infinite, then the result is an infinity
392         '''' with the same sign as the argument.
393         '''' 
394         '''' + If the argument is zero, then the result is a zero with the
395         '''' same sign as the argument.
396         '''' 
397         '''' 
398         '''' 
399         '''' The computed result must be within 1 ulp of the exact result.
400         '''' </summary>
401         '''' <param name="a">   a value. </param>
402         '''' <returns>  the cube root of {@code a}.
403         '''' @since 1.5 </returns>
404         'Public Function cbrt(a As DoubleAs Double
405         '    Return sys.cbrt(a)
406         'End Function
407
408         ''' <summary>
409         ''' Computes the remainder operation on two arguments as prescribed
410         ''' by the IEEE 754 standard.
411         ''' The remainder value is mathematically equal to
412         ''' ``f1 - f2`` x _n_,
413         ''' where _n_ is the mathematical integer closest to the exact
414         ''' mathematical value of the quotient {@code f1/f2}, and if two
415         ''' mathematical integers are equally close to {@code f1/f2},
416         ''' then _n_ is the integer that is even. If the remainder is
417         ''' zero, its sign is the same as the sign of the first argument.
418         ''' Special cases:
419         ''' + If either argument is NaN, or the first argument is infinite,
420         ''' or the second argument is positive zero or negative zero, then the
421         ''' result is NaN.
422         ''' + If the first argument is finite and the second argument is
423         ''' infinite, then the result is the same as the first argument.
424         ''' </summary>
425         ''' <param name="f1">   the dividend. </param>
426         ''' <param name="f2">   the divisor. </param>
427         ''' <returns>  the remainder when {@code f1} is divided by
428         '''          {@code f2}. </returns>
429         Public Function IEEEremainder(f1 As Double, f2 As DoubleAs Double
430             Return sys.IEEERemainder(f1, f2) ' delegate to StrictMath
431         End Function
432
433         ''' <summary>
434         ''' Returns the smallest (closest to negative infinity)
435         ''' {@code double} value that is greater than or equal to the
436         ''' argument and is equal to a mathematical  java.lang.[Integer]. Special cases:
437         ''' + If the argument value is already equal to a
438         ''' mathematical integer, then the result is the same as the
439         ''' argument.  + If the argument is NaN or an infinity or
440         ''' positive zero or negative zero, then the result is the same as
441         ''' the argument.  + If the argument value is less than zero but
442         ''' greater than -1.0, then the result is negative zero. Note
443         ''' that the value of {@code sys.ceil(x)} is exactly the
444         ''' value of {@code -Math.floor(-x)}.
445         ''' 
446         ''' </summary>
447         ''' <param name="a">   a value. </param>
448         ''' <returns>  the smallest (closest to negative infinity)
449         '''          floating-point value that is greater than or equal to
450         '''          the argument and is equal to a mathematical  java.lang.[Integer]. </returns>
451         Public Function ceil(a As DoubleAs Double
452             Return sys.Ceiling(a) ' default impl. delegates to StrictMath
453         End Function
454
455         ''' <summary>
456         ''' Returns the largest (closest to positive infinity)
457         ''' {@code double} value that is less than or equal to the
458         ''' argument and is equal to a mathematical  java.lang.[Integer]. Special cases:
459         ''' + If the argument value is already equal to a
460         ''' mathematical integer, then the result is the same as the
461         ''' argument.  + If the argument is NaN or an infinity or
462         ''' positive zero or negative zero, then the result is the same as
463         ''' the argument.
464         ''' </summary>
465         ''' <param name="a">   a value. </param>
466         ''' <returns>  the largest (closest to positive infinity)
467         '''          floating-point value that less than or equal to the argument
468         '''          and is equal to a mathematical  java.lang.[Integer]. </returns>
469         Public Function floor(a As DoubleAs Double
470             Return sys.Floor(a) ' default impl. delegates to StrictMath
471         End Function
472
473         '''' <summary>
474         '''' Returns the {@code double} value that is closest in value
475         '''' to the argument and is equal to a mathematical  java.lang.[Integer]. If two
476         '''' {@code double} values that are mathematical integers are
477         '''' equally close, the result is the integer value that is
478         '''' even. Special cases:
479         '''' + If the argument value is already equal to a mathematical
480         '''' integer, then the result is the same as the argument.
481         '''' + If the argument is NaN or an infinity or positive zero or negative
482         '''' zero, then the result is the same as the argument.
483         '''' </summary>
484         '''' <param name="a">   a {@code double} value. </param>
485         '''' <returns>  the closest floating-point value to {@code a} that is
486         ''''          equal to a mathematical  java.lang.[Integer]. </returns>
487         'Public Function rint(a As DoubleAs Double
488         '    Return sys.rint(a) ' default impl. delegates to StrictMath
489         'End Function
490
491         ''' <summary>
492         ''' Returns the angle _theta_ from the conversion of rectangular
493         ''' coordinates ({@code x}, {@code y}) to polar
494         ''' coordinates (r, _theta_).
495         ''' This method computes the phase _theta_ by computing an arc tangent
496         ''' of {@code y/x} in the range of -_pi_ to _pi_. Special
497         ''' cases:
498         ''' + If either argument is NaN, then the result is NaN.
499         ''' + If the first argument is positive zero and the second argument
500         ''' is positive, or the first argument is positive and finite and the
501         ''' second argument is positive infinity, then the result is positive
502         ''' zero.
503         ''' + If the first argument is negative zero and the second argument
504         ''' is positive, or the first argument is negative and finite and the
505         ''' second argument is positive infinity, then the result is negative zero.
506         ''' + If the first argument is positive zero and the second argument
507         ''' is negative, or the first argument is positive and finite and the
508         ''' second argument is negative infinity, then the result is the
509         ''' {@code double} value closest to _pi_.
510         ''' + If the first argument is negative zero and the second argument
511         ''' is negative, or the first argument is negative and finite and the
512         ''' second argument is negative infinity, then the result is the
513         ''' {@code double} value closest to -_pi_.
514         ''' + If the first argument is positive and the second argument is
515         ''' positive zero or negative zero, or the first argument is positive
516         ''' infinity and the second argument is finite, then the result is the
517         ''' {@code double} value closest to _pi_/2.
518         ''' + If the first argument is negative and the second argument is
519         ''' positive zero or negative zero, or the first argument is negative
520         ''' infinity and the second argument is finite, then the result is the
521         ''' {@code double} value closest to -_pi_/2.
522         ''' + If both arguments are positive infinity, then the result is the
523         ''' {@code double} value closest to _pi_/4.
524         ''' + If the first argument is positive infinity and the second argument
525         ''' is negative infinity, then the result is the {@code double}
526         ''' value closest to 3*_pi_/4.
527         ''' + If the first argument is negative infinity and the second argument
528         ''' is positive infinity, then the result is the {@code double} value
529         ''' closest to -_pi_/4.
530         ''' + If both arguments are negative infinity, then the result is the
531         ''' {@code double} value closest to -3*_pi_/4.
532         ''' 
533         ''' The computed result must be within 2 ulps of the exact result.
534         ''' Results must be semi-monotonic.
535         ''' </summary>
536         ''' <param name="y">   the ordinate coordinate </param>
537         ''' <param name="x">   the abscissa coordinate </param>
538         ''' <returns>  the _theta_ component of the point
539         '''          (_r_, _theta_)
540         '''          in polar coordinates that corresponds to the point
541         '''          (_x_, _y_) in Cartesian coordinates. </returns>
542         Public Function atan2(y As Double, x As DoubleAs Double
543             Return sys.Atan2(y, x) ' default impl. delegates to StrictMath
544         End Function
545
546         ''' <summary>
547         ''' Returns the value of the first argument raised to the power of the
548         ''' second argument. Special cases:
549         ''' 
550         ''' + If the second argument is positive or negative zero, then the
551         ''' result is 1.0.
552         ''' + If the second argument is 1.0, then the result is the same as the
553         ''' first argument.
554         ''' + If the second argument is NaN, then the result is NaN.
555         ''' + If the first argument is NaN and the second argument is nonzero,
556         ''' then the result is NaN.
557         ''' 
558         ''' + If
559         ''' 
560         ''' + the absolute value of the first argument is greater than 1
561         ''' and the second argument is positive infinity, or
562         ''' + the absolute value of the first argument is less than 1 and
563         ''' the second argument is negative infinity,
564         ''' 
565         ''' then the result is positive infinity.
566         ''' 
567         ''' + If
568         ''' 
569         ''' + the absolute value of the first argument is greater than 1 and
570         ''' the second argument is negative infinity, or
571         ''' + the absolute value of the
572         ''' first argument is less than 1 and the second argument is positive
573         ''' infinity,
574         ''' 
575         ''' then the result is positive zero.
576         ''' 
577         ''' + If the absolute value of the first argument equals 1 and the
578         ''' second argument is infinite, then the result is NaN.
579         ''' 
580         ''' + If
581         ''' 
582         ''' + the first argument is positive zero and the second argument
583         ''' is greater than zero, or
584         ''' + the first argument is positive infinity and the second
585         ''' argument is less than zero,
586         ''' 
587         ''' then the result is positive zero.
588         ''' 
589         ''' + If
590         ''' 
591         ''' + the first argument is positive zero and the second argument
592         ''' is less than zero, or
593         ''' + the first argument is positive infinity and the second
594         ''' argument is greater than zero,
595         ''' 
596         ''' then the result is positive infinity.
597         ''' 
598         ''' + If
599         ''' 
600         ''' + the first argument is negative zero and the second argument
601         ''' is greater than zero but not a finite odd integer, or
602         ''' + the first argument is negative infinity and the second
603         ''' argument is less than zero but not a finite odd integer,
604         ''' 
605         ''' then the result is positive zero.
606         ''' 
607         ''' + If
608         ''' 
609         ''' + the first argument is negative zero and the second argument
610         ''' is a positive finite odd integer, or
611         ''' + the first argument is negative infinity and the second
612         ''' argument is a negative finite odd integer,
613         ''' 
614         ''' then the result is negative zero.
615         ''' 
616         ''' + If
617         ''' 
618         ''' + the first argument is negative zero and the second argument
619         ''' is less than zero but not a finite odd integer, or
620         ''' + the first argument is negative infinity and the second
621         ''' argument is greater than zero but not a finite odd integer,
622         ''' 
623         ''' then the result is positive infinity.
624         ''' 
625         ''' + If
626         ''' 
627         ''' + the first argument is negative zero and the second argument
628         ''' is a negative finite odd integer, or
629         ''' + the first argument is negative infinity and the second
630         ''' argument is a positive finite odd integer,
631         ''' 
632         ''' then the result is negative infinity.
633         ''' 
634         ''' + If the first argument is finite and less than zero
635         ''' 
636         ''' +  if the second argument is a finite even integer, the
637         ''' result is equal to the result of raising the absolute value of
638         ''' the first argument to the power of the second argument
639         ''' 
640         ''' + if the second argument is a finite odd integer, the result
641         ''' is equal to the negative of the result of raising the absolute
642         ''' value of the first argument to the power of the second
643         ''' argument
644         ''' 
645         ''' + if the second argument is finite and not an integer, then
646         ''' the result is NaN.
647         ''' 
648         ''' 
649         ''' + If both arguments are integers, then the result is exactly equal
650         ''' to the mathematical result of raising the first argument to the power
651         ''' of the second argument if that result can in fact be represented
652         ''' exactly as a {@code double} value.
653         ''' 
654         ''' (In the foregoing descriptions, a floating-point value is
655         ''' considered to be an integer if and only if it is finite and a
656         ''' fixed point of the method #ceil ceil or,
657         ''' equivalently, a fixed point of the method {@link #floor
658         ''' floor}. A value is a fixed point of a one-argument
659         ''' method if and only if the result of applying the method to the
660         ''' value is equal to the value.)
661         ''' 
662         ''' The computed result must be within 1 ulp of the exact result.
663         ''' Results must be semi-monotonic.
664         ''' </summary>
665         ''' <param name="a">   the base. </param>
666         ''' <param name="b">   the exponent. </param>
667         ''' <returns>  the value {@code a}<sup>{@code b}</sup>. </returns>
668         Public Function pow(a As Double, b As DoubleAs Double
669             Return sys.Pow(a, b) ' default impl. delegates to StrictMath
670         End Function
671
672         '''' <summary>
673         '''' Returns the closest {@code int} to the argument, with ties
674         '''' rounding to positive infinity.
675         '''' 
676         '''' 
677         '''' Special cases:
678         '''' + If the argument is NaN, the result is 0.
679         '''' + If the argument is negative infinity or any value less than or
680         '''' equal to the value of {@code  java.lang.[Integer].MIN_VALUE}, the result is
681         '''' equal to the value of {@code  java.lang.[Integer].MIN_VALUE}.
682         '''' + If the argument is positive infinity or any value greater than or
683         '''' equal to the value of {@code  java.lang.[Integer].MAX_VALUE}, the result is
684         '''' equal to the value of {@code  java.lang.[Integer].MAX_VALUE}.
685         '''' </summary>
686         '''' <param name="a">   a floating-point value to be rounded to an  java.lang.[Integer]. </param>
687         '''' <returns>  the value of the argument rounded to the nearest
688         ''''          {@code int} value. </returns>
689         '''' <seealso cref=     java.lang.Integer#MAX_VALUE </seealso>
690         '''' <seealso cref=     java.lang.Integer#MIN_VALUE </seealso>
691         'Public Function round(a As SingleAs Integer
692         '    Dim intBits As Integer = Float.floatToRawIntBits(a)
693         '    Dim biasedExp As Integer = (intBits And sun.misc.FloatConsts.EXP_BIT_MASK) >> (sun.misc.FloatConsts.SIGNIFICAND_WIDTH - 1)
694         '    Dim shift As Integer = (sun.misc.FloatConsts.SIGNIFICAND_WIDTH - 2 + sun.misc.FloatConsts.EXP_BIAS) - biasedExp
695         '    If (shift And -32) = 0 Then ' shift >= 0 && shift < 32
696         '        ' a is a finite number such that pow(2,-32) <= ulp(a) < 1
697         '        Dim r As Integer = ((intBits And sun.misc.FloatConsts.SIGNIF_BIT_MASK) Or (sun.misc.FloatConsts.SIGNIF_BIT_MASK + 1))
698         '        If intBits < 0 Then r = -r
699         '        ' In the comments below each Java expression evaluates to the value
700         '        ' the corresponding mathematical expression:
701         '        ' (r) evaluates to a / ulp(a)
702         '        ' (r >> shift) evaluates to floor(a * 2)
703         '        ' ((r >> shift) + 1) evaluates to floor((a + 1/2) * 2)
704         '        ' (((r >> shift) + 1) >> 1) evaluates to floor(a + 1/2)
705         '        Return ((r >> shift) + 1) >> 1
706         '    Else
707         '        ' a is either
708         '        ' - a finite number with abs(a) < exp(2,FloatConsts.SIGNIFICAND_WIDTH-32) < 1/2
709         '        ' - a finite number with ulp(a) >= 1 and hence a is a mathematical integer
710         '        ' - an infinity or NaN
711         '        Return CInt(Fix(a))
712         '    End If
713         'End Function
714
715         '''' <summary>
716         '''' Returns the closest {@code long} to the argument, with ties
717         '''' rounding to positive infinity.
718         '''' 
719         '''' Special cases:
720         '''' + If the argument is NaN, the result is 0.
721         '''' + If the argument is negative infinity or any value less than or
722         '''' equal to the value of {@code java.lang.[Long].MIN_VALUE}, the result is
723         '''' equal to the value of {@code java.lang.[Long].MIN_VALUE}.
724         '''' + If the argument is positive infinity or any value greater than or
725         '''' equal to the value of {@code java.lang.[Long].MAX_VALUE}, the result is
726         '''' equal to the value of {@code java.lang.[Long].MAX_VALUE}.
727         '''' </summary>
728         '''' <param name="a">   a floating-point value to be rounded to a
729         ''''          {@code long}. </param>
730         '''' <returns>  the value of the argument rounded to the nearest
731         ''''          {@code long} value. </returns>
732         '''' <seealso cref=     java.lang.Long#MAX_VALUE </seealso>
733         '''' <seealso cref=     java.lang.Long#MIN_VALUE </seealso>
734         'Public Function round(a As DoubleAs Long
735         '    Dim longBits As Long = Java.lang.[Double].doubleToRawLongBits(a)
736         '    Dim biasedExp As Long = (longBits And sun.misc.DoubleConsts.EXP_BIT_MASK) >> (sun.misc.DoubleConsts.SIGNIFICAND_WIDTH - 1)
737         '    Dim shift As Long = (sun.misc.DoubleConsts.SIGNIFICAND_WIDTH - 2 + sun.misc.DoubleConsts.EXP_BIAS) - biasedExp
738         '    If (shift And -64) = 0 Then ' shift >= 0 && shift < 64
739         '        ' a is a finite number such that pow(2,-64) <= ulp(a) < 1
740         '        Dim r As Long = ((longBits And sun.misc.DoubleConsts.SIGNIF_BIT_MASK) Or (sun.misc.DoubleConsts.SIGNIF_BIT_MASK + 1))
741         '        If longBits < 0 Then r = -r
742         '        ' In the comments below each Java expression evaluates to the value
743         '        ' the corresponding mathematical expression:
744         '        ' (r) evaluates to a / ulp(a)
745         '        ' (r >> shift) evaluates to floor(a * 2)
746         '        ' ((r >> shift) + 1) evaluates to floor((a + 1/2) * 2)
747         '        ' (((r >> shift) + 1) >> 1) evaluates to floor(a + 1/2)
748         '        Return ((r >> shift) + 1) >> 1
749         '    Else
750         '        ' a is either
751         '        ' - a finite number with abs(a) < exp(2,DoubleConsts.SIGNIFICAND_WIDTH-64) < 1/2
752         '        ' - a finite number with ulp(a) >= 1 and hence a is a mathematical integer
753         '        ' - an infinity or NaN
754         '        Return CLng(Fix(a))
755         '    End If
756         'End Function
757
758         Private NotInheritable Class RandomNumberGeneratorHolder
759             Friend Shared ReadOnly randomNumberGenerator As New Random
760         End Class
761
762         ''' <summary>
763         ''' Returns a {@code double} value with a positive sign, greater
764         ''' than or equal to {@code 0.0} and less than {@code 1.0}.
765         ''' Returned values are chosen pseudorandomly with (approximately)
766         ''' uniform distribution from that range.
767         ''' 
768         ''' When this method is first called, it creates a single new
769         ''' pseudorandom-number generator, exactly as if by the expression
770         ''' 
771         ''' <blockquote>{@code new java.util.Random()}</blockquote>
772         ''' 
773         ''' This new pseudorandom-number generator is used thereafter for
774         ''' all calls to this method and is used nowhere else.
775         ''' 
776         ''' This method is properly synchronized to allow correct use by
777         ''' more than one thread. However, if many threads need to generate
778         ''' pseudorandom numbers at a great rate, it may reduce contention
779         ''' for each thread to have its own pseudorandom-number generator.
780         ''' </summary>
781         ''' <returns>  a pseudorandom {@code double} greater than or equal
782         ''' to {@code 0.0} and less than {@code 1.0}. </returns>
783         Public Function random() As Double
784             Return RandomNumberGeneratorHolder.randomNumberGenerator.NextDouble()
785         End Function
786
787         ''' <summary>
788         ''' Returns the sum of its arguments,
789         ''' throwing an exception if the result overflows an {@code int}.
790         ''' </summary>
791         ''' <param name="x"> the first value </param>
792         ''' <param name="y"> the second value </param>
793         ''' <returns> the result </returns>
794         ''' <exception cref="ArithmeticException"> if the result overflows an int
795         ''' @since 1.8 </exception>
796         Public Function addExact(x As Integer, y As IntegerAs Integer
797             Dim r As Integer = x + y
798             ' HD 2-12 Overflow iff both arguments have the opposite sign of the result
799             If ((x Xor r) And (y Xor r)) < 0 Then Throw New ArithmeticException("integer overflow")
800             Return r
801         End Function
802
803         ''' <summary>
804         ''' Returns the sum of its arguments,
805         ''' throwing an exception if the result overflows a {@code long}.
806         ''' </summary>
807         ''' <param name="x"> the first value </param>
808         ''' <param name="y"> the second value </param>
809         ''' <returns> the result </returns>
810         ''' <exception cref="ArithmeticException"> if the result overflows a long
811         ''' @since 1.8 </exception>
812         Public Function addExact(x As Long, y As LongAs Long
813             Dim r As Long = x + y
814             ' HD 2-12 Overflow iff both arguments have the opposite sign of the result
815             If ((x Xor r) And (y Xor r)) < 0 Then Throw New ArithmeticException("long overflow")
816             Return r
817         End Function
818
819         ''' <summary>
820         ''' Returns the difference of the arguments,
821         ''' throwing an exception if the result overflows an {@code int}.
822         ''' </summary>
823         ''' <param name="x"> the first value </param>
824         ''' <param name="y"> the second value to subtract from the first </param>
825         ''' <returns> the result </returns>
826         ''' <exception cref="ArithmeticException"> if the result overflows an int
827         ''' @since 1.8 </exception>
828         Public Function subtractExact(x As Integer, y As IntegerAs Integer
829             Dim r As Integer = x - y
830             ' HD 2-12 Overflow iff the arguments have different signs and
831             ' the sign of the result is different than the sign of x
832             If ((x Xor y) And (x Xor r)) < 0 Then Throw New ArithmeticException("integer overflow")
833             Return r
834         End Function
835
836         ''' <summary>
837         ''' Returns the difference of the arguments,
838         ''' throwing an exception if the result overflows a {@code long}.
839         ''' </summary>
840         ''' <param name="x"> the first value </param>
841         ''' <param name="y"> the second value to subtract from the first </param>
842         ''' <returns> the result </returns>
843         ''' <exception cref="ArithmeticException"> if the result overflows a long
844         ''' @since 1.8 </exception>
845         Public Function subtractExact(x As Long, y As LongAs Long
846             Dim r As Long = x - y
847             ' HD 2-12 Overflow iff the arguments have different signs and
848             ' the sign of the result is different than the sign of x
849             If ((x Xor y) And (x Xor r)) < 0 Then Throw New ArithmeticException("long overflow")
850             Return r
851         End Function
852
853         ''' <summary>
854         ''' Returns the product of the arguments,
855         ''' throwing an exception if the result overflows an {@code int}.
856         ''' </summary>
857         ''' <param name="x"> the first value </param>
858         ''' <param name="y"> the second value </param>
859         ''' <returns> the result </returns>
860         ''' <exception cref="ArithmeticException"> if the result overflows an int
861         ''' @since 1.8 </exception>
862         Public Function multiplyExact(x As Integer, y As IntegerAs Integer
863             Dim r As Long = CLng(x) * CLng(y)
864             If CInt(r) <> r Then Throw New ArithmeticException("integer overflow")
865             Return CInt(r)
866         End Function
867
868         ''' <summary>
869         ''' Returns the product of the arguments,
870         ''' throwing an exception if the result overflows a {@code long}.
871         ''' </summary>
872         ''' <param name="x"> the first value </param>
873         ''' <param name="y"> the second value </param>
874         ''' <returns> the result </returns>
875         ''' <exception cref="ArithmeticException"> if the result overflows a long
876         ''' @since 1.8 </exception>
877         Public Function multiplyExact(x As Long, y As LongAs Long
878             Dim r As Long = x * y
879             Dim ax As Long = sys.Abs(x)
880             Dim ay As Long = sys.Abs(y)
881             If (CInt(CUInt((ax Or ay)) >> 31 <> 0)) Then
882                 ' Some bits greater than 2^31 that might cause overflow
883                 ' Check the result using the divide operator
884                 ' and check for the special case of java.lang.[Long].MIN_VALUE * -1
885                 If ((y <> 0) AndAlso (r \ y <> x)) OrElse (x = [Int64].MinValue AndAlso y = -1) Then Throw New ArithmeticException("long overflow")
886             End If
887             Return r
888         End Function
889
890         ''' <summary>
891         ''' Returns the argument incremented by one, throwing an exception if the
892         ''' result overflows an {@code int}.
893         ''' </summary>
894         ''' <param name="a"> the value to increment </param>
895         ''' <returns> the result </returns>
896         ''' <exception cref="ArithmeticException"> if the result overflows an int
897         ''' @since 1.8 </exception>
898         Public Function incrementExact(a As IntegerAs Integer
899             If a = [Int32].MaxValue Then Throw New ArithmeticException("integer overflow")
900
901             Return a + 1
902         End Function
903
904         ''' <summary>
905         ''' Returns the argument incremented by one, throwing an exception if the
906         ''' result overflows a {@code long}.
907         ''' </summary>
908         ''' <param name="a"> the value to increment </param>
909         ''' <returns> the result </returns>
910         ''' <exception cref="ArithmeticException"> if the result overflows a long
911         ''' @since 1.8 </exception>
912         Public Function incrementExact(a As LongAs Long
913             If a = [Int64].MaxValue Then Throw New ArithmeticException("long overflow")
914
915             Return a + 1L
916         End Function
917
918         ''' <summary>
919         ''' Returns the argument decremented by one, throwing an exception if the
920         ''' result overflows an {@code int}.
921         ''' </summary>
922         ''' <param name="a"> the value to decrement </param>
923         ''' <returns> the result </returns>
924         ''' <exception cref="ArithmeticException"> if the result overflows an int
925         ''' @since 1.8 </exception>
926         Public Function decrementExact(a As IntegerAs Integer
927             If a = [Int32].MinValue Then Throw New ArithmeticException("integer overflow")
928
929             Return a - 1
930         End Function
931
932         ''' <summary>
933         ''' Returns the argument decremented by one, throwing an exception if the
934         ''' result overflows a {@code long}.
935         ''' </summary>
936         ''' <param name="a"> the value to decrement </param>
937         ''' <returns> the result </returns>
938         ''' <exception cref="ArithmeticException"> if the result overflows a long
939         ''' @since 1.8 </exception>
940         Public Function decrementExact(a As LongAs Long
941             If a = [Int64].MinValue Then Throw New ArithmeticException("long overflow")
942
943             Return a - 1L
944         End Function
945
946         ''' <summary>
947         ''' Returns the negation of the argument, throwing an exception if the
948         ''' result overflows an {@code int}.
949         ''' </summary>
950         ''' <param name="a"> the value to negate </param>
951         ''' <returns> the result </returns>
952         ''' <exception cref="ArithmeticException"> if the result overflows an int
953         ''' @since 1.8 </exception>
954         Public Function negateExact(a As IntegerAs Integer
955             If a = [Int32].MinValue Then Throw New ArithmeticException("integer overflow")
956
957             Return -a
958         End Function
959
960         ''' <summary>
961         ''' Returns the negation of the argument, throwing an exception if the
962         ''' result overflows a {@code long}.
963         ''' </summary>
964         ''' <param name="a"> the value to negate </param>
965         ''' <returns> the result </returns>
966         ''' <exception cref="ArithmeticException"> if the result overflows a long
967         ''' @since 1.8 </exception>
968         Public Function negateExact(a As LongAs Long
969             If a = [Int64].MinValue Then Throw New ArithmeticException("long overflow")
970
971             Return -a
972         End Function
973
974         ''' <summary>
975         ''' Returns the value of the {@code long} argument;
976         ''' throwing an exception if the value overflows an {@code int}.
977         ''' </summary>
978         ''' <param name="value"> the long value </param>
979         ''' <returns> the argument as an int </returns>
980         ''' <exception cref="ArithmeticException"> if the {@code argument} overflows an int
981         ''' @since 1.8 </exception>
982         Public Function toIntExact(value As LongAs Integer
983             If CInt(value) <> value Then Throw New ArithmeticException("integer overflow")
984             Return CInt(value)
985         End Function
986
987         ''' <summary>
988         ''' Returns the largest (closest to positive infinity)
989         ''' {@code int} value that is less than or equal to the algebraic quotient.
990         ''' There is one special case, if the dividend is the
991         '''  Integer#MIN_VALUE  java.lang.[Integer].MIN_VALUE"/> and the divisor is {@code -1},
992         ''' then integer overflow occurs and
993         ''' the result is equal to the {@code  java.lang.[Integer].MIN_VALUE}.
994         ''' 
995         ''' Normal integer division operates under the round to zero rounding mode
996         ''' (truncation).  This operation instead acts under the round toward
997         ''' negative infinity (floor) rounding mode.
998         ''' The floor rounding mode gives different results than truncation
999         ''' when the exact result is negative.
1000         ''' 
1001         '''   + If the signs of the arguments are the same, the results of
1002         '''       {@code floorDiv} and the {@code /} operator are the same.  
1003         '''       For example, {@code floorDiv(4, 3) == 1} and {@code (4 / 3) == 1}.
1004         '''   + If the signs of the arguments are different,  the quotient is negative and
1005         '''       {@code floorDiv} returns the integer less than or equal to the quotient
1006         '''       and the {@code /} operator returns the integer closest to zero.
1007         '''       For example, {@code floorDiv(-4, 3) == -2},
1008         '''       whereas {@code (-4 / 3) == -1}.
1009         ''' </summary>
1010         ''' <param name="x"> the dividend </param>
1011         ''' <param name="y"> the divisor </param>
1012         ''' <returns> the largest (closest to positive infinity)
1013         ''' {@code int} value that is less than or equal to the algebraic quotient. </returns>
1014         ''' <exception cref="ArithmeticException"> if the divisor {@code y} is zero </exception>
1015         Public Function floorDiv(x As Integer, y As IntegerAs Integer
1016             Dim r As Integer = x \ y
1017             ' if the signs are different and modulo not zero, round down
1018             If (x Xor y) < 0 AndAlso (r * y <> x) Then r -= 1
1019             Return r
1020         End Function
1021
1022         ''' <summary>
1023         ''' Returns the largest (closest to positive infinity)
1024         ''' {@code long} value that is less than or equal to the algebraic quotient.
1025         ''' There is one special case, if the dividend is the
1026         '''  Long#MIN_VALUE java.lang.[Long].MIN_VALUE"/> and the divisor is {@code -1},
1027         ''' then integer overflow occurs and
1028         ''' the result is equal to the {@code java.lang.[Long].MIN_VALUE}.
1029         ''' 
1030         ''' Normal integer division operates under the round to zero rounding mode
1031         ''' (truncation).  This operation instead acts under the round toward
1032         ''' negative infinity (floor) rounding mode.
1033         ''' The floor rounding mode gives different results than truncation
1034         ''' when the exact result is negative.
1035         ''' 
1036         ''' For examples, see  #floorDiv(int, int)"/>.
1037         ''' </summary>
1038         ''' <param name="x"> the dividend </param>
1039         ''' <param name="y"> the divisor </param>
1040         ''' <returns> the largest (closest to positive infinity)
1041         ''' {@code long} value that is less than or equal to the algebraic quotient. </returns>
1042         ''' <exception cref="ArithmeticException"> if the divisor {@code y} is zero </exception>
1043         Public Function floorDiv(x As Long, y As LongAs Long
1044             Dim r As Long = x \ y
1045             ' if the signs are different and modulo not zero, round down
1046             If (x Xor y) < 0 AndAlso (r * y <> x) Then r -= 1
1047             Return r
1048         End Function
1049
1050         ''' <summary>
1051         ''' Returns the floor modulus of the {@code int} arguments.
1052         ''' 
1053         ''' The floor modulus is {@code x - (floorDiv(x, y) * y)},
1054         ''' has the same sign as the divisor {@code y}, and
1055         ''' is in the range of {@code -abs(y) &lt; r &lt; +abs(y)}.
1056         ''' 
1057         ''' 
1058         ''' The relationship between {@code floorDiv} and {@code floorMod} is such that:
1059         ''' 
1060         '''   + {@code floorDiv(x, y) * y + floorMod(x, y) == x}
1061         ''' 
1062         ''' 
1063         ''' The difference in values between {@code floorMod} and
1064         ''' the {@code %} operator is due to the difference between
1065         ''' {@code floorDiv} that returns the integer less than or equal to the quotient
1066         ''' and the {@code /} operator that returns the integer closest to zero.
1067         ''' 
1068         ''' Examples:
1069         ''' 
1070         '''   + If the signs of the arguments are the same, the results
1071         '''       of {@code floorMod} and the {@code %} operator are the same.   
1072         '''       
1073         '''       + {@code floorMod(4, 3) == 1};   and {@code (4 % 3) == 1} 
1074         '''       
1075         '''   + If the signs of the arguments are different, the results differ from the {@code %} operator. 
1076         '''      
1077         '''      + {@code floorMod(+4, -3) == -2};   and {@code (+4 % -3) == +1}  
1078         '''      + {@code floorMod(-4, +3) == +2};   and {@code (-4 % +3) == -1}  
1079         '''      + {@code floorMod(-4, -3) == -1};   and {@code (-4 % -3) == -1 }  
1080         '''      
1081         '''    
1082         ''' 
1083         ''' 
1084         ''' If the signs of arguments are unknown and a positive modulus
1085         ''' is needed it can be computed as {@code (floorMod(x, y) + abs(y)) % abs(y)}.
1086         ''' </summary>
1087         ''' <param name="x"> the dividend </param>
1088         ''' <param name="y"> the divisor </param>
1089         ''' <returns> the floor modulus {@code x - (floorDiv(x, y) * y)} </returns>
1090         ''' <exception cref="ArithmeticException"> if the divisor {@code y} is zero </exception>
1091         Public Function floorMod(x As Integer, y As IntegerAs Integer
1092             Dim r As Integer = x - floorDiv(x, y) * y
1093             Return r
1094         End Function
1095
1096         ''' <summary>
1097         ''' Returns the floor modulus of the {@code long} arguments.
1098         ''' 
1099         ''' The floor modulus is {@code x - (floorDiv(x, y) * y)},
1100         ''' has the same sign as the divisor {@code y}, and
1101         ''' is in the range of {@code -abs(y) &lt; r &lt; +abs(y)}.
1102         ''' 
1103         ''' 
1104         ''' The relationship between {@code floorDiv} and {@code floorMod} is such that:
1105         ''' 
1106         '''   + {@code floorDiv(x, y) * y + floorMod(x, y) == x}
1107         ''' 
1108         ''' 
1109         ''' For examples, see  #floorMod(int, int)"/>.
1110         ''' </summary>
1111         ''' <param name="x"> the dividend </param>
1112         ''' <param name="y"> the divisor </param>
1113         ''' <returns> the floor modulus {@code x - (floorDiv(x, y) * y)} </returns>
1114         ''' <exception cref="ArithmeticException"> if the divisor {@code y} is zero </exception>
1115         Public Function floorMod(x As Long, y As LongAs Long
1116             Return x - floorDiv(x, y) * y
1117         End Function
1118
1119         ''' <summary>
1120         ''' Returns the absolute value of an {@code int} value.
1121         ''' If the argument is not negative, the argument is returned.
1122         ''' If the argument is negative, the negation of the argument is returned.
1123         ''' 
1124         ''' Note that if the argument is equal to the value of
1125         '''  Integer#MIN_VALUE"/>, the most negative representable
1126         ''' {@code int} value, the result is that same value, which is
1127         ''' negative.
1128         ''' </summary>
1129         ''' <param name="a">   the argument whose absolute value is to be determined </param>
1130         ''' <returns>  the absolute value of the argument. </returns>
1131         Public Function abs(a As IntegerAs Integer
1132             Return If(a < 0, -a, a)
1133         End Function
1134
1135         ''' <summary>
1136         ''' Returns the absolute value of a {@code long} value.
1137         ''' If the argument is not negative, the argument is returned.
1138         ''' If the argument is negative, the negation of the argument is returned.
1139         ''' 
1140         ''' Note that if the argument is equal to the value of
1141         '''  Long#MIN_VALUE"/>, the most negative representable
1142         ''' {@code long} value, the result is that same value, which
1143         ''' is negative.
1144         ''' </summary>
1145         ''' <param name="a">   the argument whose absolute value is to be determined </param>
1146         ''' <returns>  the absolute value of the argument. </returns>
1147         Public Function abs(a As LongAs Long
1148             Return If(a < 0, -a, a)
1149         End Function
1150
1151         ''' <summary>
1152         ''' Returns the absolute value of a {@code float} value.
1153         ''' If the argument is not negative, the argument is returned.
1154         ''' If the argument is negative, the negation of the argument is returned.
1155         ''' Special cases:
1156         ''' + If the argument is positive zero or negative zero, the
1157         ''' result is positive zero.
1158         ''' + If the argument is infinite, the result is positive infinity.
1159         ''' + If the argument is NaN, the result is NaN.
1160         ''' In other words, the result is the same as the value of the expression:
1161         ''' {@code Float.intBitsToFloat(0x7fffffff &amp; Float.floatToIntBits(a))}
1162         ''' </summary>
1163         ''' <param name="a">   the argument whose absolute value is to be determined </param>
1164         ''' <returns>  the absolute value of the argument. </returns>
1165         Public Function abs(a As SingleAs Single
1166             Return If(a <= 0.0F, 0.0F - a, a)
1167         End Function
1168
1169         ''' <summary>
1170         ''' Returns the absolute value of a {@code double} value.
1171         ''' If the argument is not negative, the argument is returned.
1172         ''' If the argument is negative, the negation of the argument is returned.
1173         ''' Special cases:
1174         ''' + If the argument is positive zero or negative zero, the result
1175         ''' is positive zero.
1176         ''' + If the argument is infinite, the result is positive infinity.
1177         ''' + If the argument is NaN, the result is NaN.
1178         ''' In other words, the result is the same as the value of the expression:
1179         ''' {@code java.lang.[Double].longBitsToDouble((Double.doubleToLongBits(a)&lt;&lt;1)>>>1)}
1180         ''' </summary>
1181         ''' <param name="a">   the argument whose absolute value is to be determined </param>
1182         ''' <returns>  the absolute value of the argument. </returns>
1183         Public Function abs(a As DoubleAs Double
1184             Return If(a <= 0.0R, 0.0R - a, a)
1185         End Function
1186
1187         ''' <summary>
1188         ''' Returns the greater of two {@code int} values. That is, the
1189         ''' result is the argument closer to the value of
1190         '''  Integer#MAX_VALUE"/>. If the arguments have the same value,
1191         ''' the result is that same value.
1192         ''' </summary>
1193         ''' <param name="a">   an argument. </param>
1194         ''' <param name="b">   another argument. </param>
1195         ''' <returns>  the larger of {@code a} and {@code b}. </returns>
1196         Public Function max(a As Integer, b As IntegerAs Integer
1197             Return If(a >= b, a, b)
1198         End Function
1199
1200         ''' <summary>
1201         ''' Returns the greater of two {@code long} values. That is, the
1202         ''' result is the argument closer to the value of
1203         '''  Long#MAX_VALUE"/>. If the arguments have the same value,
1204         ''' the result is that same value.
1205         ''' </summary>
1206         ''' <param name="a">   an argument. </param>
1207         ''' <param name="b">   another argument. </param>
1208         ''' <returns>  the larger of {@code a} and {@code b}. </returns>
1209         Public Function max(a As Long, b As LongAs Long
1210             Return If(a >= b, a, b)
1211         End Function
1212
1213         '' Use raw bit-wise conversions on guaranteed non-NaN arguments.
1214         'Private negativeZeroFloatBits As Long = Float.floatToRawIntBits(-0.0F)
1215         'Private negativeZeroDoubleBits As Long = Java.lang.[Double].doubleToRawLongBits(-0.0R)
1216
1217         '''' <summary>
1218         '''' Returns the greater of two {@code float} values.  That is,
1219         '''' the result is the argument closer to positive infinity. If the
1220         '''' arguments have the same value, the result is that same
1221         '''' value. If either value is NaN, then the result is NaN.  Unlike
1222         '''' the numerical comparison operators, this method considers
1223         '''' negative zero to be strictly smaller than positive zero. If one
1224         '''' argument is positive zero and the other negative zero, the
1225         '''' result is positive zero.
1226         '''' </summary>
1227         '''' <param name="a">   an argument. </param>
1228         '''' <param name="b">   another argument. </param>
1229         '''' <returns>  the larger of {@code a} and {@code b}. </returns>
1230         'Public Function max(a As Single, b As SingleAs Single
1231         '    If a <> a Then Return a ' a is NaN
1232         '    If (a = 0.0F) AndAlso (b = 0.0F) AndAlso (Float.floatToRawIntBits(a) = negativeZeroFloatBits) Then Return b
1233         '    Return If(a >= b, a, b)
1234         'End Function
1235
1236         '''' <summary>
1237         '''' Returns the greater of two {@code double} values.  That
1238         '''' is, the result is the argument closer to positive infinity. If
1239         '''' the arguments have the same value, the result is that same
1240         '''' value. If either value is NaN, then the result is NaN.  Unlike
1241         '''' the numerical comparison operators, this method considers
1242         '''' negative zero to be strictly smaller than positive zero. If one
1243         '''' argument is positive zero and the other negative zero, the
1244         '''' result is positive zero.
1245         '''' </summary>
1246         '''' <param name="a">   an argument. </param>
1247         '''' <param name="b">   another argument. </param>
1248         '''' <returns>  the larger of {@code a} and {@code b}. </returns>
1249         'Public Function max(a As Double, b As DoubleAs Double
1250         '    If a <> a Then Return a ' a is NaN
1251         '    If (a = 0.0R) AndAlso (b = 0.0R) AndAlso (Double.doubleToRawLongBits(a) = negativeZeroDoubleBits) Then Return b
1252         '    Return If(a >= b, a, b)
1253         'End Function
1254
1255         ''' <summary>
1256         ''' Returns the smaller of two {@code int} values. That is,
1257         ''' the result the argument closer to the value of
1258         '''  Integer#MIN_VALUE"/>.  If the arguments have the same
1259         ''' value, the result is that same value.
1260         ''' </summary>
1261         ''' <param name="a">   an argument. </param>
1262         ''' <param name="b">   another argument. </param>
1263         ''' <returns>  the smaller of {@code a} and {@code b}. </returns>
1264         Public Function min(a As Integer, b As IntegerAs Integer
1265             Return If(a <= b, a, b)
1266         End Function
1267
1268         ''' <summary>
1269         ''' Returns the smaller of two {@code long} values. That is,
1270         ''' the result is the argument closer to the value of
1271         '''  Long#MIN_VALUE"/>. If the arguments have the same
1272         ''' value, the result is that same value.
1273         ''' </summary>
1274         ''' <param name="a">   an argument. </param>
1275         ''' <param name="b">   another argument. </param>
1276         ''' <returns>  the smaller of {@code a} and {@code b}. </returns>
1277         Public Function min(a As Long, b As LongAs Long
1278             Return If(a <= b, a, b)
1279         End Function
1280
1281         '''' <summary>
1282         '''' Returns the smaller of two {@code float} values.  That is,
1283         '''' the result is the value closer to negative infinity. If the
1284         '''' arguments have the same value, the result is that same
1285         '''' value. If either value is NaN, then the result is NaN.  Unlike
1286         '''' the numerical comparison operators, this method considers
1287         '''' negative zero to be strictly smaller than positive zero.  If
1288         '''' one argument is positive zero and the other is negative zero,
1289         '''' the result is negative zero.
1290         '''' </summary>
1291         '''' <param name="a">   an argument. </param>
1292         '''' <param name="b">   another argument. </param>
1293         '''' <returns>  the smaller of {@code a} and {@code b}. </returns>
1294         'Public Function min(a As Single, b As SingleAs Single
1295         '    If a <> a Then Return a ' a is NaN
1296         '    If (a = 0.0F) AndAlso (b = 0.0F) AndAlso (Float.floatToRawIntBits(b) = negativeZeroFloatBits) Then Return b
1297         '    Return If(a <= b, a, b)
1298         'End Function
1299
1300         '''' <summary>
1301         '''' Returns the smaller of two {@code double} values.  That
1302         '''' is, the result is the value closer to negative infinity. If the
1303         '''' arguments have the same value, the result is that same
1304         '''' value. If either value is NaN, then the result is NaN.  Unlike
1305         '''' the numerical comparison operators, this method considers
1306         '''' negative zero to be strictly smaller than positive zero. If one
1307         '''' argument is positive zero and the other is negative zero, the
1308         '''' result is negative zero.
1309         '''' </summary>
1310         '''' <param name="a">   an argument. </param>
1311         '''' <param name="b">   another argument. </param>
1312         '''' <returns>  the smaller of {@code a} and {@code b}. </returns>
1313         'Public Function min(a As Double, b As DoubleAs Double
1314         '    If a <> a Then Return a ' a is NaN
1315         '    If (a = 0.0R) AndAlso (b = 0.0R) AndAlso (Double.doubleToRawLongBits(b) = negativeZeroDoubleBits) Then Return b
1316         '    Return If(a <= b, a, b)
1317         'End Function
1318
1319         '''' <summary>
1320         '''' Returns the size of an ulp of the argument.  An ulp, unit in
1321         '''' the last place, of a {@code double} value is the positive
1322         '''' distance between this floating-point value and the {@code
1323         '''' double} value next larger in magnitude.  Note that for non-NaN
1324         '''' _x_, <code>ulp(-_x_) == ulp(_x_)</code>.
1325         '''' 
1326         '''' Special Cases:
1327         '''' 
1328         '''' +  If the argument is NaN, then the result is NaN.
1329         '''' +  If the argument is positive or negative infinity, then the
1330         '''' result is positive infinity.
1331         '''' +  If the argument is positive or negative zero, then the result is
1332         '''' {@code java.lang.[Double].MIN_VALUE}.
1333         '''' +  If the argument is &plusmn;{@code java.lang.[Double].MAX_VALUE}, then
1334         '''' the result is equal to 2<sup>971</sup>.
1335         '''' 
1336         '''' </summary>
1337         '''' <param name="d"> the floating-point value whose ulp is to be returned </param>
1338         '''' <returns> the size of an ulp of the argument
1339         '''' @author Joseph D. Darcy
1340         '''' @since 1.5 </returns>
1341         'Public Function ulp(d As DoubleAs Double
1342         '    Dim exp As Integer = getExponent(d)
1343
1344         '    Select Case exp
1345         '        Case sun.misc.DoubleConsts.MAX_EXPONENT + 1 ' NaN or infinity
1346         '            Return sys.Abs(d)
1347
1348         '        Case sun.misc.DoubleConsts.MIN_EXPONENT - 1 ' zero or subnormal
1349         '            Return Java.lang.[Double].MIN_VALUE
1350
1351         '        Case Else
1352         '            Debug.Assert(exp <= sun.misc.DoubleConsts.MAX_EXPONENT AndAlso exp >= sun.misc.DoubleConsts.MIN_EXPONENT)
1353
1354         '            ' ulp(x) is usually 2^(SIGNIFICAND_WIDTH-1)*(2^ilogb(x))
1355         '            exp = exp - (sun.misc.DoubleConsts.SIGNIFICAND_WIDTH - 1)
1356         '            If exp >= sun.misc.DoubleConsts.MIN_EXPONENT Then
1357         '                Return powerOfTwoD(exp)
1358         '            Else
1359         '                ' return a subnormal result; left shift integer
1360         '                ' representation of java.lang.[Double].MIN_VALUE appropriate
1361         '                ' number of positions
1362         '                Return Java.lang.[Double].longBitsToDouble(1L << (exp - (sun.misc.DoubleConsts.MIN_EXPONENT - (sun.misc.DoubleConsts.SIGNIFICAND_WIDTH - 1))))
1363         '            End If
1364         '    End Select
1365         'End Function
1366
1367         '''' <summary>
1368         '''' Returns the size of an ulp of the argument.  An ulp, unit in
1369         '''' the last place, of a {@code float} value is the positive
1370         '''' distance between this floating-point value and the {@code
1371         '''' float} value next larger in magnitude.  Note that for non-NaN
1372         '''' _x_, <code>ulp(-_x_) == ulp(_x_)</code>.
1373         '''' 
1374         '''' Special Cases:
1375         '''' 
1376         '''' +  If the argument is NaN, then the result is NaN.
1377         '''' +  If the argument is positive or negative infinity, then the
1378         '''' result is positive infinity.
1379         '''' +  If the argument is positive or negative zero, then the result is
1380         '''' {@code Float.MIN_VALUE}.
1381         '''' +  If the argument is &plusmn;{@code Float.MAX_VALUE}, then
1382         '''' the result is equal to 2<sup>104</sup>.
1383         '''' 
1384         '''' </summary>
1385         '''' <param name="f"> the floating-point value whose ulp is to be returned </param>
1386         '''' <returns> the size of an ulp of the argument
1387         '''' @author Joseph D. Darcy
1388         '''' @since 1.5 </returns>
1389         'Public Function ulp(f As SingleAs Single
1390         '    Dim exp As Integer = getExponent(f)
1391
1392         '    Select Case exp
1393         '        Case sun.misc.FloatConsts.MAX_EXPONENT + 1 ' NaN or infinity
1394         '            Return sys.Abs(f)
1395
1396         '        Case sun.misc.FloatConsts.MIN_EXPONENT - 1 ' zero or subnormal
1397         '            Return sun.misc.FloatConsts.MIN_VALUE
1398
1399         '        Case Else
1400         '            Debug.Assert(exp <= sun.misc.FloatConsts.MAX_EXPONENT AndAlso exp >= sun.misc.FloatConsts.MIN_EXPONENT)
1401
1402         '            ' ulp(x) is usually 2^(SIGNIFICAND_WIDTH-1)*(2^ilogb(x))
1403         '            exp = exp - (sun.misc.FloatConsts.SIGNIFICAND_WIDTH - 1)
1404         '            If exp >= sun.misc.FloatConsts.MIN_EXPONENT Then
1405         '                Return powerOfTwoF(exp)
1406         '            Else
1407         '                ' return a subnormal result; left shift integer
1408         '                ' representation of FloatConsts.MIN_VALUE appropriate
1409         '                ' number of positions
1410         '                Return Float.intBitsToFloat(1 << (exp - (sun.misc.FloatConsts.MIN_EXPONENT - (sun.misc.FloatConsts.SIGNIFICAND_WIDTH - 1))))
1411         '            End If
1412         '    End Select
1413         'End Function
1414
1415         '''' <summary>
1416         '''' Returns the signum function of the argument; zero if the argument
1417         '''' is zero, 1.0 if the argument is greater than zero, -1.0 if the
1418         '''' argument is less than zero.
1419         '''' 
1420         '''' Special Cases:
1421         '''' 
1422         '''' +  If the argument is NaN, then the result is NaN.
1423         '''' +  If the argument is positive zero or negative zero, then the
1424         ''''      result is the same as the argument.
1425         '''' 
1426         '''' </summary>
1427         '''' <param name="d"> the floating-point value whose signum is to be returned </param>
1428         '''' <returns> the signum function of the argument
1429         '''' @author Joseph D. Darcy
1430         '''' @since 1.5 </returns>
1431         'Public Function signum(d As DoubleAs Double
1432         '    Return If(d = 0.0 OrElse [Double].IsNaN(d), d, copySign(1.0, d))
1433         'End Function
1434
1435         '''' <summary>
1436         '''' Returns the signum function of the argument; zero if the argument
1437         '''' is zero, 1.0f if the argument is greater than zero, -1.0f if the
1438         '''' argument is less than zero.
1439         '''' 
1440         '''' Special Cases:
1441         '''' 
1442         '''' +  If the argument is NaN, then the result is NaN.
1443         '''' +  If the argument is positive zero or negative zero, then the
1444         ''''      result is the same as the argument.
1445         '''' 
1446         '''' </summary>
1447         '''' <param name="f"> the floating-point value whose signum is to be returned </param>
1448         '''' <returns> the signum function of the argument
1449         '''' @author Joseph D. Darcy
1450         '''' @since 1.5 </returns>
1451         'Public Function signum(f As SingleAs Single
1452         '    Return If(f = 0.0F OrElse Single.IsNaN(f), f, copySign(1.0F, f))
1453         'End Function
1454
1455         ''' <summary>
1456         ''' Returns the hyperbolic sine of a {@code double} value.
1457         ''' The hyperbolic sine of _x_ is defined to be
1458         ''' (_e<sup>x</sup> - e<sup>-x</sup>_)/2
1459         ''' where _e_ is  Math#E Euler's number"/>.
1460         ''' 
1461         ''' Special cases:
1462         ''' 
1463         ''' 
1464         ''' + If the argument is NaN, then the result is NaN.
1465         ''' 
1466         ''' + If the argument is infinite, then the result is an infinity
1467         ''' with the same sign as the argument.
1468         ''' 
1469         ''' + If the argument is zero, then the result is a zero with the
1470         ''' same sign as the argument.
1471         ''' 
1472         ''' 
1473         ''' 
1474         ''' The computed result must be within 2.5 ulps of the exact result.
1475         ''' </summary>
1476         ''' <param name="x"> The number whose hyperbolic sine is to be returned. </param>
1477         ''' <returns>  The hyperbolic sine of {@code x}.
1478         ''' @since 1.5 </returns>
1479         Public Function sinh(x As DoubleAs Double
1480             Return sys.Sinh(x)
1481         End Function
1482
1483         ''' <summary>
1484         ''' Returns the hyperbolic cosine of a {@code double} value.
1485         ''' The hyperbolic cosine of _x_ is defined to be
1486         ''' (_e<sup>x</sup> + e<sup>-x</sup>_)/2
1487         ''' where _e_ is  Math#E Euler's number"/>.
1488         ''' 
1489         ''' Special cases:
1490         ''' 
1491         ''' 
1492         ''' + If the argument is NaN, then the result is NaN.
1493         ''' 
1494         ''' + If the argument is infinite, then the result is positive
1495         ''' infinity.
1496         ''' 
1497         ''' + If the argument is zero, then the result is {@code 1.0}.
1498         ''' 
1499         ''' 
1500         ''' 
1501         ''' The computed result must be within 2.5 ulps of the exact result.
1502         ''' </summary>
1503         ''' <param name="x"> The number whose hyperbolic cosine is to be returned. </param>
1504         ''' <returns>  The hyperbolic cosine of {@code x}.
1505         ''' @since 1.5 </returns>
1506         Public Function cosh(x As DoubleAs Double
1507             Return sys.Cosh(x)
1508         End Function
1509
1510         ''' <summary>
1511         ''' Returns the hyperbolic tangent of a {@code double} value.
1512         ''' The hyperbolic tangent of _x_ is defined to be
1513         ''' (_e<sup>x</sup> - e<sup>-x</sup>_)/(_e<sup>x</sup> + e<sup>-x</sup>_),
1514         ''' in other words, {@link Math#sinh
1515         ''' sinh(_x_)}/ Math#cosh cosh(_x_)"/>.  Note
1516         ''' that the absolute value of the exact tanh is always less than
1517         ''' 1.
1518         ''' 
1519         ''' Special cases:
1520         ''' 
1521         ''' 
1522         ''' + If the argument is NaN, then the result is NaN.
1523         ''' 
1524         ''' + If the argument is zero, then the result is a zero with the
1525         ''' same sign as the argument.
1526         ''' 
1527         ''' + If the argument is positive infinity, then the result is
1528         ''' {@code +1.0}.
1529         ''' 
1530         ''' + If the argument is negative infinity, then the result is
1531         ''' {@code -1.0}.
1532         ''' 
1533         ''' 
1534         ''' 
1535         ''' The computed result must be within 2.5 ulps of the exact result.
1536         ''' The result of {@code tanh} for any finite input must have
1537         ''' an absolute value less than or equal to 1.  Note that once the
1538         ''' exact result of tanh is within 1/2 of an ulp of the limit value
1539         ''' of 1, correctly signed {@code 1.0} should be returned.
1540         ''' </summary>
1541         ''' <param name="x"> The number whose hyperbolic tangent is to be returned. </param>
1542         ''' <returns>  The hyperbolic tangent of {@code x}.
1543         ''' @since 1.5 </returns>
1544         Public Function tanh(x As DoubleAs Double
1545             Return sys.Tanh(x)
1546         End Function
1547
1548         '''' <summary>
1549         '''' Returns sqrt(_x_<sup>2</sup> +_y_<sup>2</sup>)
1550         '''' without intermediate overflow or underflow.
1551         '''' 
1552         '''' Special cases:
1553         '''' 
1554         '''' 
1555         '''' +  If either argument is infinite, then the result
1556         '''' is positive infinity.
1557         '''' 
1558         '''' +  If either argument is NaN and neither argument is infinite,
1559         '''' then the result is NaN.
1560         '''' 
1561         '''' 
1562         '''' 
1563         '''' The computed result must be within 1 ulp of the exact
1564         '''' result.  If one parameter is held constant, the results must be
1565         '''' semi-monotonic in the other parameter.
1566         '''' </summary>
1567         '''' <param name="x"> a value </param>
1568         '''' <param name="y"> a value </param>
1569         '''' <returns> sqrt(_x_<sup>2</sup> +_y_<sup>2</sup>)
1570         '''' without intermediate overflow or underflow
1571         '''' @since 1.5 </returns>
1572         'Public Function hypot(x As Double, y As DoubleAs Double
1573         '    Return sys.hypot(x, y)
1574         'End Function
1575
1576         '''' <summary>
1577         '''' Returns _e_<sup>x</sup> -1.  Note that for values of
1578         '''' _x_ near 0, the exact sum of
1579         '''' {@code expm1(x)} + 1 is much closer to the true
1580         '''' result of _e_<sup>x</sup> than {@code exp(x)}.
1581         '''' 
1582         '''' Special cases:
1583         '''' 
1584         '''' + If the argument is NaN, the result is NaN.
1585         '''' 
1586         '''' + If the argument is positive infinity, then the result is
1587         '''' positive infinity.
1588         '''' 
1589         '''' + If the argument is negative infinity, then the result is
1590         '''' -1.0.
1591         '''' 
1592         '''' + If the argument is zero, then the result is a zero with the
1593         '''' same sign as the argument.
1594         '''' 
1595         '''' 
1596         '''' 
1597         '''' The computed result must be within 1 ulp of the exact result.
1598         '''' Results must be semi-monotonic.  The result of
1599         '''' {@code expm1} for any finite input must be greater than or
1600         '''' equal to {@code -1.0}.  Note that once the exact result of
1601         '''' _e_<sup>{@code x}</sup> - 1 is within 1/2
1602         '''' ulp of the limit value -1, {@code -1.0} should be
1603         '''' returned.
1604         '''' </summary>
1605         '''' <param name="x">   the exponent to raise _e_ to in the computation of
1606         ''''              _e_<sup>{@code x}</sup> -1. </param>
1607         '''' <returns>  the value _e_<sup>{@code x}</sup> - 1.
1608         '''' @since 1.5 </returns>
1609         'Public Function expm1(x As DoubleAs Double
1610         '    Return sys.expm1(x)
1611         'End Function
1612
1613         ''' <summary>
1614         ''' Returns the natural logarithm of the sum of the argument and 1.
1615         ''' Note that for small values {@code x}, the result of
1616         ''' {@code log1p(x)} is much closer to the true result of ln(1
1617         ''' + {@code x}) than the floating-point evaluation of
1618         ''' {@code log(1.0+x)}.
1619         ''' 
1620         ''' Special cases:
1621         ''' 
1622         ''' 
1623         ''' 
1624         ''' + If the argument is NaN or less than -1, then the result is
1625         ''' NaN.
1626         ''' 
1627         ''' + If the argument is positive infinity, then the result is
1628         ''' positive infinity.
1629         ''' 
1630         ''' + If the argument is negative one, then the result is
1631         ''' negative infinity.
1632         ''' 
1633         ''' + If the argument is zero, then the result is a zero with the
1634         ''' same sign as the argument.
1635         ''' 
1636         ''' 
1637         ''' 
1638         ''' The computed result must be within 1 ulp of the exact result.
1639         ''' Results must be semi-monotonic.
1640         ''' </summary>
1641         ''' <param name="x">   a value </param>
1642         ''' <returns> the value ln({@code x} + 1), the natural
1643         ''' log of {@code x} + 1
1644         ''' @since 1.5 </returns>
1645         ''' <remarks>http://www.johndcook.com/csharp_log_one_plus_x.html</remarks>
1646         Public Function log1p(x As DoubleAs Double
1647             If x <= -1.0 Then
1648                 Return [Double].NaN
1649             End If
1650
1651             If sys.Abs(x) > 0.0001 Then
1652                 Return sys.Log(1.0 + x)
1653             End If
1654
1655             ' Use Taylor approx. log(1 + x) = x - x^2/2 with error roughly x^3/3
1656             ' Since |x| < 10^-4, |x|^3 < 10^-12, relative error less than 10^-8
1657             Return (-0.5 * x + 1.0) * x
1658         End Function
1659
1660         ''' <summary>
1661         ''' Computes log(1-x) without losing precision for small values of x.
1662         ''' </summary>
1663         ''' 
1664         Public Function Log1m(x As DoubleAs Double
1665             If x >= 1.0 Then
1666                 Return [Double].NaN
1667             End If
1668
1669             If sys.Abs(x) > 0.0001 Then
1670                 Return sys.Log(1.0 - x)
1671             End If
1672
1673             ' Use Taylor approx. log(1 + x) = x - x^2/2 with error roughly x^3/3
1674             ' Since |x| < 10^-4, |x|^3 < 10^-12, relative error less than 10^-8
1675             Return -(0.5 * x + 1.0) * x
1676         End Function
1677
1678         '''' <summary>
1679         '''' Returns the first floating-point argument with the sign of the
1680         '''' second floating-point argument.  Note that unlike the {@link
1681         '''' StrictMath#copySign(double, double) StrictMath.copySign}
1682         '''' method, this method does not require NaN {@code sign}
1683         '''' arguments to be treated as positive values; implementations are
1684         '''' permitted to treat some NaN arguments as positive and other NaN
1685         '''' arguments as negative to allow greater performance.
1686         '''' </summary>
1687         '''' <param name="magnitude">  the parameter providing the magnitude of the result </param>
1688         '''' <param name="sign">   the parameter providing the sign of the result </param>
1689         '''' <returns> a value with the magnitude of {@code magnitude}
1690         '''' and the sign of {@code sign}.
1691         '''' @since 1.6 </returns>
1692         'Public Function copySign(magnitude As Double, sign As DoubleAs Double
1693         '    Return Java.lang.[Double].longBitsToDouble((Double.doubleToRawLongBits(sign) And (sun.misc.DoubleConsts.SIGN_BIT_MASK)) Or (Double.doubleToRawLongBits(magnitude) And (sun.misc.DoubleConsts.EXP_BIT_MASK Or sun.misc.DoubleConsts.SIGNIF_BIT_MASK)))
1694         'End Function
1695
1696         '''' <summary>
1697         '''' Returns the first floating-point argument with the sign of the
1698         '''' second floating-point argument.  Note that unlike the {@link
1699         '''' StrictMath#copySign(float, float) StrictMath.copySign}
1700         '''' method, this method does not require NaN {@code sign}
1701         '''' arguments to be treated as positive values; implementations are
1702         '''' permitted to treat some NaN arguments as positive and other NaN
1703         '''' arguments as negative to allow greater performance.
1704         '''' </summary>
1705         '''' <param name="magnitude">  the parameter providing the magnitude of the result </param>
1706         '''' <param name="sign">   the parameter providing the sign of the result </param>
1707         '''' <returns> a value with the magnitude of {@code magnitude}
1708         '''' and the sign of {@code sign}.
1709         '''' @since 1.6 </returns>
1710         'Public Function copySign(magnitude As Single, sign As SingleAs Single
1711         '    Return Float.intBitsToFloat((Float.floatToRawIntBits(sign) And (sun.misc.FloatConsts.SIGN_BIT_MASK)) Or (Float.floatToRawIntBits(magnitude) And (sun.misc.FloatConsts.EXP_BIT_MASK Or sun.misc.FloatConsts.SIGNIF_BIT_MASK)))
1712         'End Function
1713
1714         '''' <summary>
1715         '''' Returns the unbiased exponent used in the representation of a
1716         '''' {@code float}.  Special cases:
1717         '''' 
1718         '''' 
1719         '''' + If the argument is NaN or infinite, then the result is
1720         ''''  Float#MAX_EXPONENT"/> + 1.
1721         '''' + If the argument is zero or subnormal, then the result is
1722         ''''  Float#MIN_EXPONENT"/> -1.
1723         ''''  </summary>
1724         '''' <param name="f"> a {@code float} value </param>
1725         '''' <returns> the unbiased exponent of the argument
1726         '''' @since 1.6 </returns>
1727         'Public Function getExponent(f As SingleAs Integer
1728         '    '        
1729         '    '         * Bitwise convert f to integer, mask out exponent bits, shift
1730         '    '         * to the right and then subtract out float's bias adjust to
1731         '    '         * get true exponent value
1732         '    '         
1733         '    Return ((Float.floatToRawIntBits(f) And sun.misc.FloatConsts.EXP_BIT_MASK) >> (sun.misc.FloatConsts.SIGNIFICAND_WIDTH - 1)) - sun.misc.FloatConsts.EXP_BIAS
1734         'End Function
1735
1736         '''' <summary>
1737         '''' Returns the unbiased exponent used in the representation of a
1738         '''' {@code double}.  Special cases:
1739         '''' 
1740         '''' 
1741         '''' + If the argument is NaN or infinite, then the result is
1742         ''''  Double#MAX_EXPONENT"/> + 1.
1743         '''' + If the argument is zero or subnormal, then the result is
1744         ''''  Double#MIN_EXPONENT"/> -1.
1745         ''''  </summary>
1746         '''' <param name="d"> a {@code double} value </param>
1747         '''' <returns> the unbiased exponent of the argument
1748         '''' @since 1.6 </returns>
1749         'Public Function getExponent(d As DoubleAs Integer
1750         '    '        
1751         '    '         * Bitwise convert d to long, mask out exponent bits, shift
1752         '    '         * to the right and then subtract out double's bias adjust to
1753         '    '         * get true exponent value.
1754         '    '         
1755         '    Return CInt(Fix(((Double.doubleToRawLongBits(d) And sun.misc.DoubleConsts.EXP_BIT_MASK) >> (sun.misc.DoubleConsts.SIGNIFICAND_WIDTH - 1)) - sun.misc.DoubleConsts.EXP_BIAS))
1756         'End Function
1757
1758         '''' <summary>
1759         '''' Returns the floating-point number adjacent to the first
1760         '''' argument in the direction of the second argument.  If both
1761         '''' arguments compare as equal the second argument is returned.
1762         '''' 
1763         '''' 
1764         '''' Special cases:
1765         '''' 
1766         '''' +  If either argument is a NaN, then NaN is returned.
1767         '''' 
1768         '''' +  If both arguments are signed zeros, {@code direction}
1769         '''' is returned unchanged (as implied by the requirement of
1770         '''' returning the second argument if the arguments compare as
1771         '''' equal).
1772         '''' 
1773         '''' +  If {@code start} is
1774         '''' &plusmn; Double#MIN_VALUE"/> and {@code direction}
1775         '''' has a value such that the result should have a smaller
1776         '''' magnitude, then a zero with the same sign as {@code start}
1777         '''' is returned.
1778         '''' 
1779         '''' +  If {@code start} is infinite and
1780         '''' {@code direction} has a value such that the result should
1781         '''' have a smaller magnitude,  Double#MAX_VALUE"/> with the
1782         '''' same sign as {@code start} is returned.
1783         '''' 
1784         '''' +  If {@code start} is equal to &plusmn;
1785         ''''  Double#MAX_VALUE"/> and {@code direction} has a
1786         '''' value such that the result should have a larger magnitude, an
1787         '''' infinity with same sign as {@code start} is returned.
1788         '''' 
1789         '''' </summary>
1790         '''' <param name="start">  starting floating-point value </param>
1791         '''' <param name="direction"> value indicating which of
1792         '''' {@code start}'s neighbors or {@code start} should
1793         '''' be returned </param>
1794         '''' <returns> The floating-point number adjacent to {@code start} in the
1795         '''' direction of {@code direction}.
1796         '''' @since 1.6 </returns>
1797         'Public Function nextAfter(start As Double, direction As DoubleAs Double
1798         '    '        
1799         '    '         * The cases:
1800         '    '         *
1801         '    '         * nextAfter(+infinity, 0)  == MAX_VALUE
1802         '    '         * nextAfter(+infinity, +infinity)  == +infinity
1803         '    '         * nextAfter(-infinity, 0)  == -MAX_VALUE
1804         '    '         * nextAfter(-infinity, -infinity)  == -infinity
1805         '    '         *
1806         '    '         * are naturally handled without any additional testing
1807         '    '         
1808
1809         '    ' First check for NaN values
1810         '    If Java.lang.[Double].IsNaN(start) OrElse Java.lang.[Double].IsNaN(direction) Then
1811         '        ' return a NaN derived from the input NaN(s)
1812         '        Return start + direction
1813         '    ElseIf start = direction Then
1814         '        Return direction ' start > direction or start < direction
1815         '    Else
1816         '        ' Add +0.0 to get rid of a -0.0 (+0.0 + -0.0 => +0.0)
1817         '        ' then bitwise convert start to  java.lang.[Integer].
1818         '        Dim transducer As Long = Java.lang.[Double].doubleToRawLongBits(start + 0.0R)
1819
1820         '        '            
1821         '        '             * IEEE 754 floating-point numbers are lexicographically
1822         '        '             * ordered if treated as signed- magnitude integers .
1823         '        '             * Since Java's integers are two's complement,
1824         '        '             * incrementing" the two's complement representation of a
1825         '        '             * logically negative floating-point value *decrements*
1826         '        '             * the signed-magnitude representation. Therefore, when
1827         '        '             * the integer representation of a floating-point values
1828         '        '             * is less than zero, the adjustment to the representation
1829         '        '             * is in the opposite direction than would be expected at
1830         '        '             * first .
1831         '        '             
1832         '        If direction > start Then ' Calculate next greater value
1833         '            transducer = transducer + (If(transducer >= 0L, 1L, -1L)) ' Calculate next lesser value
1834         '        Else
1835         '            Debug.Assert(direction < start)
1836         '            If transducer > 0L Then
1837         '                transducer -= 1
1838         '            Else
1839         '                If transducer < 0L Then
1840         '                    transducer += 1
1841         '                    '                    
1842         '                    '                     * transducer==0, the result is -MIN_VALUE
1843         '                    '                     *
1844         '                    '                     * The transition from zero (implicitly
1845         '                    '                     * positive) to the smallest negative
1846         '                    '                     * signed magnitude value must be done
1847         '                    '                     * explicitly.
1848         '                    '                     
1849         '                Else
1850         '                    transducer = sun.misc.DoubleConsts.SIGN_BIT_MASK Or 1L
1851         '                End If
1852         '            End If
1853         '        End If
1854
1855         '        Return Java.lang.[Double].longBitsToDouble(transducer)
1856         '    End If
1857         'End Function
1858
1859         '<span class="xml_comment">''' <summary></span>
1860         <span class="xml_comment">'''' Returns the floating-point number adjacent to the first</span>
1861         <span class="xml_comment">'''' argument in the direction of the second argument.  If both</span>
1862         <span class="xml_comment">'''' arguments compare as equal a value equivalent to the second argument</span>
1863         <span class="xml_comment">'''' is returned.</span>
1864         '<span class="xml_comment">''' </span>
1865         '<span class="xml_comment">''' </span>
1866         '<span class="xml_comment">''' Special cases:</span>
1867         '<span class="xml_comment">''' </span>
1868         <span class="xml_comment">'''' +  If either argument is a NaN, then NaN is returned.</span>
1869         '<span class="xml_comment">''' </span>
1870         <span class="xml_comment">'''' +  If both arguments are signed zeros, a value equivalent</span>
1871         <span class="xml_comment">'''' to {@code direction} is returned.</span>
1872         '<span class="xml_comment">''' </span>
1873         <span class="xml_comment">'''' +  If {@code start} is</span>
1874         <span class="xml_comment">'''' &plusmn; Float#MIN_VALUE"/> and {@code direction}</span>
1875         <span class="xml_comment">'''' has a value such that the result should have a smaller</span>
1876         <span class="xml_comment">'''' magnitude, then a zero with the same sign as {@code start}</span>
1877         <span class="xml_comment">'''' is returned.</span>
1878         '<span class="xml_comment">''' </span>
1879         <span class="xml_comment">'''' +  If {@code start} is infinite and</span>
1880         <span class="xml_comment">'''' {@code direction} has a value such that the result should</span>
1881         <span class="xml_comment">'''' have a smaller magnitude,  Float#MAX_VALUE"/> with the</span>
1882         <span class="xml_comment">'''' same sign as {@code start} is returned.</span>
1883         '<span class="xml_comment">''' </span>
1884         <span class="xml_comment">'''' +  If {@code start} is equal to &plusmn;</span>
1885         <span class="xml_comment">''''  Float#MAX_VALUE"/> and {@code direction} has a</span>
1886         <span class="xml_comment">'''' value such that the result should have a larger magnitude, an</span>
1887         <span class="xml_comment">'''' infinity with same sign as {@code start} is returned.</span>
1888         '<span class="xml_comment">''' </span>
1889         '<span class="xml_comment">''' </summary></span>
1890         <span class="xml_comment">'''' <param name="start">  starting floating-point value </param></span>
1891         <span class="xml_comment">'''' <param name="direction"> value indicating which of</span>
1892         <span class="xml_comment">'''' {@code start}'s neighbors or {@code start} should</span>
1893         <span class="xml_comment">'''' be returned </param></span>
1894         <span class="xml_comment">'''' <returns> The floating-point number adjacent to {@code start} in the</span>
1895         <span class="xml_comment">'''' direction of {@code direction}.</span>
1896         <span class="xml_comment">'''' @since 1.6 </returns></span>
1897         'Public Function nextAfter(start As Single, direction As DoubleAs Single
1898         '    '        
1899         '    '         * The cases:
1900         '    '         *
1901         '    '         * nextAfter(+infinity, 0)  == MAX_VALUE
1902         '    '         * nextAfter(+infinity, +infinity)  == +infinity
1903         '    '         * nextAfter(-infinity, 0)  == -MAX_VALUE
1904         '    '         * nextAfter(-infinity, -infinity)  == -infinity
1905         '    '         *
1906         '    '         * are naturally handled without any additional testing
1907         '    '         
1908
1909         '    ' First check for NaN values
1910         '    If Float.IsNaN(start) OrElse Java.lang.[Double].IsNaN(direction) Then
1911         '        ' return a NaN derived from the input NaN(s)
1912         '        Return start + CSng(direction)
1913         '    ElseIf start = direction Then
1914         '        Return CSng(direction) ' start > direction or start < direction
1915         '    Else
1916         '        ' Add +0.0 to get rid of a -0.0 (+0.0 + -0.0 => +0.0)
1917         '        ' then bitwise convert start to  java.lang.[Integer].
1918         '        Dim transducer As Integer = Float.floatToRawIntBits(start + 0.0F)
1919
1920         '        '            
1921         '        '             * IEEE 754 floating-point numbers are lexicographically
1922         '        '             * ordered if treated as signed- magnitude integers .
1923         '        '             * Since Java's integers are two's complement,
1924         '        '             * incrementing" the two's complement representation of a
1925         '        '             * logically negative floating-point value *decrements*
1926         '        '             * the signed-magnitude representation. Therefore, when
1927         '        '             * the integer representation of a floating-point values
1928         '        '             * is less than zero, the adjustment to the representation
1929         '        '             * is in the opposite direction than would be expected at
1930         '        '             * first.
1931         '        '             
1932         '        If direction > start Then ' Calculate next greater value
1933         '            transducer = transducer + (If(transducer >= 0, 1, -1)) ' Calculate next lesser value
1934         '        Else
1935         '            Debug.Assert(direction < start)
1936         '            If transducer > 0 Then
1937         '                transducer -= 1
1938         '            Else
1939         '                If transducer < 0 Then
1940         '                    transducer += 1
1941         '                    '                    
1942         '                    '                     * transducer==0, the result is -MIN_VALUE
1943         '                    '                     *
1944         '                    '                     * The transition from zero (implicitly
1945         '                    '                     * positive) to the smallest negative
1946         '                    '                     * signed magnitude value must be done
1947         '                    '                     * explicitly.
1948         '                    '                     
1949         '                Else
1950         '                    transducer = sun.misc.FloatConsts.SIGN_BIT_MASK Or 1
1951         '                End If
1952         '            End If
1953         '        End If
1954
1955         '        Return Float.intBitsToFloat(transducer)
1956         '    End If
1957         'End Function
1958
1959         '''' <summary>
1960         '''' Returns the floating-point value adjacent to {@code d} in
1961         '''' the direction of positive infinity.  This method is
1962         '''' semantically equivalent to {@code nextAfter(d,
1963         '''' java.lang.[Double].POSITIVE_INFINITY)}; however, a {@code nextUp}
1964         '''' implementation may run faster than its equivalent
1965         '''' {@code nextAfter} call.
1966         '''' 
1967         '''' Special Cases:
1968         '''' 
1969         '''' +  If the argument is NaN, the result is NaN.
1970         '''' 
1971         '''' +  If the argument is positive infinity, the result is
1972         '''' positive infinity.
1973         '''' 
1974         '''' +  If the argument is zero, the result is
1975         ''''  Double#MIN_VALUE"/>
1976         '''' 
1977         '''' 
1978         '''' </summary>
1979         '''' <param name="d"> starting floating-point value </param>
1980         '''' <returns> The adjacent floating-point value closer to positive
1981         '''' infinity.
1982         '''' @since 1.6 </returns>
1983         'Public Function nextUp(d As DoubleAs Double
1984         '    If Java.lang.[Double].IsNaN(d) OrElse d = Java.lang.[Double].PositiveInfinity Then
1985         '        Return d
1986         '    Else
1987         '        d += 0.0R
1988         '        Return Java.lang.[Double].longBitsToDouble(Double.doubleToRawLongBits(d) + (If(d >= 0.0R, +1L, -1L)))
1989         '    End If
1990         'End Function
1991
1992         '''' <summary>
1993         '''' Returns the floating-point value adjacent to {@code f} in
1994         '''' the direction of positive infinity.  This method is
1995         '''' semantically equivalent to {@code nextAfter(f,
1996         '''' Float.POSITIVE_INFINITY)}; however, a {@code nextUp}
1997         '''' implementation may run faster than its equivalent
1998         '''' {@code nextAfter} call.
1999         '''' 
2000         '''' Special Cases:
2001         '''' 
2002         '''' +  If the argument is NaN, the result is NaN.
2003         '''' 
2004         '''' +  If the argument is positive infinity, the result is
2005         '''' positive infinity.
2006         '''' 
2007         '''' +  If the argument is zero, the result is
2008         ''''  Float#MIN_VALUE"/>
2009         '''' 
2010         '''' 
2011         '''' </summary>
2012         '''' <param name="f"> starting floating-point value </param>
2013         '''' <returns> The adjacent floating-point value closer to positive
2014         '''' infinity.
2015         '''' @since 1.6 </returns>
2016         'Public Function nextUp(f As SingleAs Single
2017         '    If Float.IsNaN(f) OrElse f = sun.misc.FloatConsts.POSITIVE_INFINITY Then
2018         '        Return f
2019         '    Else
2020         '        f += 0.0F
2021         '        Return Float.intBitsToFloat(Float.floatToRawIntBits(f) + (If(f >= 0.0F, +1, -1)))
2022         '    End If
2023         'End Function
2024
2025         '''' <summary>
2026         '''' Returns the floating-point value adjacent to {@code d} in
2027         '''' the direction of negative infinity.  This method is
2028         '''' semantically equivalent to {@code nextAfter(d,
2029         '''' java.lang.[Double].NEGATIVE_INFINITY)}; however, a
2030         '''' {@code nextDown} implementation may run faster than its
2031         '''' equivalent {@code nextAfter} call.
2032         '''' 
2033         '''' Special Cases:
2034         '''' 
2035         '''' +  If the argument is NaN, the result is NaN.
2036         '''' 
2037         '''' +  If the argument is negative infinity, the result is
2038         '''' negative infinity.
2039         '''' 
2040         '''' +  If the argument is zero, the result is
2041         '''' {@code -Double.MIN_VALUE}
2042         '''' 
2043         '''' 
2044         '''' </summary>
2045         '''' <param name="d">  starting floating-point value </param>
2046         '''' <returns> The adjacent floating-point value closer to negative
2047         '''' infinity.
2048         '''' @since 1.8 </returns>
2049         'Public Function nextDown(d As DoubleAs Double
2050         '    If Java.lang.[Double].IsNaN(d) OrElse d = Java.lang.[Double].NegativeInfinity Then
2051         '        Return d
2052         '    Else
2053         '        If d = 0.0 Then
2054         '            Return -Double.MIN_VALUE
2055         '        Else
2056         '            Return Java.lang.[Double].longBitsToDouble(Double.doubleToRawLongBits(d) + (If(d > 0.0R, -1L, +1L)))
2057         '        End If
2058         '    End If
2059         'End Function
2060
2061         '''' <summary>
2062         '''' Returns the floating-point value adjacent to {@code f} in
2063         '''' the direction of negative infinity.  This method is
2064         '''' semantically equivalent to {@code nextAfter(f,
2065         '''' Float.NEGATIVE_INFINITY)}; however, a
2066         '''' {@code nextDown} implementation may run faster than its
2067         '''' equivalent {@code nextAfter} call.
2068         '''' 
2069         '''' Special Cases:
2070         '''' 
2071         '''' +  If the argument is NaN, the result is NaN.
2072         '''' 
2073         '''' +  If the argument is negative infinity, the result is
2074         '''' negative infinity.
2075         '''' 
2076         '''' +  If the argument is zero, the result is
2077         '''' {@code -Float.MIN_VALUE}
2078         '''' 
2079         '''' 
2080         '''' </summary>
2081         '''' <param name="f">  starting floating-point value </param>
2082         '''' <returns> The adjacent floating-point value closer to negative
2083         '''' infinity.
2084         '''' @since 1.8 </returns>
2085         'Public Function nextDown(f As SingleAs Single
2086         '    If Float.IsNaN(f) OrElse f = Float.NegativeInfinity Then
2087         '        Return f
2088         '    Else
2089         '        If f = 0.0F Then
2090         '            Return -Float.MIN_VALUE
2091         '        Else
2092         '            Return Float.intBitsToFloat(Float.floatToRawIntBits(f) + (If(f > 0.0F, -1, +1)))
2093         '        End If
2094         '    End If
2095         'End Function
2096
2097         '''' <summary>
2098         '''' Returns {@code d} &times;
2099         '''' 2<sup>{@code scaleFactor}</sup> rounded as if performed
2100         '''' by a single correctly rounded floating-point multiply to a
2101         '''' member of the double value set.  See the Java
2102         '''' Language Specification for a discussion of floating-point
2103         '''' value sets.  If the exponent of the result is between {@link
2104         '''' Double#MIN_EXPONENT} and  Double#MAX_EXPONENT"/>, the
2105         '''' answer is calculated exactly.  If the exponent of the result
2106         '''' would be larger than {@code java.lang.[Double].MAX_EXPONENT}, an
2107         '''' infinity is returned.  Note that if the result is subnormal,
2108         '''' precision may be lost; that is, when {@code scalb(x, n)}
2109         '''' is subnormal, {@code scalb(scalb(x, n), -n)} may not equal
2110         '''' _x_.  When the result is non-NaN, the result has the same
2111         '''' sign as {@code d}.
2112         '''' 
2113         '''' Special cases:
2114         '''' 
2115         '''' +  If the first argument is NaN, NaN is returned.
2116         '''' +  If the first argument is infinite, then an infinity of the
2117         '''' same sign is returned.
2118         '''' +  If the first argument is zero, then a zero of the same
2119         '''' sign is returned.
2120         '''' 
2121         '''' </summary>
2122         '''' <param name="d"> number to be scaled by a power of two. </param>
2123         '''' <param name="scaleFactor"> power of 2 used to scale {@code d} </param>
2124         '''' <returns> {@code d} &times; 2<sup>{@code scaleFactor}</sup>
2125         '''' @since 1.6 </returns>
2126         'Public Function scalb(d As Double, scaleFactor As IntegerAs Double
2127         '    '        
2128         '    '         * This method does not need to be declared strictfp to
2129         '    '         * compute the same correct result on all platforms.  When
2130         '    '         * scaling up, it does not matter what order the
2131         '    '         * multiply-store operations are done; the result will be
2132         '    '         * finite or overflow regardless of the operation ordering.
2133         '    '         * However, to get the correct result when scaling down, a
2134         '    '         * particular ordering must be used.
2135         '    '         *
2136         '    '         * When scaling down, the multiply-store operations are
2137         '    '         * sequenced so that it is not possible for two consecutive
2138         '    '         * multiply-stores to return subnormal results.  If one
2139         '    '         * multiply-store result is subnormal, the next multiply will
2140         '    '         * round it away to zero.  This is done by first multiplying
2141         '    '         * by 2 ^ (scaleFactor % n) and then multiplying several
2142         '    '         * times by by 2^n as needed where n is the exponent of number
2143         '    '         * that is a covenient power of two.  In this way, at most one
2144         '    '         * real rounding error occurs.  If the double value set is
2145         '    '         * being used exclusively, the rounding will occur on a
2146         '    '         * multiply.  If the double-extended-exponent value set is
2147         '    '         * being used, the products will (perhaps) be exact but the
2148         '    '         * stores to d are guaranteed to round to the double value
2149         '    '         * set.
2150         '    '         *
2151         '    '         * It is _not_ a valid implementation to first multiply d by
2152         '    '         * 2^MIN_EXPONENT and then by 2 ^ (scaleFactor %
2153         '    '         * MIN_EXPONENT) since even in a strictfp program double
2154         '    '         * rounding on underflow could occur; e.g. if the scaleFactor
2155         '    '         * argument was (MIN_EXPONENT - n) and the exponent of d was a
2156         '    '         * little less than -(MIN_EXPONENT - n), meaning the final
2157         '    '         * result would be subnormal.
2158         '    '         *
2159         '    '         * Since exact reproducibility of this method can be achieved
2160         '    '         * without any undue performance burden, there is no
2161         '    '         * compelling reason to allow double rounding on underflow in
2162         '    '         * scalb.
2163         '    '         
2164
2165         '    ' magnitude of a power of two so large that scaling a finite
2166         '    ' nonzero value by it would be guaranteed to over or
2167         '    ' underflow; due to rounding, scaling down takes takes an
2168         '    ' additional power of two which is reflected here
2169         '    Dim MAX_SCALE As Integer = sun.misc.DoubleConsts.MAX_EXPONENT + -sun.misc.DoubleConsts.MIN_EXPONENT + sun.misc.DoubleConsts.SIGNIFICAND_WIDTH + 1
2170         '    Dim exp_adjust As Integer = 0
2171         '    Dim scale_increment As Integer = 0
2172         '    Dim exp_delta As Double = Java.lang.[Double].NaN
2173
2174         '    ' Make sure scaling factor is in a reasonable range
2175
2176         '    If scaleFactor < 0 Then
2177         '        scaleFactor = sys.Max(scaleFactor, -MAX_SCALE)
2178         '        scale_increment = -512
2179         '        exp_delta = twoToTheDoubleScaleDown
2180         '    Else
2181         '        scaleFactor = sys.Min(scaleFactor, MAX_SCALE)
2182         '        scale_increment = 512
2183         '        exp_delta = twoToTheDoubleScaleUp
2184         '    End If
2185
2186         '    ' Calculate (scaleFactor % +/-512), 512 = 2^9, using
2187         '    ' technique from "Hacker's Delight" section 10-2.
2188         '    Dim t As Integer = CInt(CUInt((scaleFactor >> 9 - 1)) >> 32 - 9)
2189         '    exp_adjust = ((scaleFactor + t) And (512 - 1)) - t
2190
2191         '    d *= powerOfTwoD(exp_adjust)
2192         '    scaleFactor -= exp_adjust
2193
2194         '    Do While scaleFactor <> 0
2195         '        d *= exp_delta
2196         '        scaleFactor -= scale_increment
2197         '    Loop
2198         '    Return d
2199         'End Function
2200
2201         '''' <summary>
2202         '''' Returns {@code f} &times;
2203         '''' 2<sup>{@code scaleFactor}</sup> rounded as if performed
2204         '''' by a single correctly rounded floating-point multiply to a
2205         '''' member of the float value set.  See the Java
2206         '''' Language Specification for a discussion of floating-point
2207         '''' value sets.  If the exponent of the result is between {@link
2208         '''' Float#MIN_EXPONENT} and  Float#MAX_EXPONENT"/>, the
2209         '''' answer is calculated exactly.  If the exponent of the result
2210         '''' would be larger than {@code Float.MAX_EXPONENT}, an
2211         '''' infinity is returned.  Note that if the result is subnormal,
2212         '''' precision may be lost; that is, when {@code scalb(x, n)}
2213         '''' is subnormal, {@code scalb(scalb(x, n), -n)} may not equal
2214         '''' _x_.  When the result is non-NaN, the result has the same
2215         '''' sign as {@code f}.
2216         '''' 
2217         '''' Special cases:
2218         '''' 
2219         '''' +  If the first argument is NaN, NaN is returned.
2220         '''' +  If the first argument is infinite, then an infinity of the
2221         '''' same sign is returned.
2222         '''' +  If the first argument is zero, then a zero of the same
2223         '''' sign is returned.
2224         '''' 
2225         '''' </summary>
2226         '''' <param name="f"> number to be scaled by a power of two. </param>
2227         '''' <param name="scaleFactor"> power of 2 used to scale {@code f} </param>
2228         '''' <returns> {@code f} &times; 2<sup>{@code scaleFactor}</sup>
2229         '''' @since 1.6 </returns>
2230         'Public Function scalb(f As Single, scaleFactor As IntegerAs Single
2231         '    ' magnitude of a power of two so large that scaling a finite
2232         '    ' nonzero value by it would be guaranteed to over or
2233         '    ' underflow; due to rounding, scaling down takes takes an
2234         '    ' additional power of two which is reflected here
2235         '    Dim MAX_SCALE As Integer = sun.misc.FloatConsts.MAX_EXPONENT + -sun.misc.FloatConsts.MIN_EXPONENT + sun.misc.FloatConsts.SIGNIFICAND_WIDTH + 1
2236
2237         '    ' Make sure scaling factor is in a reasonable range
2238         '    scaleFactor = sys.Max(System.Math.Min(scaleFactor, MAX_SCALE), -MAX_SCALE)
2239
2240         '    '        
2241         '    '         * Since + MAX_SCALE for float fits well within the double
2242         '    '         * exponent range and + float -> double conversion is exact
2243         '    '         * the multiplication below will be exact. Therefore, the
2244         '    '         * rounding that occurs when the double product is cast to
2245         '    '         * float will be the correctly rounded float result.  Since
2246         '    '         * all operations other than the final multiply will be exact,
2247         '    '         * it is not necessary to declare this method strictfp.
2248         '    '         
2249         '    Return CSng(CDbl(f) * powerOfTwoD(scaleFactor))
2250         'End Function
2251
2252         'Constants used in scalb
2253         'Friend twoToTheDoubleScaleUp As Double = powerOfTwoD(512)
2254         'Friend twoToTheDoubleScaleDown As Double = powerOfTwoD(-512)
2255
2256         '''' <summary>
2257         '''' Returns a floating-point power of two in the normal range.
2258         '''' </summary>
2259         'Friend Function powerOfTwoD(n As IntegerAs Double
2260         '    Assert(n >= sun.misc.DoubleConsts.MIN_EXPONENT AndAlso n <= sun.misc.DoubleConsts.MAX_EXPONENT)
2261         '    Return java.lang.[Double].longBitsToDouble(((CLng(n) + CLng(Fix(sun.misc.DoubleConsts.EXP_BIAS))) << (sun.misc.DoubleConsts.SIGNIFICAND_WIDTH - 1)) And sun.misc.DoubleConsts.EXP_BIT_MASK)
2262         'End Function
2263
2264         '''' <summary>
2265         '''' Returns a floating-point power of two in the normal range.
2266         '''' </summary>
2267         'Friend Function powerOfTwoF(n As IntegerAs Single
2268         '    Assert(n >= sun.misc.FloatConsts.MIN_EXPONENT AndAlso n <= sun.misc.FloatConsts.MAX_EXPONENT)
2269         '    Return Float.intBitsToFloat(((n + sun.misc.FloatConsts.EXP_BIAS) << (sun.misc.FloatConsts.SIGNIFICAND_WIDTH - 1)) And sun.misc.FloatConsts.EXP_BIT_MASK)
2270         'End Function
2271     End Module
2272 End Namespace