strictmath.html

来自「j2se5-api-zh,java文档的中文版本」· HTML 代码 · 共 1,539 行 · 第 1/5 页

<li>如果
 <ul>
<li>如果第一个参数是负零，并且第二个参数大于零但不是有限的奇数整数，或者
<li>第一个参数是负无穷大，并且第二个参数小于零但不是有限的奇数整数，
 </ul>
那么结果是正零。

<li>如果
 <ul>
<li>第一个参数是负零，并且第二个参数是正的有限奇数整数，或者
<li>第一个参数是负无穷大，并且第二个参数是负的有限奇数整数，
 </ul>
那么结果是负零。

<li>如果
 <ul>
<li>如果第一个参数是负零，并且第二个参数小于零但不是有限的奇数整数，或者
<li>第一个参数是负无穷大，并且第二个参数大于零但不是有限的奇数整数，
 </ul>
那么结果是正无穷大。

<li>如果
 <ul>
<li>第一个参数是负零，并且第二个参数是负的有限奇数整数，或者
<li>第一个参数是负无穷大，并且第二个参数是正的有限奇数整数，
 </ul>
那么结果是负无穷大。

<li>如果第一个参数是小于零的有限值，
 <ul>
<li> 并且第二个参数是有限的偶数整数，那么结果等于第一个参数的绝对值的第二个参数次幂的结果。

<li>如果第二个参数是有限的奇数整数，那么结果等于第一个参数绝对值的第二个参数次幂的结果的负数。

<li>如果第二个参数是有限的非整数值，那么结果是 NaN。
 </ul>

<li>如果两个参数都是整数，并且结果可以表示为 <code>double</code> 值，那么该结果恰好等于第一个参数的第二个参数次幂的算术结果。</ul>
 
<p>（在前面的描述中，当且仅当浮点数为有限值并且是方法 <A HREF="StrictMath.html#ceil(double)"><CODE><tt>ceil</tt></CODE></A> 的定点数，或者是方法 <A HREF="StrictMath.html#floor(double)"><CODE><tt>floor</tt></CODE></A> 的定点数时，才可以认为浮点值是整数。当且仅当将方法应用到值的结果等于该值时，该值才是带有一个参数的方法的定点值。）
<P>
<DD><DL>
<DT><B>参数：</B><DD><CODE>a</CODE> - 底数。<DD><CODE>b</CODE> - 指数。
<DT><B>返回：</B><DD>值 <code>a<sup>b</sup></code>。</DL>
</DD>
</DL>
<HR>

<A NAME="round(float)"><!-- --></A><H3>
round</H3>
<PRE>
public static int <B>round</B>(float&nbsp;a)</PRE>
<DL>
<DD>返回最接近参数的 <code>int</code>。通过加上 1/2 将该结果舍入为整数，取结果的基数并强制转换为 <code>int</code> 类型。换句话说，结果等于以下表达式的值：
 <p><pre>(int)Math.floor(a + 0.5f)</pre>
 <p>
特殊情况是：
<ul><li>如果参数是 NaN，那么结果是 0。
<li>如果参数是负无穷大或任何小于或等于 <code>Integer.MIN_VALUE</code> 的值，那么结果等于 <code>Integer.MIN_VALUE</code> 的值。
<li>如果参数是正无穷大或任何大于或等于 <code>Integer.MAX_VALUE</code> 的值，那么结果等于 <code>Integer.MAX_VALUE</code> 的值。</ul>
<P>
<DD><DL>
<DT><B>参数：</B><DD><CODE>a</CODE> - 要舍入为整数的浮点值。
<DT><B>返回：</B><DD>舍入为最接近的 <code>int</code> 值的参数值。<DT><B>另请参见：</B><DD><A HREF="Integer.html#MAX_VALUE"><CODE>Integer.MAX_VALUE</CODE></A>, 
<A HREF="Integer.html#MIN_VALUE"><CODE>Integer.MIN_VALUE</CODE></A></DL>
</DD>
</DL>
<HR>

<A NAME="round(double)"><!-- --></A><H3>
round</H3>
<PRE>
public static long <B>round</B>(double&nbsp;a)</PRE>
<DL>
<DD>返回最接近参数的 <code>long</code>。通过加上 1/2 将该结果舍入为整数，取结果的基数并强制转换为 <code>long</code> 类型。换句话说，结果等于以下表达式的值：
 <p><pre>(long)Math.floor(a + 0.5d)</pre>
 <p>
特殊情况是：
<ul><li>如果参数是 NaN，那么结果是 0。
<li>如果参数是负无穷大或任何小于或等于 <code>Long.MIN_VALUE</code> 的值，那么结果等于 <code>Long.MIN_VALUE</code> 的值。 
<li>如果参数是正无穷大或任何大于或等于 <code>Long.MAX_VALUE</code> 的值，那么结果等于 <code>Long.MAX_VALUE</code> 的值。</ul>
<P>
<DD><DL>
<DT><B>参数：</B><DD><CODE>a</CODE> - 舍入为 <code>long</code> 的浮点值。
<DT><B>返回：</B><DD>舍入为最接近的 <code>long</code> 值的参数值。<DT><B>另请参见：</B><DD><A HREF="Long.html#MAX_VALUE"><CODE>Long.MAX_VALUE</CODE></A>, 
<A HREF="Long.html#MIN_VALUE"><CODE>Long.MIN_VALUE</CODE></A></DL>
</DD>
</DL>
<HR>

<A NAME="random()"><!-- --></A><H3>
random</H3>
<PRE>
public static double <B>random</B>()</PRE>
<DL>
<DD>返回带有正号的 <code>double</code> 值，大于或等于 <code>0.0</code>，小于 <code>1.0</code>。返回值是一个伪随机选择的数，在上述范围内（大致）均匀分布。 
 
<p>第一次调用该方法时，它将创建一个新的伪随机数生成器，正如通过表达式
<blockquote><pre>new java.util.Random</pre></blockquote> 一样。之后，该新的伪随机数生成器可用于针对该方法的所有调用，但不能在其他地方使用。
 
<p>在经过适当同步后，允许多个线程正确地使用该方法。然而，如果很多线程需要以极高的速率生成伪随机数，那么这可能会减少每个线程对拥有自己的伪随机数生成器的争用。
<P>
<DD><DL>

<DT><B>返回：</B><DD>大于等于 <code>0.0</code> 但小于 <code>1.0</code> 的伪随机 <code>double</code> 数。<DT><B>另请参见：</B><DD><A HREF="../util/Random.html#nextDouble()"><CODE>Random.nextDouble()</CODE></A></DL>
</DD>
</DL>
<HR>

<A NAME="abs(int)"><!-- --></A><H3>
abs</H3>
<PRE>
public static int <B>abs</B>(int&nbsp;a)</PRE>
<DL>
<DD>返回 <code>int</code> 值的绝对值。如果参数不是负数，则返回该参数。如果参数是负数，则返回该参数的相反数。
 
<p>注意，如果参数等于 <code>Integer.MIN_VALUE</code> 的值，即能够表示的最小负 <code>int</code> 值，则结果与该值相同且为负。
<P>
<DD><DL>
<DT><B>参数：</B><DD><CODE>a</CODE> - 要确定绝对值的参数。
<DT><B>返回：</B><DD>参数的绝对值。<DT><B>另请参见：</B><DD><A HREF="Integer.html#MIN_VALUE"><CODE>Integer.MIN_VALUE</CODE></A></DL>
</DD>
</DL>
<HR>

<A NAME="abs(long)"><!-- --></A><H3>
abs</H3>
<PRE>
public static long <B>abs</B>(long&nbsp;a)</PRE>
<DL>
<DD>返回 <code>long</code> 值的绝对值。如果参数不是负数，则返回该参数。如果参数是负数，则返回该参数的相反数。
 
<p>注意，如果参数等于 <code>Long.MIN_VALUE</code> 的值，即能够表示的最小负 <code>long</code> 值，则结果与该值相同且为负。
<P>
<DD><DL>
<DT><B>参数：</B><DD><CODE>a</CODE> - 要确定绝对值的参数。
<DT><B>返回：</B><DD>参数的绝对值。<DT><B>另请参见：</B><DD><A HREF="Long.html#MIN_VALUE"><CODE>Long.MIN_VALUE</CODE></A></DL>
</DD>
</DL>
<HR>

<A NAME="abs(float)"><!-- --></A><H3>
abs</H3>
<PRE>
public static float <B>abs</B>(float&nbsp;a)</PRE>
<DL>
<DD>返回 <code>float</code> 值的绝对值。如果参数不是负数，则返回该参数。如果参数是负数，则返回该参数的相反数。特殊情况是：
<ul><li>如果参数是正零或负零，那么结果是正零。 
<li>如果参数是无穷大，那么结果是正无穷大。
<li>如果参数是 NaN，那么结果就是 NaN。</ul>
换句话说，结果等于以下表达式的值：
 <p><pre>Float.intBitsToFloat(0x7fffffff & Float.floatToIntBits(a))</pre>
<P>
<DD><DL>
<DT><B>参数：</B><DD><CODE>a</CODE> - 要确定绝对值的参数。
<DT><B>返回：</B><DD>参数的绝对值。</DL>
</DD>
</DL>
<HR>

<A NAME="abs(double)"><!-- --></A><H3>
abs</H3>
<PRE>
public static double <B>abs</B>(double&nbsp;a)</PRE>
<DL>
<DD>返回 <code>double</code> 值的绝对值。如果参数不是负数，则返回该参数。如果参数是负数，则返回该参数的相反数。特殊情况是：
<ul><li>如果参数是正零或负零，那么结果是正零。
<li>如果参数是无穷大，那么结果是正无穷大。
<li>如果参数是 NaN，那么结果就是 NaN。</ul>
换句话说，结果等于以下表达式的值：
 <p><code>Double.longBitsToDouble((Double.doubleToLongBits(a)&lt;&lt;1)&gt;&gt;&gt;1)</code>
<P>
<DD><DL>
<DT><B>参数：</B><DD><CODE>a</CODE> - 要确定绝对值的参数。
<DT><B>返回：</B><DD>参数的绝对值。</DL>
</DD>
</DL>
<HR>

<A NAME="max(int, int)"><!-- --></A><H3>
max</H3>
<PRE>
public static int <B>max</B>(int&nbsp;a,
                      int&nbsp;b)</PRE>
<DL>
<DD>返回两个 <code>int</code> 值中较大的一个。也就是说，结果是更接近 <code>Integer.MAX_VALUE</code> 值的参数。如果参数值相同，则结果是该相同值。
<P>
<DD><DL>
<DT><B>参数：</B><DD><CODE>a</CODE> - 参数。<DD><CODE>b</CODE> - 另一个参数。
<DT><B>返回：</B><DD><code>a</code> 和 <code>b</code> 中大的较大者。<DT><B>另请参见：</B><DD><A HREF="Long.html#MAX_VALUE"><CODE>Long.MAX_VALUE</CODE></A></DL>
</DD>
</DL>
<HR>

<A NAME="max(long, long)"><!-- --></A><H3>
max</H3>
<PRE>
public static long <B>max</B>(long&nbsp;a,
                       long&nbsp;b)</PRE>
<DL>
<DD>返回两个 <code>long</code> 值中较大的一个。也就是说，结果是更接近 <code>Long.MAX_VALUE</code> 值的参数。如果参数值相同，则结果是该相同值。
<P>
<DD><DL>
<DT><B>参数：</B><DD><CODE>a</CODE> - 参数。<DD><CODE>b</CODE> - 另一个参数。
<DT><B>返回：</B><DD><code>a</code> 和 <code>b</code> 中的较大者。<DT><B>另请参见：</B><DD><A HREF="Long.html#MAX_VALUE"><CODE>Long.MAX_VALUE</CODE></A></DL>
</DD>
</DL>
<HR>

<A NAME="max(float, float)"><!-- --></A><H3>
max</H3>
<PRE>
public static float <B>max</B>(float&nbsp;a,
                        float&nbsp;b)</PRE>
<DL>
<DD>返回两个 <code>float</code> 值中较大的一个。也就是说，结果是更接近正无穷大的参数。如果参数值相同，则结果是该相同值。如果两个值都是 NaN，那么结果就是 NaN。与数值比较运算不同，该方法认为负零严格小于正零。如果一个参数是正零，另一个参数是负零，那么结果就是正零。
<P>
<DD><DL>
<DT><B>参数：</B><DD><CODE>a</CODE> - 参数。<DD><CODE>b</CODE> - 另一个参数。
<DT><B>返回：</B><DD><code>a</code> 和 <code>b</code> 中的较大者。</DL>
</DD>
</DL>
<HR>

<A NAME="max(double, double)"><!-- --></A><H3>
max</H3>
<PRE>
public static double <B>max</B>(double&nbsp;a,
                         double&nbsp;b)</PRE>
<DL>
<DD>返回两个 <code>double</code> 值中较大的一个。也就是说，结果是更接近正无穷大的参数。如果参数值相同，则结果是该相同值。如果两个值都是 NaN，那么结果就是 NaN。与数值比较运算不同，该方法认为负零严格小于正零。如果一个参数是正零，另一个参数是负零，那么结果就是正零。
<P>
<DD><DL>
<DT><B>参数：</B><DD><CODE>a</CODE> - 参数。<DD><CODE>b</CODE> - 另一个参数。
<DT><B>返回：</B><DD><code>a</code> 和 <code>b</code> 中的较大者。</DL>
</DD>
</DL>
<HR>

<A NAME="min(int, int)"><!-- --></A><H3>
min</H3>
<PRE>
public static int <B>min</B>(int&nbsp;a,
                      int&nbsp;b)</PRE>
<DL>
<DD>返回两个 <code>int</code> 值中较小的一个。也就是说，结果是更接近 <code>Integer.MIN_VALUE</code> 值的参数。如果参数值相同，则结果是该相同值。
<P>
<DD><DL>
<DT><B>参数：</B><DD><CODE>a</CODE> - 参数。<DD><CODE>b</CODE> - 另一个参数。
<DT><B>返回：</B><DD><code>a</code> 和 <code>b</code> 中的较小者。<DT><B>另请参见：</B><DD><A HREF="Long.html#MIN_VALUE"><CODE>Long.MIN_VALUE</CODE></A></DL>
</DD>
</DL>
<HR>

<A NAME="min(long, long)"><!-- --></A><H3>
min</H3>
<PRE>
public static long <B>min</B>(long&nbsp;a,
                       long&nbsp;b)</PRE>
<DL>
<DD>返回两个 <code>long</code> 值中较小的一个。也就是说，结果是更接近 <code>Long.MIN_VALUE</code> 值的参数。如果参数值相同，则结果是该相同值。
<P>
<DD><DL>
<DT><B>参数：</B><DD><CODE>a</CODE> - 参数。<DD><CODE>b</CODE> - 另一个参数。
<DT><B>返回：</B><DD><code>a</code> 和 <code>b</code> 中的较小者。<DT><B>另请参见：</B><DD><A HREF="Long.html#MIN_VALUE"><CODE>Long.MIN_VALUE</CODE></A></DL>
</DD>
</DL>
<HR>

<A NAME="min(float, float)"><!-- --></A><H3>
min</H3>
<PRE>
public static float <B>min</B>(float&nbsp;a,
                        float&nbsp;b)</PRE>
<DL>
<DD>返回两个 <code>float</code> 值中较小的一个。也就是说，结果是更接近负无穷大的值。如果参数值相同，则结果是该相同值。如果两个值都是 NaN，那么结果就是 NaN。与数值比较运算不同，该方法认为负零严格小于正零。如果一个参数是正零，另一个参数是负零，那么结果是负零。
<P>
<DD><DL>
<DT><B>参数：</B><DD><CODE>a</CODE> - 参数。<DD><CODE>b</CODE> - 另一个参数。
<DT><B>返回：</B><DD><code>a</code> 和 <code>b</code> 中的较小者。</DL>
</DD>
</DL>
<HR>

<A NAME="min(double, double)"><!-- --></A><H3>
min</H3>
<PRE>
public static double <B>min</B>(double&nbsp;a,
                         double&nbsp;b)</PRE>
<DL>
<DD>返回两个 <code>double</code> 值中较小的一个。也就是说，结果是更接近负无穷大的值。如果参数值相同，则结果是该相同值。如果两个值都是 NaN，那么结果就是 NaN。与数值比较运算不同，该方法认为负零严格小于正零。如果一个参数是正零，另一个参数是负零，那么结果是负零。
<P>
<DD><DL>
<DT><B>参数：</B><DD><CODE>a</CODE> - 参数。<DD><CODE>b</CODE> - 另一个参数。
<DT><B>返回：</B><DD><code>a</code> 和 <code>b</code> 中的较小者。</DL>
</DD>
</DL>
<HR>

<A NAME="ulp(double)"><!-- --></A><H3>
ulp</H3>
<PRE>
public static double <B>ulp</B>(double&nbsp;d)</PRE>
<DL>
<DD>返回参数的 ulp 大小。<code>double</code> 值的 ulp 是该浮点值与下一个较大 <code>double</code> 值之间的正距离。注意，对于非 NaN <i>x</i>，<code>ulp(-<i>x</i>) == ulp(<i>x</i>)</code>。
 
<p>特殊情况是：