Java Math ulp（）方法及其示例-yiteyi-C++库

这个 JAVA朗，数学。ulp（） 是一个内置的java方法，返回参数的ulp大小。ulp代表精度最低的单位。它计算给定的双精度或浮点值与双倍或浮点值，数值再大一点。参数可以有两种类型：

null

ulp（浮动f）： 它接受浮点类型的输入。
ulp（双d）： 它需要双重类型的输入。

注：

如果参数为NaN，则输出为NaN。
如果参数为正、负双精度或浮点值，则ulp（-arg）和ulp（arg）的输出相同。
如果参数为正或负零，则输出将加倍。最小值或浮动。最小值。
如果参数为正无穷大或负无穷大，则输出为正无穷大。
如果参数是正的或负的，则为双精度。最大值或浮动。最大值，输出为2 ⁹⁷¹ 对于双重类型和2 ¹⁰⁴ 对于浮动类型。

语法：

public static dataType ulp(dataType g)
Parameter :
 g: argument whose ulp is to be returned.
Return :
This method returns the size of an ulp of the argument.

例子： 表示工作 JAVA朗，数学。ulp（） 方法

                     // Java program to demonstrate working                   
                     // of java.lang.Math.ulp() method                   
                     import                               java.lang.Math;                   
                             
                     class                               Gfg {                   
                             
                                         // driver code                   
                                         public                               static                               void                               main(String args[])                   
                                         {                   
                                         double                               a =                               34.543                               ;                   
                             
                                         // Input positive double value                   
                                         // Output ulp(a)                   
                                         System.out.println(Math.ulp(a));                   
                             
                                         // Input negative double value                   
                                         // Output ulp(-a)==ulp(a)                   
                                         System.out.println(Math.ulp(-a));                   
                             
                                         double                               b =                               0.0                               /                               0                               ;                   
                             
                                         // Input NaN, Output Nan                   
                                         System.out.println(Math.ulp(b));                   
                             
                                         float                               c = -                               0                               .0f;                   
                             
                                         // Input negative zero                   
                                         // Output  Float.MIN_VALUE.                   
                                         System.out.println(Math.ulp(c));                   
                             
                                         float                               d = -                               1                               .0f /                               0                               ;                   
                             
                                         // Input negative infinity                   
                                         // Output  positive infinity.                   
                                         System.out.println(Math.ulp(d));                   
                             
                                         double                               e = Double.MAX_VALUE;                   
                             
                                         System.out.println(Math.ulp(e));                   
                                         }                   
                     }                   

输出：

7.105427357601002E-15
7.105427357601002E-15
NaN
1.4E-45
Infinity
1.9958403095347198E292

文章版权归作者所有，未经允许请勿转载。

THE END

Java