开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > J2ME > 查看源码
MicroDouble.java
资源名称：GMapsTest.rar　[点击查看]
上传用户：hygd004
上传日期：2022-07-01
资源大小：246k
文件大小：135k
源码类别：

J2ME

开发平台：

Java

MicroDouble.java：源码内容
  1. // $Id: MicroDouble.java,v 1.2 2004/08/03 04:57:42 Dave Exp $
  2. /*
  3.  * Double.java
  4.  * Copyright (C) 2003, 2004 David Clausen
  5.  *
  6.  * This program is free software; you can redistribute it and/or
  7.  * modify it under the terms of the GNU General Public License
  8.  * as published by the Free Software Foundation; either version 2
  9.  * of the License, or (at your option) any later version.
  10.  *
  11.  * This program is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  * GNU General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU General Public License
  17.  * along with this program; if not, write to the Free Software
  18.  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  19.  *
  20.  * Portions of this software are derived from FDLIBM, which contained the
  21.  * following notice:
  22.  *
  23.  * ====================================================
  24.  * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
  25.  *
  26.  * Developed at SunSoft, a Sun Microsystems, Inc. business.
  27.  * Permission to use, copy, modify, and distribute this
  28.  * software is freely granted, provided that this notice 
  29.  * is preserved.
  30.  * ====================================================
  31.  *
  32.  * For mor information on FDLIBM see:
  33.  * http://netlib.bell-labs.com/netlib/fdlibm/index.html
  34.  *
  35.  */
  36. package net.dclausen.microfloat;
  38. import java.util.Random;
  40. /**
  41.  * A software implementation of IEEE-754 double precision math which does not
  42.  * rely on the <code>double</code> data type. 
  43.  * This class overloads the <code>long</code> data type by storing 
  44.  * <code>double</code> data in it.
  45.  * See the 
  46.  * <a href="package-summary.html#package_description">package description</a> 
  47.  * for more information.
  48.  * <p>
  49.  * @author David Clausen
  50.  * @see <a href="http://java.sun.com/j2se/1.4.2/docs/api/java/lang/Double.html">Double</a>
  51.  * @see <a href="http://java.sun.com/j2se/1.4.2/docs/api/java/lang/Math.html">Math</a>
  52.  * @see Float
  53.  * @version $Revision: 1.2 $
  54.  */
  55. public class MicroDouble {
  56.   
  57.   /////////////////////////////////////////////////////////////////////////////
  58.   // General-purpose constants
  59.   /////////////////////////////////////////////////////////////////////////////
  61.   /**
  62.    * A constant holding the same value as <a href="http://java.sun.com/j2se/1.4.2/docs/api/java/lang/Double.html#POSITIVE_INFINITY">Double.POSITIVE_INFINITY</a>
  63.    */
  64.   public  static final long POSITIVE_INFINITY = 0x7ff0000000000000L;
  65.   
  66.   /**
  67.    * A constant holding the same value as <a href="http://java.sun.com/j2se/1.4.2/docs/api/java/lang/Double.html#NEGATIVE_INFINITY">Double.NEGATIVE_INFINITY</a>
  68.    */
  69.   public  static final long NEGATIVE_INFINITY = 0xfff0000000000000L;
  71.   /**
  72.    * A constant holding the same value as <a href="http://java.sun.com/j2se/1.4.2/docs/api/java/lang/Double.html#NaN">Double.NaN</a>
  73.    */
  74.   public  static final long NaN               = 0x7ff8000000000000L;
  75.   
  76.   /**
  77.    * A constant holding the same value as <a href="http://java.sun.com/j2se/1.4.2/docs/api/java/lang/Double.html#MAX_VALUE">Double.MAX_VALUE</a>
  78.    */
  79.   public  static final long MAX_VALUE         = 0x7fefffffffffffffL;
  80.   
  81.   /**
  82.    * A constant holding the same value as <a href="http://java.sun.com/j2se/1.4.2/docs/api/java/lang/Double.html#MIN_VALUE">Double.MIN_VALUE</a>
  83.    */
  84.   public  static final long MIN_VALUE         = 0x0000000000000001L; 
  85.   
  86.   /**
  87.    * A constant holding the same value as <a href="http://java.sun.com/j2se/1.4.2/docs/api/java/lang/Math.html#E">Math.E</a>
  88.    */
  89.   public  static final long E                 = 0x4005bf0a8b145769L;
  90.   
  91.   /**
  92.    * A constant holding the same value as <a href="http://java.sun.com/j2se/1.4.2/docs/api/java/lang/Math.html#PI">Math.PI</a>
  93.    */
  94.   public  static final long PI                = 0x400921fb54442d18L;
  96.   // Other constants needed internally, and exposed as a convenience.
  98.   /** A constant holding the value of 0.0d */
  99.   public static final long ZERO              = 0x0000000000000000L;
  101.   /** A constant holding the value of -0.0d */
  102.   public static final long NEGATIVE_ZERO     = 0x8000000000000000L;
  103.   
  104.   /** A constant holding the value of 1.0d */
  105.   public static final long ONE               = 0x3ff0000000000000L;
  106.   
  107.   /** A constant holding the value of -1.0d */
  108.   public static final long NEGATIVE_ONE      = 0xbff0000000000000L;
  109.   
  110.   /** A constant holding the value of 2.0d */
  111.   public static final long TWO               = 0x4000000000000000L;
  112.   
  113.   /** A constant holding the value of 3.0d */
  114.   public static final long THREE             = 0x4008000000000000L;
  115.   
  116.   /** A constant holding the value of 4.0d */
  117.   public static final long FOUR              = 0x4010000000000000L;
  118.   
  119.   /** A constant holding the value of 5.0d */
  120.   public static final long FIVE              = 0x4014000000000000L;
  121.   
  122.   /** A constant holding the value of 6.0d */
  123.   public static final long SIX               = 0x4018000000000000L;
  124.   
  125.   /** A constant holding the value of 8.0d */
  126.   public static final long EIGHT             = 0x4020000000000000L;
  127.   
  128.   /** A constant holding the value of 10.0d */
  129.   public static final long TEN               = 0x4024000000000000L;
  130.   
  131.   /** A constant holding the value of 100.0d */
  132.   public static final long ONE_HUNDRED       = 0x4059000000000000L;
  133.   
  134.   /** A constant holding the value of 1.5d */
  135.   public static final long THREE_HALVES      = 0x3ff8000000000000L;
  136.   
  137.   /** A constant holding the value of 0.5d */
  138.   public static final long ONE_HALF          = 0x3fe0000000000000L;
  139.   
  140.   /** A constant holding the value of (1.0d / 3.0d) */
  141.   public static final long ONE_THIRD         = 0x3fd5555555555555L;
  142.   
  143.   /** A constant holding the value of 0.25d */
  144.   public static final long ONE_FOURTH        = 0x3fd0000000000000L;
  145.   
  146.   /** A constant holding the value of 0.125d */
  147.   public static final long ONE_EIGHTH        = 0x3fc0000000000000L;
  148.   
  149.   /** A constant holding the natural logarithm of 2 */
  150.   public static final long LN2               = 0x3fe62e42fefa39efL;
  152.   
  153.   /////////////////////////////////////////////////////////////////////////////
  154.   // Packing and unpacking the IEEE-754 double precision format
  155.   /////////////////////////////////////////////////////////////////////////////
  157.   private static final long ABS_MASK          = 0x7fffffffffffffffL;
  158.   private static final long SIGN_MASK         = 0x8000000000000000L; // 1 bit
  159.   private static final long EXPONENT_MASK     = 0x7ff0000000000000L; // 11 bits
  160.   private static final long FRACTION_MASK     = 0x000fffffffffffffL; // 52 bits
  161.   private static final long IMPLIED_ONE       = 0x0010000000000000L; // 53rd bit
  163.   /** @return true iff d is negative */
  164.   static boolean unpackSign(long d) {
  165.     return (d < 0L);
  166.   }
  168.   /** @return an integer in the range [-1075, 972] */
  169.   static int unpackExponent(long d) {
  170.     return (((int) (d >> 52)) & 0x7ff) - 1075;
  171.   }
  173.   /** @return a long in the range [0, 0x001fffffffffffffL] */
  174.   static long unpackMantissa(long d) {
  175.     if ((d & EXPONENT_MASK) == 0) {
  176.       return ((d & FRACTION_MASK) << 1);
  177.     } else {
  178.       return ((d & FRACTION_MASK) | IMPLIED_ONE);
  179.     }
  180.   }
  182.   /** 
  183.    * @return the double which most closely represents the given base-2 mantissa
  184.    *         and exponent
  185.    */
  186.   static long pack(boolean negative, int exponent, long mantissa) {
  187.     // reduce precision of mantissa, rounding if necessary
  188.     if (mantissa != 0) {
  189.       // left align mantissa
  190.       int shift = BitUtils.countLeadingZeros(mantissa);
  191.       mantissa <<= shift;
  192.       exponent -= shift;
  194.       if (exponent < -1085) {
  195.         // subnormal
  196.         mantissa = BitUtils.roundingRightShift(mantissa, -1074 - exponent);
  197.       } else {
  198.         // normal
  199.         mantissa = BitUtils.roundingRightShift(mantissa, 11);
  200.         if (mantissa == 0x20000000000000L) {
  201.           // oops, rounding carried into the 54th bit
  202.           mantissa = 0x10000000000000L;
  203.           exponent++;
  204.         }
  205.         // pack the exponent
  206.         if (exponent > 960) {
  207.           mantissa = POSITIVE_INFINITY;
  208.         } else {
  209.           mantissa ^= IMPLIED_ONE;
  210.           mantissa |= ((long) (exponent + 1086)) << 52;
  211.         }
  212.       }
  213.     }
  214.     
  215.     // pack the sign bit
  216.     if (negative) {
  217.       mantissa |= SIGN_MASK;
  218.     }
  219.     
  220.     return mantissa;
  221.   }
  223.   
  224.   /////////////////////////////////////////////////////////////////////////////
  225.   // Simple tests 
  226.   /////////////////////////////////////////////////////////////////////////////
  228.   /**
  229.    * Mimics <a href="http://java.sun.com/j2se/1.4.2/docs/api/java/lang/Double.html#isNaN(double)">Double.isNaN(double)</a>
  230.    */
  231.   public static boolean isNaN(long d) {
  232.     return ((d & ABS_MASK) > POSITIVE_INFINITY);
  233.   }
  235.   /**
  236.    * Mimics <a href="http://java.sun.com/j2se/1.4.2/docs/api/java/lang/Double.html#isInfinite(double)">Double.isInfinite(double)</a>
  237.    */
  238.   public static boolean isInfinite(long d) {
  239.     return ((d & ABS_MASK) == POSITIVE_INFINITY);
  240.   }
  241.   
  242.   /**
  243.    * Returns <code>true</code> if the specified number has zero
  244.    * magnitude, <code>false</code> otherwise.
  245.    *
  246.    * @param   d   the <code>double</code> value to be tested.
  247.    * @return  <code>true</code> if the value of the argument is positive
  248.    *          zero or negative zero; <code>false</code> otherwise.
  249.    */
  250.   public static boolean isZero(long d) {
  251.     return ((d & ABS_MASK) == ZERO);
  252.   }
  254.   
  255.   /////////////////////////////////////////////////////////////////////////////
  256.   // Sign changes
  257.   /////////////////////////////////////////////////////////////////////////////
  259.   /**
  260.    * Mimics <a href="http://java.sun.com/j2se/1.4.2/docs/api/java/lang/Math.html#abs(double)">Math.abs(double)</a>
  261.    */
  262.   public static long abs(long d) {
  263.     //if (isNaN(d)) {
  264.     //  return NaN;
  265.     //}
  266.     return (d & ABS_MASK);
  267.   }
  269.   /**
  270.    * Returns the negation of a <code>double</code> value.
  271.    * Special cases:
  272.    * <ul>
  273.    * <li>If the argument is negative zero, the result is positive zero.
  274.    * <li>If the argument is positive zero, the result is negative zero.
  275.    * <li>If the argument is negative infinity, the result is positive infinity.
  276.    * <li>If the argument is positive infinity, the result is negative infinity.
  277.    * <li>If the argument is NaN, the result is NaN.</ul>
  278.    * <p>
  279.    * This method takes the place of the unary <code>-</code> operator.
  280.    *
  281.    * @param   d   the <code>double</code> value whose negated value is to be 
  282.    *              determined
  283.    * @return  the negation of the argument.
  284.    */
  285.   public static long negate(long d) {
  286.     if (isNaN(d)) {
  287.       return NaN;
  288.     }
  289.     return (d ^ SIGN_MASK);
  290.   }
  291.   
  293.   /////////////////////////////////////////////////////////////////////////////
  294.   // Comparison
  295.   /////////////////////////////////////////////////////////////////////////////
  297.   /**
  298.    * Returns <code>true</code> if the specified numbers are considered equal
  299.    * according to 
  300.    * <a href="http://java.sun.com/docs/books/jls/second_edition/html/expressions.doc.html#5198">section 15.21.1
  301.    * of the JLS</a>.  Special cases:
  302.    * <ul>
  303.    * <li>If either operand is NaN, then the result is false
  304.    * <li>Positive zero and negative zero are considered equal
  305.    * </ul>
  306.    * <p>
  307.    * This method takes the place of the <code>==</code> operator.
  308.    *
  309.    * @param   d1   the first <code>double</code> value to be compared.
  310.    * @param   d2   the second <code>double</code> value to be compared.
  311.    * @return  <code>true</code> if the two values are considered equal;
  312.    *          <code>false</code> otherwise.
  313.    */
  314.   public static boolean eq(long d1, long d2) {
  315.     return (((d1 == d2) && (! isNaN(d1))) || (isZero(d1) && isZero(d2)));
  316.   }
  318.   /**
  319.    * Returns <code>true</code> if the specified numbers are considered unequal
  320.    * according to 
  321.    * <a href="http://java.sun.com/docs/books/jls/second_edition/html/expressions.doc.html#5198">section
  322.    * 15.21.1 of the JLS</a>.  Special cases:
  323.    * <ul>
  324.    * <li>If either operand is NaN, then the result is true
  325.    * <li>Positive zero and negative zero are considered equal
  326.    * </ul>
  327.    * The value returned by <code>ne</code> is always the opposite of the value
  328.    * returned by <code>eq</code> for the same arguments.
  329.    * <p>
  330.    * This method takes the place of the <code>!=</code> operator.
  331.    *
  332.    * @param   d1   the first <code>double</code> value to be compared.
  333.    * @param   d2   the second <code>double</code> value to be compared.
  334.    * @return  <code>true</code> if the two values are considered equal;
  335.    *          <code>false</code> otherwise.
  336.    */
  337.   public static boolean ne(long d1, long d2) {
  338.     return (! eq(d1, d2));
  339.   }
  341.   /**
  342.    * Returns <code>true</code> if the first argument is considered less than
  343.    * the second argument according to 
  344.    * <a href="http://java.sun.com/docs/books/jls/second_edition/html/expressions.doc.html#153654">section
  345.    * 15.20.1 of the JLS</a>.  Special cases:
  346.    * <ul>
  347.    * <li>If either operand is NaN, then the result is false
  348.    * <li>Positive zero and negative zero are considered equal
  349.    * <li>Negative infinity is conisdered less than all other values except NaN
  350.    * <li>Positive infinity is conisdered greater than all other values except NaN
  351.    * </ul>
  352.    * <p>
  353.    * This method takes the place of the <code>&lt;</code> operator.
  354.    *
  355.    * @param   d1   the first <code>double</code> value to be compared.
  356.    * @param   d2   the second <code>double</code> value to be compared.
  357.    * @return  <code>true</code> if the first value is less than the second value;
  358.    *          <code>false</code> otherwise.
  359.    */
  360.   public static boolean lt(long d1, long d2) {
  361.     if (isNaN(d1) || isNaN(d2)) {
  362.       return false;
  363.     } else if (d2 == ZERO) {
  364.       d2 = NEGATIVE_ZERO;
  365.     }
  366.     return (cmp(d1, d2) < 0);
  367.   }
  368.   
  369.   /**
  370.    * Returns <code>true</code> if the first argument is considered less than
  371.    * or equal to the second argument according to 
  372.    * <a href="http://java.sun.com/docs/books/jls/second_edition/html/expressions.doc.html#153654">section
  373.    * 15.20.1 of the JLS</a>.  Special cases:
  374.    * <ul>
  375.    * <li>If either operand is NaN, then the result is false
  376.    * <li>Positive zero and negative zero are considered equal
  377.    * <li>Negative infinity is conisdered less than all other values except NaN
  378.    * <li>Positive infinity is conisdered greater than all other values except NaN
  379.    * </ul>
  380.    * <p>
  381.    * This method takes the place of the <code>&lt;=</code> operator.
  382.    *
  383.    * @param   d1   the first <code>double</code> value to be compared.
  384.    * @param   d2   the second <code>double</code> value to be compared.
  385.    * @return  <code>true</code> if the first value is less than or equal to 
  386.    *          the second value; <code>false</code> otherwise.
  387.    */
  388.   public static boolean le(long d1, long d2) {
  389.     if (isNaN(d1) || isNaN(d2)) {
  390.       return false;
  391.     } else if (d2 == NEGATIVE_ZERO) {
  392.       d2 = ZERO;
  393.     }
  394.     return (cmp(d1, d2) <= 0);
  395.   }
  397.   /**
  398.    * Returns <code>true</code> if the first argument is considered greater than
  399.    * the second argument according to 
  400.    * <a href="http://java.sun.com/docs/books/jls/second_edition/html/expressions.doc.html#153654">section
  401.    * 15.20.1 of the JLS</a>.  Special cases:
  402.    * <ul>
  403.    * <li>If either operand is NaN, then the result is false
  404.    * <li>Positive zero and negative zero are considered equal
  405.    * <li>Negative infinity is conisdered less than all other values except NaN
  406.    * <li>Positive infinity is conisdered greater than all other values except NaN
  407.    * </ul>
  408.    * <p>
  409.    * This method takes the place of the <code>&gt;</code> operator.
  410.    *
  411.    * @param   d1   the first <code>double</code> value to be compared.
  412.    * @param   d2   the second <code>double</code> value to be compared.
  413.    * @return  <code>true</code> if the first value is greater than the second value;
  414.    *          <code>false</code> otherwise.
  415.    */
  416.   public static boolean gt(long d1, long d2) {
  417.     if (isNaN(d1) || isNaN(d2)) {
  418.       return false;
  419.     } else if (d1 == ZERO) {
  420.       d1 = NEGATIVE_ZERO;
  421.     }
  422.     return (cmp(d1, d2) > 0);
  423.   }
  424.   
  425.   /**
  426.    * Returns <code>true</code> if the first argument is considered greater than
  427.    * or equal to the second argument according to 
  428.    * <a href="http://java.sun.com/docs/books/jls/second_edition/html/expressions.doc.html#153654">section
  429.    * 15.20.1 of the JLS</a>.  Special cases:
  430.    * <ul>
  431.    * <li>If either operand is NaN, then the result is false
  432.    * <li>Positive zero and negative zero are considered equal
  433.    * <li>Negative infinity is conisdered less than all other values except NaN
  434.    * <li>Positive infinity is conisdered greater than all other values except NaN
  435.    * </ul>
  436.    * <p>
  437.    * This method takes the place of the <code>&gt;=</code> operator.
  438.    *
  439.    * @param   d1   the first <code>double</code> value to be compared.
  440.    * @param   d2   the second <code>double</code> value to be compared.
  441.    * @return  <code>true</code> if the first value is greater than or equal to 
  442.    *          the second value; <code>false</code> otherwise.
  443.    */
  444.   public static boolean ge(long d1, long d2) {
  445.     if (isNaN(d1) || isNaN(d2)) {
  446.       return false;
  447.     } else if (d1 == NEGATIVE_ZERO) {
  448.       d1 = ZERO;
  449.     }
  450.     return (cmp(d1, d2) >= 0);
  451.   }
  453.   /**
  454.    * Mimics <a href="http://java.sun.com/j2se/1.4.2/docs/api/java/lang/Double.html#compare(double, double)">Double.compare(double, double)</a>.
  455.    * <p>
  456.    * Note that when using this method (as well as <code>Double.compare</code>),
  457.    * the following rules apply:
  458.    * <ul><li>
  459.    * <code>NaN</code> is considered 
  460.    * to be equal to itself and greater than all other
  461.    * <code>double</code> values (including
  462.    * <code>POSITIVE_INFINITY</code>).
  463.    * <li>
  464.    * <code>0.0</code> is considered to be greater
  465.    * than <code>-0.0</code>.
  466.    * </ul>
  467.    */
  468.   public static int compare(long d1, long d2) {
  469.     boolean n1 = isNaN(d1);
  470.     boolean n2 = isNaN(d2);
  471.     if (n1 || n2) {
  472.       if (n1 && n2) {
  473.         return 0;
  474.       }
  475.       return (n1 ? 1 : -1);
  476.     }
  477.     return cmp(d1, d2);
  478.   }
  480.   /**
  481.    * Mimics <a href="http://java.sun.com/j2se/1.4.2/docs/api/java/lang/Math.html#max(double, double)">Math.max(double, double)</a>
  482.    */
  483.   public static long max(long d1, long d2) {
  484.     if (isNaN(d1) || isNaN(d2)) {
  485.       return NaN;
  486.     }
  487.     return ((cmp(d1, d2) >= 0) ? d1 : d2);
  488.   }
  490.   /**
  491.    * Mimics <a href="http://java.sun.com/j2se/1.4.2/docs/api/java/lang/Math.html#min(double, double)">Math.min(double, double)</a>
  492.    */
  493.   public static long min(long d1, long d2) {
  494.     if (isNaN(d1) || isNaN(d2)) {
  495.       return NaN;
  496.     }
  497.     return ((cmp(d1, d2) < 0) ? d1 : d2);
  498.   }
  500.   private static int cmp(long d1, long d2) {
  501.     if (d1 == d2) {
  502.       return 0;
  503.     } else if (d1 < 0L) {
  504.       if (d2 < 0L) {
  505.         return ((d1 < d2) ? 1 : -1);
  506.       }
  507.       return -1;
  508.     } else if (d2 < 0) {
  509.       return 1;
  510.     }
  511.     return ((d1 < d2) ? -1 : 1);
  512.   }
  513.   
  514.   /////////////////////////////////////////////////////////////////////////////
  515.   // Type conversion
  516.   /////////////////////////////////////////////////////////////////////////////
  517.   
  518.   /** 
  519.    * Convert the given <code>int</code> to a <code>double</code> as would happen
  520.    * in a casting operation specified by 
  521.    * <a href="http://java.sun.com/docs/books/jls/second_edition/html/conversions.doc.html#25214">section
  522.    * 5.1.2 of the JLS</a>.  This is a widening primitive conversion which 
  523.    * will result in neither a loss of magnitude nor precision.
  524.    *
  525.    * @param x the <code>int</code> to be converted
  526.    * @return the <code>double</code> representation of the argument
  527.    */
  528.   public static long intToDouble(int x) {
  529.     return longToDouble(x);
  530.   }
  531.   
  532.   /** 
  533.    * Convert the given <code>long</code> to a <code>double</code> as would happen
  534.    * in a casting operation specified by 
  535.    * <a href="http://java.sun.com/docs/books/jls/second_edition/html/conversions.doc.html#25214">section
  536.    * 5.1.2 of the JLS</a>.  This is a widening primitive conversion which 
  537.    * will not result in a loss of magnitude, but might result in a loss of
  538.    * precision.
  539.    *
  540.    * @param x the <code>long</code> to be converted
  541.    * @return the <code>double</code> representation of the argument
  542.    */
  543.   public static long longToDouble(long x) {
  544.     if (x < 0) {
  545.       return pack(true, 0, -x);
  546.     }
  547.     return pack(false, 0, x);
  548.   }
  550.   /** 
  551.    * Convert the given <code>float</code> to a <code>double</code> as would happen
  552.    * in a casting operation specified by 
  553.    * <a href="http://java.sun.com/docs/books/jls/second_edition/html/conversions.doc.html#25214">section
  554.    * 5.1.2 of the JLS</a>.  This is a widening primitive conversion which 
  555.    * will result in neither a loss of magnitude nor precision.
  556.    *
  557.    * @param f the <code>float</code> to be converted
  558.    * @return the <code>double</code> representation of the argument
  559.    */
  560.   public static long floatToDouble(int f) {
  561.     if (MicroFloat.isNaN(f)) {
  562.       return NaN;
  563.     }
  564.     boolean n = MicroFloat.unpackSign(f);
  565.     if (MicroFloat.isZero(f)) {
  566.       return (n ? NEGATIVE_ZERO : ZERO);
  567.     } else if (MicroFloat.isInfinite(f)) {
  568.       return (n ? NEGATIVE_INFINITY : POSITIVE_INFINITY);
  569.     }
  570.     int x = MicroFloat.unpackExponent(f);
  571.     long m = MicroFloat.unpackMantissa(f);
  572.     return pack(n, x, m);
  573.   }
  574.   
  575.   /** 
  576.    * Convert the given <code>double</code> to a <code>byte</code> as would happen
  577.    * in a casting operation specified by 
  578.    * <a href="http://java.sun.com/docs/books/jls/second_edition/html/conversions.doc.html#25363">section
  579.    * 5.1.3 of the JLS</a>.  This is a narrowing primitive conversion which 
  580.    * may result in a loss of magnitude and/or precision.
  581.    * <p>
  582.    * Note that this is a non-intuitive conversion.  If the argument is outside
  583.    * of the range of the byte type, the result is basically meaningless.
  584.    *
  585.    * @param d the <code>double</code> to be converted
  586.    * @return the <code>byte</code> representation of the argument
  587.    */
  588.   public static byte byteValue(long d) {
  589.     return (byte) intValue(d);
  590.   }
  592.   /** 
  593.    * Convert the given <code>double</code> to a <code>short</code> as would happen
  594.    * in a casting operation specified by 
  595.    * <a href="http://java.sun.com/docs/books/jls/second_edition/html/conversions.doc.html#25363">section
  596.    * 5.1.3 of the JLS</a>.  This is a narrowing primitive conversion which 
  597.    * may result in a loss of magnitude and/or precision.
  598.    * <p>
  599.    * Note that this is a non-intuitive conversion.  If the argument is outside
  600.    * of the range of the short type, the result is basically meaningless.
  601.    *
  602.    * @param d the <code>double</code> to be converted
  603.    * @return the <code>short</code> representation of the argument
  604.    */
  605.   public static short shortValue(long d) {
  606.     return (short) intValue(d);
  607.   }
  609.   /** 
  610.    * Convert the given <code>double</code> to an <code>int</code> as would happen
  611.    * in a casting operation specified by 
  612.    * <a href="http://java.sun.com/docs/books/jls/second_edition/html/conversions.doc.html#25363">section
  613.    * 5.1.3 of the JLS</a>.  This is a narrowing primitive conversion which 
  614.    * may result in a loss of magnitude and/or precision.
  615.    *
  616.    * @param d the <code>double</code> to be converted
  617.    * @return the <code>int</code> representation of the argument
  618.    */
  619.   public static int intValue(long d) {
  620.     long x = longValue(d);
  621.     if (x >= Integer.MAX_VALUE) {
  622.       return Integer.MAX_VALUE;
  623.     } else if (x <= Integer.MIN_VALUE) {
  624.       return Integer.MIN_VALUE;
  625.     }
  626.     return (int) x;
  627.   }
  629.   /** 
  630.    * Convert the given <code>double</code> to a <code>long</code> as would happen
  631.    * in a casting operation specified by 
  632.    * <a href="http://java.sun.com/docs/books/jls/second_edition/html/conversions.doc.html#25363">section
  633.    * 5.1.3 of the JLS</a>.  This is a narrowing primitive conversion which 
  634.    * may result in a loss of magnitude and/or precision.
  635.    *
  636.    * @param d the <code>double</code> to be converted
  637.    * @return the <code>long</code> representation of the argument
  638.    */
  639.   public static long longValue(long d) {
  640.     if (isNaN(d)) {
  641.       return 0;
  642.     }
  643.     boolean n = unpackSign(d);
  644.     int x = unpackExponent(d);
  645.     long m = unpackMantissa(d);
  646.     if (x > 0) {
  647.       if ((x >= 63) || ((m >> (63 - x)) != 0))  {
  648.         return (n ? Long.MIN_VALUE : Long.MAX_VALUE);
  649.       }
  650.       m <<= x;
  651.     } else if (x <= -53) {
  652.       return 0;
  653.     } else {
  654.       m >>>= -x;
  655.     }
  656.     return (n ? -m : m);
  657.   }
  659.   /** 
  660.    * Convert the given <code>double</code> to a <code>float</code> as would happen
  661.    * in a casting operation specified by 
  662.    * <a href="http://java.sun.com/docs/books/jls/second_edition/html/conversions.doc.html#25363">section
  663.    * 5.1.3 of the JLS</a>.  This is a narrowing primitive conversion which 
  664.    * may result in a loss of magnitude and/or precision.
  665.    *
  666.    * @param d the <code>double</code> to be converted
  667.    * @return the <code>float</code> representation of the argument
  668.    */
  669.   public static int floatValue(long d) {
  670.     return MicroFloat.doubleToFloat(d);
  671.   }
  672.   
  673.   /////////////////////////////////////////////////////////////////////////////
  674.   // Random number generation
  675.   /////////////////////////////////////////////////////////////////////////////
  677.   private static Random random;
  679.   private static synchronized Random getRandom() {
  680.     if (random == null) {
  681.       random = new java.util.Random();
  682.     }
  683.     return random;
  684.   }
  685.   
  686.   /**
  687.    * Mimics <a href="http://java.sun.com/j2se/1.4.2/docs/api/java/lang/Math.html#random()">Math.random()</a>
  688.    */
  689.   public static long random() {
  690.     return pack(false, -64, getRandom().nextLong() << 11);
  691.   }
  693.   
  694.   /////////////////////////////////////////////////////////////////////////////
  695.   // Basic arithmetic
  696.   /////////////////////////////////////////////////////////////////////////////
  698.   /**
  699.    * Returns the sum of the two <code>double</code> arguments according to 
  700.    * <a href="http://java.sun.com/docs/books/jls/second_edition/html/expressions.doc.html#13510">section
  701.    * 15.18.2 of the JLS</a>.
  702.    * <p>
  703.    * This method takes the place of the <code>+</code> operator.
  704.    *
  705.    * @param   d1   the first <code>double</code> value to be summed.
  706.    * @param   d2   the second <code>double</code> value to be summed.
  707.    * @return  the sum of the two arguments
  708.    */
  709.   public static long add(long d1, long d2) {
  710.     if (isNaN(d1) || isNaN(d2)) {
  711.       return NaN;
  712.     }
  714.     boolean n1 = unpackSign(d1);
  715.     boolean n2 = unpackSign(d2);
  716.     
  717.     // special handling of infinity
  718.     boolean i1 = isInfinite(d1);
  719.     boolean i2 = isInfinite(d2);
  720.     if (i1 || i2) {
  721.       if (i1 && i2) {
  722.         if (n1 != n2) {
  723.           // infinites of opposite sign -> NaN
  724.           return NaN;
  725.         } else {
  726.           // infinites of same sign -> infinity the same sign
  727.           return d1;
  728.         }
  729.       } else if (i1) {
  730.         return d1; // infinite + finite = infinite
  731.       } else {
  732.         return d2; // finite + infinite = infinite
  733.       }
  734.     }
  735.     
  736.     // special handling of zero
  737.     boolean z1 = isZero(d1);
  738.     boolean z2 = isZero(d2);
  739.     if (z1 || z2) {
  740.       if (z1 && z2) {
  741.         if (n1 != n2) {
  742.           // zeros of opposite sign -> positive zero
  743.           return ZERO;
  744.         } else {
  745.           return d1; // zeros of same sign -> zero of the same sign
  746.         }
  747.       } else if (z1) {
  748.         return d2; // zero + nonzero = nonzero
  749.       } else {
  750.         return d1; // nonzero + zero = nonzero
  751.       }
  752.     }
  753.     
  754.     // unpack, and add 3 guard digits
  755.     long m1 = unpackMantissa(d1) << 3;
  756.     int x1 = unpackExponent(d1) - 3;
  757.     long m2 = unpackMantissa(d2) << 3;
  758.     int x2 = unpackExponent(d2) - 3;
  759.     
  760.     // make exponents equal
  761.     int dx = x1 - x2;
  762.     if (dx > 0) {
  763.       m2 = BitUtils.stickyRightShift(m2, dx);
  764.       x2 = x1;
  765.     } else if (dx < 0) {
  766.       m1 = BitUtils.stickyRightShift(m1, -dx);
  767.       x1 = x2;
  768.     }
  770.     // if the signs are different, negate the smaller mantissa and choose
  771.     // the sign of the larger
  772.     if (n1 ^ n2) { 
  773.       if (m1 > m2) {
  774.         m2 = -m2;
  775.       } else {
  776.         m1 = -m1;
  777.         n1 = n2;
  778.       }
  779.     }
  780.     
  781.     // add (or subtract) mantissas
  782.     m1 += m2;
  784.     // pack result, and handle special case of zero (which always returns +0.0) 
  785.     long d = pack(n1, x1, m1);
  786.     if (d == NEGATIVE_ZERO) {
  787.       return ZERO;
  788.     }
  789.     return d;
  790.   }
  791.   
  792.   /**
  793.    * Returns the difference of the two <code>double</code> arguments according to 
  794.    * <a href="http://java.sun.com/docs/books/jls/second_edition/html/expressions.doc.html#13510">section
  795.    * 15.18.2 of the JLS</a>.
  796.    * <p>
  797.    * This method takes the place of the binary <code>-</code> operator.
  798.    *
  799.    * @param   d1   the first <code>double</code> value 
  800.    * @param   d2   the second <code>double</code> value
  801.    * @return  the difference of the two arguments
  802.    */
  803.   public static long sub(long d1, long d2) {
  804.     return add(d1, negate(d2));
  805.   }
  807.   /**
  808.    * Returns the product of the two <code>double</code> arguments according to 
  809.    * <a href="http://java.sun.com/docs/books/jls/second_edition/html/expressions.doc.html#5036">section
  810.    * 15.17.1 of the JLS</a>.
  811.    * <p>
  812.    * This method takes the place of the <code>*</code> operator.
  813.    *
  814.    * @param   d1   the first <code>double</code> value
  815.    * @param   d2   the second <code>double</code> value
  816.    * @return  the product of the two arguments
  817.    */
  818.   public static long mul(long d1, long d2) {
  819.     if (isNaN(d1) || isNaN(d2)) {
  820.       return NaN;
  821.     }
  823.     boolean negative = unpackSign(d1) ^ unpackSign(d2);
  824.     
  825.     // special handling of infinity
  826.     if (isInfinite(d1) || isInfinite(d2)) {
  827.       if (isZero(d1) || isZero(d2)) {
  828.         return NaN;
  829.       } else {
  830.         return (negative ? NEGATIVE_INFINITY : POSITIVE_INFINITY);
  831.       }
  832.     }
  833.     
  834.     // unpack
  835.     long m1 = unpackMantissa(d1);
  836.     int x1 = unpackExponent(d1);
  837.     long m2 = unpackMantissa(d2);
  838.     int x2 = unpackExponent(d2);
  839.     
  840.     // compute the resultant exponent
  841.     x1 += x2;
  842.     
  843.     // compute the resultant mantissa using double-precision integer 
  844.     // multiplication with 28 bit words
  845.     long m11 = m1 & 0x0fffffff;
  846.     long m12 = m1 >> 28;
  847.     long m21 = m2 & 0x0fffffff;
  848.     long m22 = m2 >> 28;
  849.     
  850.     long t1 = m11 * m21;
  851.     long t2 = (m11 * m22) + (m12 * m21);
  852.     long t3 = m12 * m22;
  853.     
  854.     t1 += (t2 & 0x0fffffff) << 28;
  855.     t3 += t2 >>> 28;
  856.     t3 += t1 >>> 56;
  857.     t1 <<= 8;
  858.     // the 128 bit result is now in t3t1
  860.     if (t3 == 0) {
  861.       // the high 64 bits are zero and can be ignored.
  862.       return pack(negative, x1, t1);
  863.     }
  864.     
  865.     // shift the result left into t3 and discard excess precision
  866.     int s = BitUtils.countLeadingZeros(t3);
  867.     x1 += 56 - s;
  868.     t3 <<= s;
  869.     t3 |= t1 >>> (64 - s);
  870.     if ((t1 << s) != 0) {
  871.       // discarded low bits go into the sticky bit
  872.       t3 |= 1;
  873.     }
  874.     
  875.     // round and pack the result
  876.     return pack(negative, x1, t3);
  877.   }
  878.   
  879.   /**
  880.    * Returns the quotient of the two <code>double</code> arguments according to 
  881.    * <a href="http://java.sun.com/docs/books/jls/second_edition/html/expressions.doc.html#5047">section
  882.    * 15.17.2 of the JLS</a>.
  883.    * <p>
  884.    * This method takes the place of the <code>/</code> operator.
  885.    *
  886.    * @param   d1   the <code>double</code> dividend 
  887.    * @param   d2   the <code>double</code> divisor
  888.    * @return  the quotient of the two arguments
  889.    */
  890.   public static long div(long d1, long d2) {
  891.     if (isNaN(d1) || isNaN(d2)) {
  892.       return NaN;
  893.     }
  895.     boolean negative = unpackSign(d1) ^ unpackSign(d2);
  896.     
  897.     // special handling of infinity
  898.     boolean n1 = isInfinite(d1);
  899.     boolean n2 = isInfinite(d2);
  900.     if (n1 || n2) {
  901.       if (n1 && n2) {
  902.         return NaN;
  903.       } else if (n1) {
  904.         return (negative ? NEGATIVE_INFINITY : POSITIVE_INFINITY);
  905.       } else {
  906.         return (negative ? NEGATIVE_ZERO : ZERO);
  907.       }
  908.     }
  909.     // neither value is infinite
  910.     
  911.     // special handling of zero
  912.     n1 = isZero(d1);
  913.     n2 = isZero(d2);
  914.     if (n1 || n2) {
  915.       if (n1 && n2) {
  916.         return NaN;
  917.       } else if (n1) {
  918.         return (negative ? NEGATIVE_ZERO : ZERO);
  919.       } else {
  920.         return (negative ? NEGATIVE_INFINITY : POSITIVE_INFINITY);
  921.       }
  922.     }
  923.     // neither value is zero
  924.     
  925.     // unpack
  926.     long m1 = unpackMantissa(d1);
  927.     int x1 = unpackExponent(d1);
  928.     long m2 = unpackMantissa(d2);
  929.     int x2 = unpackExponent(d2);
  931.     // shift, divide, mod, repeat
  932.     long m = 0;
  933.     x1 -= x2;
  934.     while (true) {
  935.       int s = Math.min(BitUtils.countLeadingZeros(m1) - 1, 
  936.               BitUtils.countLeadingZeros(m));
  937.       if (s <= 8) {
  938.         if (m1 != 0) {
  939.           m |= 1;
  940.         }
  941.         break;
  942.       }
  943.       m1 <<= s;
  944.       m <<= s;
  945.       x1 -= s;
  946.       m |= m1 / m2;
  947.       m1 %= m2;
  948.     }
  949.     return pack(negative, x1, m);
  950.   }
  951.   
  952.   /**
  953.    * Returns the remainder of the two <code>double</code> arguments according to 
  954.    * <a href="http://java.sun.com/docs/books/jls/second_edition/html/expressions.doc.html#24956">section
  955.    * 15.17.3 of the JLS</a>.
  956.    * <p>
  957.    * This method takes the place of the <code>%</code> operator.
  958.    *
  959.    * @param   d1   the <code>double</code> dividend 
  960.    * @param   d2   the <code>double</code> divisor
  961.    * @return  the remainder of the two arguments
  962.    * @see #IEEEremainder(long, long)
  963.    */
  964.   public static long mod(long d1, long d2) {
  965.     if (isNaN(d1) || isNaN(d2) || isInfinite(d1) || isZero(d2)) {
  966.       return NaN;
  967.     } else if (isZero(d1) || isInfinite(d2)) {
  968.       return d1;
  969.     }
  970.     
  971.     // unpack
  972.     int x1 = unpackExponent(d1);
  973.     int x2 = unpackExponent(d2);
  974.     if (x1 < x2) {
  975.       return d1;
  976.     }
  977.     boolean n = unpackSign(d1);
  978.     long m1 = unpackMantissa(d1);
  979.     long m2 = unpackMantissa(d2);
  980.     if (x1 == x2) {
  981.       m1 %= m2;
  982.     } else {
  983.       // reduce m1 by left shifting and modding until the exponents x1 and x2 are 
  984.       // equal
  985.       while (x1 != x2) {
  986.         int s = Math.min(BitUtils.countLeadingZeros(m1) - 1, x1 - x2);
  987.         x1 -= s;
  988.         m1 = (m1 << s) % m2;
  989.       }
  990.     }
  991.     return pack(n, x1, m1);
  992.   }
  994.   
  995.   /////////////////////////////////////////////////////////////////////////////
  996.   // Rounding
  997.   /////////////////////////////////////////////////////////////////////////////
  999.   
  1000.   /**
  1001.    * Returns the <code>double</code> of greatest magnitude (furthest from zero)
  1002.    * that is equal to a mathematical integer and which has a mignitude not
  1003.    * greater than the argument's magnitude.  Special cases:
  1004.    * <ul><li>If the argument value is already equal to a mathematical 
  1005.    * integer, then the result is the same as the argument. 
  1006.    * <li>If the argument is NaN or an infinity or positive zero or 
  1007.    * negative zero, then the result is the same as the argument.</ul>
  1008.    *
  1009.    * @param   d   a <code>double</code> value.
  1010.    * @return the <code>double</code> of greatest magnitude (furthest from zero)
  1011.    *         whose magnitude is not greater than the argument's and which 
  1012.    *         is equal to a mathematical integer.
  1013.    */
  1014.   public static long truncate(long d) {
  1015.     return round(d, false, unpackSign(d));
  1016.   }
  1018.   /**
  1019.    * Mimics <a href="http://java.sun.com/j2se/1.4.2/docs/api/java/lang/Math.html#rint(double)">Math.rint(double)</a>.
  1020.    */
  1021.   public static long rint(long d) {
  1022.     return round(d, true, false);
  1023.   }
  1024.   
  1025.   /**
  1026.    * Mimics <a href="http://java.sun.com/j2se/1.4.2/docs/api/java/lang/Math.html#floor(double)">Math.floor(double)</a>.
  1027.    */
  1028.   public static long floor(long d) {
  1029.     return round(d, false, false);
  1030.   }
  1031.   
  1032.   /**
  1033.    * Mimcs <a href="http://java.sun.com/j2se/1.4.2/docs/api/java/lang/Math.html#ceil(double)">Math.ceil(double)</a>.
  1034.    */
  1035.   public static long ceil(long d) {
  1036.     return round(d, false, true);
  1037.   }
  1039.   /**
  1040.    * Mimcs <a href="http://java.sun.com/j2se/1.4.2/docs/api/java/lang/Math.html#round(double)">Math.round(double)</a>.
  1041.    */
  1042.   public static long round(long d) {
  1043.     return longValue(floor(add(d, ONE_HALF)));
  1044.   }
  1046.   private static long round(long d, boolean round, boolean ceil) {
  1047.     if (isNaN(d)) {
  1048.       return NaN;
  1049.     } else if (isZero(d) || isInfinite(d)) {
  1050.       return d;
  1051.     }
  1052.     int x = unpackExponent(d);
  1053.     if (x >= 0) {
  1054.       return d;
  1055.     }
  1056.     boolean n = unpackSign(d);
  1057.     long m = unpackMantissa(d);
  1058.     if (round) {
  1059.       m = BitUtils.roundingRightShift(m, -x);
  1060.     } else {
  1061.       long r;
  1062.       if (x <= -64) {
  1063.         r = m;
  1064.         m = 0;
  1065.       } else {
  1066.         r = m << (64 + x);
  1067.         m >>>= -x;
  1068.       }
  1069.       if ((n ^ ceil) && (r != 0)) {
  1070.         m++;
  1071.       }
  1072.     }
  1073.     return pack(n, 0, m);
  1074.   }
  1076.   
  1077.   /////////////////////////////////////////////////////////////////////////////
  1078.   // String Conversion
  1079.   /////////////////////////////////////////////////////////////////////////////
  1080.   
  1081.   // decimal -> binary 
  1082.   
  1083.   // base 2 mantissas for 10**-345 through 10**309, at intervals of 1000
  1084.   private static final long[] pow10m = {
  1085.           0xf4b0769e47eb5a79L, 0xeef453d6923bd65aL, 0xe95a99df8ace6f54L, 
  1086.           0xe3e27a444d8d98b8L, 0xde8b2b66b3bc4724L, 0xd953e8624b85dd79L, 
  1087.           0xd43bf0effdc0ba48L, 0xcf42894a5dce35eaL, 0xca66fa129f9b60a7L, 
  1088.           0xc5a890362fddbc63L, 0xc1069cd4eabe89f9L, 0xbc807527ed3e12bdL, 
  1089.           0xb8157268fdae9e4cL, 0xb3c4f1ba87bc8697L, 0xaf8e5410288e1b6fL, 
  1090.           0xab70fe17c79ac6caL, 0xa76c582338ed2622L, 0xa37fce126597973dL, 
  1091.           0x9faacf3df73609b1L, 0x9becce62836ac577L, 0x9845418c345644d7L, 
  1092.           0x94b3a202eb1c3f39L, 0x91376c36d99995beL, 0x8dd01fad907ffc3cL, 
  1093.           0x8a7d3eef7f1cfc52L, 0x873e4f75e2224e68L, 0x8412d9991ed58092L, 
  1094.           0x80fa687f881c7f8eL, 0xfbe9141915d7a922L, 0xf6019da07f549b2bL, 
  1095.           0xf03d93eebc589f88L, 0xea9c227723ee8bcbL, 0xe51c79a85916f485L, 
  1096.           0xdfbdcece67006ac9L, 0xda7f5bf590966849L, 0xd5605fcdcf32e1d7L, 
  1097.           0xd0601d8efc57b08cL, 0xcb7ddcdda26da269L, 0xc6b8e9b0709f109aL, 
  1098.           0xc21094364dfb5637L, 0xbd8430bd08277231L, 0xb913179899f68584L, 
  1099.           0xb4bca50b065abe63L, 0xb080392cc4349dedL, 0xac5d37d5b79b6239L, 
  1100.           0xa8530886b54dbdecL, 0xa46116538d0deb78L, 0xa086cfcd97bf97f4L, 
  1101.           0x9cc3a6eec6311a64L, 0x991711052d8bf3c5L, 0x9580869f0e7aac0fL, 
  1102.           0x91ff83775423cc06L, 0x8e938662882af53eL, 0x8b3c113c38f9f37fL, 
  1103.           0x87f8a8d4cfa417caL, 0x84c8d4dfd2c63f3bL, 0x81ac1fe293d599c0L, 
  1104.           0xfd442e4688bd304bL, 0xf7549530e188c129L, 0xf18899b1bc3f8ca2L, 
  1105.           0xebdf661791d60f56L, 0xe65829b3046b0afaL, 0xe0f218b8d25088b8L, 
  1106.           0xdbac6c247d62a584L, 0xd686619ba27255a3L, 0xd17f3b51fca3a7a1L, 
  1107.           0xcc963fee10b7d1b3L, 0xc7caba6e7c5382c9L, 0xc31bfa0fe5698db8L, 
  1108.           0xbe89523386091466L, 0xba121a4650e4ddecL, 0xb5b5ada8aaff80b8L, 
  1109.           0xb1736b96b6fd83b4L, 0xad4ab7112eb3929eL, 0xa93af6c6c79b5d2eL, 
  1110.           0xa54394fe1eedb8ffL, 0xa163ff802a3426a9L, 0x9d9ba7832936edc1L, 
  1111.           0x99ea0196163fa42eL, 0x964e858c91ba2655L, 0x92c8ae6b464fc96fL, 
  1112.           0x8f57fa54c2a9eab7L, 0x8bfbea76c619ef36L, 0x88b402f7fd75539bL, 
  1113.           0x857fcae62d8493a5L, 0x825ecc24c8737830L, 0xfea126b7d78186bdL, 
  1114.           0xf8a95fcf88747d94L, 0xf2d56790ab41c2a3L, 0xed246723473e3813L, 
  1115.           0xe7958cb87392c2c3L, 0xe2280b6c20dd5232L, 0xdcdb1b2798182245L, 
  1116.           0xd7adf884aa879177L, 0xd29fe4b18e88640fL, 0xcdb02555653131b6L, 
  1117.           0xc8de047564d20a8cL, 0xc428d05aa4751e4dL, 0xbf8fdb78849a5f97L, 
  1118.           0xbb127c53b17ec159L, 0xb6b00d69bb55c8d1L, 0xb267ed1940f1c61cL, 
  1119.           0xae397d8aa96c1b78L, 0xaa242499697392d3L, 0xa6274bbdd0fadd62L, 
  1120.           0xa2425ff75e14fc32L, 0x9e74d1b791e07e48L, 0x9abe14cd44753b53L, 
  1121.           0x971da05074da7befL, 0x9392ee8e921d5d07L, 0x901d7cf73ab0acd9L, 
  1122.           0x8cbccc096f5088ccL, 0x89705f4136b4a597L, 0x8637bd05af6c69b6L, 
  1123.           0x83126e978d4fdf3bL, 0x8000000000000000L, 0xfa00000000000000L, 
  1124.           0xf424000000000000L, 0xee6b280000000000L, 0xe8d4a51000000000L, 
  1125.           0xe35fa931a0000000L, 0xde0b6b3a76400000L, 0xd8d726b7177a8000L, 
  1126.           0xd3c21bcecceda100L, 0xcecb8f27f4200f3aL, 0xc9f2c9cd04674edfL, 
  1127.           0xc5371912364ce305L, 0xc097ce7bc90715b3L, 0xbc143fa4e250eb31L, 
  1128.           0xb7abc627050305aeL, 0xb35dbf821ae4f38cL, 0xaf298d050e4395d7L, 
  1129.           0xab0e93b6efee0054L, 0xa70c3c40a64e6c52L, 0xa321f2d7226895c8L, 
  1130.           0x9f4f2726179a2245L, 0x9b934c3b330c8577L, 0x97edd871cfda3a57L, 
  1131.           0x945e455f24fb1cf9L, 0x90e40fbeea1d3a4bL, 0x8d7eb76070a08aedL, 
  1132.           0x8a2dbf142dfcc7abL, 0x86f0ac99b4e8dafdL, 0x83c7088e1aab65dbL, 
  1133.           0x80b05e5ac60b6178L, 0xfb5878494ace3a5fL, 0xf5746577930d6501L, 
  1134.           0xefb3ab16c59b14a3L, 0xea1575143cf97227L, 0xe498f455c38b997aL, 
  1135.           0xdf3d5e9bc0f653e1L, 0xda01ee641a708deaL, 0xd4e5e2cdc1d1ea96L, 
  1136.           0xcfe87f7cef46ff17L, 0xcb090c8001ab551cL, 0xc646d63501a1511eL, 
  1137.           0xc1a12d2fc3978937L, 0xbd176620a501fc00L, 0xb8a8d9bbe123f018L, 
  1138.           0xb454e4a179dd1877L, 0xb01ae745b101e9e4L, 0xabfa45da0edbde69L, 
  1139.           0xa7f26836f282b733L, 0xa402b9c5a8d3a6e7L, 0xa02aa96b06deb0feL, 
  1140.           0x9c69a97284b578d8L, 0x98bf2f79d5993803L, 0x952ab45cfa97a0b3L, 
  1141.           0x91abb422ccb812efL, 0x8e41ade9fbebc27dL, 0x8aec23d680043beeL, 
  1142.           0x87aa9aff79042287L, 0x847c9b5d7c2e09b7L, 0x8161afb94b44f57dL, 
  1143.           0xfcb2cb35e702af78L, 0xf6c69a72a3989f5cL, 0xf0fdf2d3f3c30b9fL, 
  1144.           0xeb57ff22fc0c795aL, 0xe5d3ef282a242e82L, 0xe070f78d3927556bL, 
  1145.           0xdb2e51bfe9d0696aL, 0xd60b3bd56a5586f2L, 0xd106f86e69d785c8L, 
  1146.           0xcc20ce9bd35c78a5L, 0xc75809c42c684dd1L, 0xc2abf989935ddbfeL, 
  1147.           0xbe1bf1b059e9a8d6L, 0xb9a74a0637ce2ee1L, 0xb54d5e4a127f59c8L, 
  1148.           0xb10d8e1456105dadL, 0xace73cbfdc0bfb7bL, 0xa8d9d1535ce3b396L, 
  1149.           0xa4e4b66b68b65d61L, 0xa1075a24e4421731L, 0x9d412e0806e88aa6L, 
  1150.           0x9991a6f3d6bf1766L, 0x95f83d0a1fb69cd9L, 0x92746b9be2f8552cL, 
  1151.           0x8f05b1163ba6832dL, 0x8bab8eefb6409c1aL, 0x8865899617fb1871L, 
  1152.           0x8533285c936b35dfL, 0x8213f56a67f6b29cL, 0xfe0efb53d30dd4d8L, 
  1153.           0xf81aa16fdc1b81dbL, 0xf24a01a73cf2dcd0L, 0xec9c459d51852ba3L, 
  1154.           0xe7109bfba19c0c9dL, 0xe1a63853bbd26451L, 0xdc5c5301c56b75f7L, 
  1155.           0xd732290fbacaf134L, 0xd226fc195c6a2f8cL, 0xcd3a1230c43fb26fL, 
  1156.           0xc86ab5c39fa63441L, 0xc3b8358109e84f07L, 0xbf21e44003acdd2dL, 
  1157.           0xbaa718e68396cffeL, 0xb6472e511c81471eL, 0xb201833b35d63f73L, 
  1158.   };
  1159.   
  1160.   // base 2 exponents for 10**-345 through 10**309, at intervals of 1000
  1161.   private static final short[] pow10x = {
  1162.           -1146, -1136, -1126, -1116, -1106, -1096, -1086, -1076, 
  1163.           -1066, -1056, -1046, -1036, -1026, -1016, -1006, -996, 
  1164.           -986, -976, -966, -956, -946, -936, -926, -916, 
  1165.           -906, -896, -886, -876, -867, -857, -847, -837, 
  1166.           -827, -817, -807, -797, -787, -777, -767, -757, 
  1167.           -747, -737, -727, -717, -707, -697, -687, -677, 
  1168.           -667, -657, -647, -637, -627, -617, -607, -597, 
  1169.           -587, -578, -568, -558, -548, -538, -528, -518, 
  1170.           -508, -498, -488, -478, -468, -458, -448, -438, 
  1171.           -428, -418, -408, -398, -388, -378, -368, -358, 
  1172.           -348, -338, -328, -318, -308, -298, -289, -279, 
  1173.           -269, -259, -249, -239, -229, -219, -209, -199, 
  1174.           -189, -179, -169, -159, -149, -139, -129, -119, 
  1175.           -109, -99, -89, -79, -69, -59, -49, -39, 
  1176.           -29, -19, -9, 1, 10, 20, 30, 40, 
  1177.           50, 60, 70, 80, 90, 100, 110, 120, 
  1178.           130, 140, 150, 160, 170, 180, 190, 200, 
  1179.           210, 220, 230, 240, 250, 260, 270, 280, 
  1180.           290, 299, 309, 319, 329, 339, 349, 359, 
  1181.           369, 379, 389, 399, 409, 419, 429, 439, 
  1182.           449, 459, 469, 479, 489, 499, 509, 519, 
  1183.           529, 539, 549, 559, 569, 579, 588, 598, 
  1184.           608, 618, 628, 638, 648, 658, 668, 678, 
  1185.           688, 698, 708, 718, 728, 738, 748, 758, 
  1186.           768, 778, 788, 798, 808, 818, 828, 838, 
  1187.           848, 858, 868, 877, 887, 897, 907, 917, 
  1188.           927, 937, 947, 957, 967, 977, 987, 997, 
  1189.           1007, 1017, 1027, 
  1190.   };
  1192.   private static long decToDouble(boolean negative, int base10x, long base10m) {
  1193.     if (base10m == 0) {
  1194.       return (negative ? NEGATIVE_ZERO : ZERO);
  1195.     }
  1196.     // maximize base10m to ensure consistency between toString and parseDouble
  1197.     while ((base10m > 0) && (base10m <= 0x1999999999999999L)) { // (Long.MAX_VALUE / 5))) {
  1198.       base10m = (base10m << 3) + (base10m << 1);
  1199.       base10x--;
  1200.     }
  1201.     // base10x needs to be a multiple of 3, because the tables are
  1202.     // spaced at intervals of 1000 (not 10).
  1203.     base10x += 345;
  1204.     int mod = base10x % 3;
  1205.     base10x /= 3;
  1206.     if (base10x < 0) { // -345
  1207.       return (negative ? NEGATIVE_ZERO : ZERO);
  1208.     } else if (base10x > 218) { // 309
  1209.       return (negative ? NEGATIVE_INFINITY : POSITIVE_INFINITY);
  1210.     }
  1211.     int base2x = pow10x[base10x];
  1212.     int s = BitUtils.countLeadingZeros(base10m);
  1213.     base10m <<= s;
  1214.     base2x -= s;
  1215.     long base2m = dpMul(base10m, pow10m[base10x]);
  1216.     while (mod > 0) {
  1217.       if (base2m < 0) {
  1218.         base2m >>>= 1;
  1219.         base2x++;
  1220.       }
  1221.       base2m += base2m >>> 2;
  1222.       base2x += 3;
  1223.       mod--;
  1224.     }
  1225.     return pack(negative, base2x, base2m);
  1226.   }
  1228.   /**
  1229.    * Double-precision integer multiplication of x1 and x2.
  1230.    */
  1231.   private static final long dpMul(long x1, long x2) {
  1232.     long v1 = (x1 >>> 32)        * (x2 >>> 32);
  1233.     long v2 = (x1 & 0xffffffffL) * (x2 >>> 32);
  1234.     long v3 = (x1 >>> 32)        * (x2 & 0xffffffffL);
  1235.     v1 += v2 >>> 32;
  1236.     v1 += v3 >>> 32;
  1237.     if (((v2 + v3) << 32) < 0) {
  1238.       v1++;
  1239.     }
  1240.     return v1;
  1241.   }
  1242.   
  1243.   /**
  1244.    * Mimics <a href="http://java.sun.com/j2se/1.4.2/docs/api/java/lang/Double.html#parseDouble(String)">Double.parseDouble(String)</a>.
  1245.    * <p>
  1246.    * See the notes on <code>toString</code> for some caveats on String 
  1247.    * conversion.
  1248.    *
  1249.    * @see #toString
  1250.    * @exception  NumberFormatException  if the string does not contain a
  1251.    *               parsable number.
  1252.    */
  1253.   public static long parseDouble(String s) {
  1254.     // remove leading & trailing whitespace
  1255.     s = s.trim().toUpperCase();
  1256.     
  1257.     // check length
  1258.     int len = s.length();
  1259.     if (len == 0) {
  1260.       throw new NumberFormatException(s);
  1261.     }
  1262.     
  1263.     // check for NaN
  1264.     if ("NAN".equals(s)) {
  1265.       return NaN;
  1266.     }
  1267.     
  1268.     // begin parsing, one character at a time
  1269.     int idx = 0;
  1270.     
  1271.     // read sign
  1272.     boolean negative = false;
  1273.     char c = s.charAt(0);
  1274.     negative = (c == '-');
  1275.     if (negative || (c == '+')) {
  1276.       idx = 1;
  1277.     }
  1279.     // check for "Infinity"
  1280.     if (idx < len) {
  1281.       c = s.charAt(idx);
  1282.       if ((c == 'I') || (c == 'i')) {
  1283.         if ("INFINITY".equals(s.substring(idx))) {
  1284.           return (negative ? NEGATIVE_INFINITY : POSITIVE_INFINITY);
  1285.         }
  1286.       }
  1287.     }
  1289.     // read Digits.Digits
  1290.     long mantissa = 0;
  1291.     int exponent = 0;
  1292.     int fractionChars = 0;
  1293.     boolean sticky = false;
  1294.     boolean readingFraction = false;
  1295.     while (idx < len) {
  1296.       c = s.charAt(idx);
  1297.       if (c == '.') {
  1298.         if (readingFraction) {
  1299.           throw new NumberFormatException(s);
  1300.         }
  1301.         readingFraction = true;
  1302.       } else if ((c < '0') || (c > '9')) {
  1303.         break;
  1304.       } else {
  1305.         fractionChars++;
  1306.         if (mantissa <= 0x1999999999999998L) { // ((Long.MAX_VALUE / 5) - 1)
  1307.           mantissa = (mantissa << 3) + (mantissa << 1) + (c - '0');
  1308.           if (readingFraction) {
  1309.             exponent--;
  1310.           }
  1311.         } else {
  1312.           if (! readingFraction) {
  1313.             exponent++;
  1314.           }
  1315.           sticky |= (c != '0');
  1316.         }
  1317.       }
  1318.       idx++;
  1319.     }
  1320.     if (fractionChars == 0) {
  1321.       throw new NumberFormatException(s);
  1322.     }
  1323.     
  1324.     // read exponent
  1325.     if (((idx + 1) < len) && ((s.charAt(idx) == 'E') || (s.charAt(idx) == 'e'))) {
  1326.       try {
  1327.         exponent += Integer.parseInt(s.substring(idx + 1));
  1328.       } catch (NumberFormatException e) {
  1329.         throw new NumberFormatException(s);
  1330.       }
  1331.       idx = len;
  1332.     } else if (idx != len) {
  1333.       // check that we parsed the entire string
  1334.       throw new NumberFormatException(s);
  1335.     }
  1337.     // convert the decimal to a float
  1338.     return decToDouble(negative, exponent, mantissa);
  1339.   }
  1341.   // binary -> decimal
  1342.   
  1343.   // base 10 mantissas for 2**-1075 through 2**972, at intervals of 2**11
  1344.   private static final long[] pow2m = {
  1345.           0x3f3d8b077b8e0b11L, 0x81842f29f2cce376L, 0x1a8662f3b3919708L, 
  1346.           0x3652b62c71ce021dL, 0x6f40f20501a5e7a8L, 0xe3d8f9e563a198e5L, 
  1347.           0x2ea9c639a0e5b3ffL, 0x5f90f22001d66e96L, 0xc3b8358109e84f07L, 
  1348.           0x2815578d865470daL, 0x52173a79e8197a93L, 0xa81f301449ee8c70L, 
  1349.           0x226e6cf846d8ca6fL, 0x4683f19a2ab1bf59L, 0x906a617d450187e2L, 
  1350.           0x1d9388b3aa30a574L, 0x3c928069cf3cb734L, 0x7c0d50b7ee0dc0edL, 
  1351.           0xfe0efb53d30dd4d8L, 0x3407fbc42995e10bL, 0x6a8f537d42bc2b19L, 
  1352.           0xda3c0f568cc4f3e9L, 0x2cb1c756f2a408feL, 0x5b88c3416ddb353cL, 
  1353.           0xbb764c4ca7a44410L, 0x266469bcf5afc5d9L, 0x4ea0970403744553L, 
  1354.           0xa1075a24e4421731L, 0x20fa8ae248247913L, 0x438a53baf1f4ae3cL, 
  1355.           0x8a5296ffe33cc930L, 0x1c5416bb92e3e607L, 0x3a044721f1706ea6L, 
  1356.           0x76d1770e38320986L, 0xf356f7ebf83552feL, 0x31d602710b1a1374L, 
  1357.           0x6610674de9ae3c53L, 0xd106f86e69d785c8L, 0x2acf0bf77baab497L, 
  1358.           0x57ac20b32a535d5eL, 0xb38d92d760ec4455L, 0x24c5bfdd7761f2f6L, 
  1359.           0x4b4f5be23c2cf3a2L, 0x9a3c2087a63f6399L, 0x1f965966bce055efL, 
  1360.           0x40b0d7dca5a27abfL, 0x847c9b5d7c2e09b7L, 0x1b221effe500d3b5L, 
  1361.           0x3791a7ef666817f9L, 0x71ce24bb2fefcecaL, 0xe912b9d1478ceb17L, 
  1362.           0x2fbbbed612bfe181L, 0x61c209e792f16b87L, 0xc83553c5c8965d3dL, 
  1363.           0x2900ae716a34e9baL, 0x53f9341b79415b99L, 0xabfa45da0edbde69L, 
  1364.           0x233894a789cd2ec7L, 0x4821f50d63f209c9L, 0x93ba47c980e98ce0L, 
  1365.           0x1e412f0f768fad71L, 0x3df622f090826959L, 0x7ee5a7d0010b1532L, 
  1366.           0x19fd0fef9de8dfe3L, 0x353978b370747aa6L, 0x6d00f7320d3846f5L, 
  1367.           0xdf3d5e9bc0f653e1L, 0x2db830ddf3e8b84cL, 0x5da22ed4e5309410L, 
  1368.           0xbfc2ef456ae276e9L, 0x2745d2cb73b0391fL, 0x506e3af8bbc71cebL, 
  1369.           0xa4b8cab1a1563f52L, 0x21bc2b266d3a36bfL, 0x4516df8a16fe63d6L, 
  1370.           0x8d7eb76070a08aedL, 0x1cfa698c95390ba9L, 0x3b58e88c75313ecaL, 
  1371.           0x798b138e3fe1c845L, 0xf8ebad2b84e0d58cL, 0x32fa9be33ac0aeceL, 
  1372.           0x6867a5a867f103b3L, 0xd5d238a4abe98068L, 0x2bca63414390e576L, 
  1373.           0x59aedfc10d7279c6L, 0xb7abc627050305aeL, 0x259da6542d43623dL, 
  1374.           0x4d0985cb1d3608aeL, 0x9dc5ada82b70b59eL, 0x204fce5e3e250261L, 
  1375.           0x422ca8b0a00a4250L, 0x878678326eac9000L, 0x1bc16d674ec80000L, 
  1376.           0x38d7ea4c68000000L, 0x746a528800000000L, 0xee6b280000000000L, 
  1377.           0x30d4000000000000L, 0x6400000000000000L, 0xcccccccccccccccdL, 
  1378.           0x29f16b11c6d1e109L, 0x55e63b88c230e77eL, 0xafebff0bcb24aaffL, 
  1379.           0x24075f3dceac2b36L, 0x49c97747490eae84L, 0x971da05074da7befL, 
  1380.           0x1ef2d0f5da7dd8aaL, 0x3f61ed7ca0c03283L, 0x81ceb32c4b43fcf5L, 
  1381.           0x1a95a5b7f87a0ef1L, 0x3671f73b54f1c895L, 0x6f80f42fc8971bd2L, 
  1382.           0xe45c10c42a2b3b06L, 0x2ec49f14ec5fb056L, 0x5fc7edbc424d2fcbL, 
  1383.           0xc428d05aa4751e4dL, 0x282c674aadc39bb6L, 0x524675555bad4716L, 
  1384.           0xa87fea27a539e9a5L, 0x22823c3e2fc3c55bL, 0x46ac8391ca4529b0L, 
  1385.           0x90bd77f3483bb9baL, 0x1da48ce468e7c702L, 0x3cb559e42ad070a9L, 
  1386.           0x7c54afe7c43a3ecaL, 0xfea126b7d78186bdL, 0x3425eb41e9c7c9adL, 
  1387.           0x6acca251be03a951L, 0xdab99e59958885c5L, 0x2ccb7e3a7cd51959L, 
  1388.           0x5bbd6d030bf1dde6L, 0xbbe226efb628afebL, 0x267a8065858fe90cL, 
  1389.           0x4ecdd3c1949b76e0L, 0xa163ff802a3426a9L, 0x210d8432d2fc5833L, 
  1390.           0x43b12f82b63e2546L, 0x8aa22c0dbef60ee4L, 0x1c6463225ab7ec1dL, 
  1391.           0x3a25a835f947855aL, 0x7715d36033c5acc0L, 0xf3e2f893dec3f126L, 
  1392.           0x31f2ae9b9f14e0b2L, 0x664b1ff7085be8daL, 0xd17f3b51fca3a7a1L, 
  1393.           0x2ae7ad1f207d4454L, 0x57de91a832277568L, 0xb3f4e093db73a093L, 
  1394.           0x24dae7f3aec97265L, 0x4b7ab0078ad3dbf3L, 0x9a94dd3e8cf578baL, 
  1395.           0x1fa885c8d117a609L, 0x40d60ff149eacce0L, 0x84c8d4dfd2c63f3bL, 
  1396.           0x1b31bb5dc320d18fL, 0x37b1a07e7d30c7ccL, 0x720f9eb539bbf765L, 
  1397.           0xe998d258869facd7L, 0x2fd735519e3bbc2eL, 0x61fa48553bdeb07eL, 
  1398.           0xc8a883c0fdaf7df0L, 0x29184594e3437adeL, 0x542984435aa6def6L, 
  1399.           0xac5d37d5b79b6239L, 0x234cd83c273db92fL, 0x484b75379c244c28L, 
  1400.           0x940f4613ae5ed137L, 0x1e5297287c2f4579L, 0x3e19c9072331b530L, 
  1401.           0x7f2eaa0a85848581L, 0x1a0c03b1df8af611L, 0x355817f373ccb876L, 
  1402.           0x6d3fadfac84b3424L, 0xdfbdcece67006ac9L, 0x2dd27ebb4504974eL, 
  1403.           0x5dd80dc941929e51L, 0xc0314325637a193aL, 0x275c6b23eb69b26dL, 
  1404.           0x509c814fb511cfb9L, 0xa5178fff668ae0b6L, 0x21cf93dd7888939aL, 
  1405.           0x453e9f77bf8e7e29L, 0x8dd01fad907ffc3cL, 0x1d0b15a491eb8459L, 
  1406.           0x3b7b0d9ac471b2e4L, 0x79d1013cf6ab6a45L, 0xf97ae3d0d2446f25L, 
  1407.           0x3317f065bfbf5f43L
  1408.  };
  1409.           
  1410.   // base 10 exponents for 2**-1075 through 2**972, at intervals of 2**11
  1411.   private static final short[] pow2x = {
  1412.           -323, -320, -316, -313, -310, -307, -303, -300, 
  1413.           -297, -293, -290, -287, -283, -280, -277, -273, 
  1414.           -270, -267, -264, -260, -257, -254, -250, -247, 
  1415.           -244, -240, -237, -234, -230, -227, -224, -220, 
  1416.           -217, -214, -211, -207, -204, -201, -197, -194, 
  1417.           -191, -187, -184, -181, -177, -174, -171, -167, 
  1418.           -164, -161, -158, -154, -151, -148, -144, -141, 
  1419.           -138, -134, -131, -128, -124, -121, -118, -114, 
  1420.           -111, -108, -105, -101, -98, -95, -91, -88, 
  1421.           -85, -81, -78, -75, -71, -68, -65, -62, 
  1422.           -58, -55, -52, -48, -45, -42, -38, -35, 
  1423.           -32, -28, -25, -22, -18, -15, -12, -9, 
  1424.           -5, -2, 1, 5, 8, 11, 15, 18, 
  1425.           21, 25, 28, 31, 35, 38, 41, 44, 
  1426.           48, 51, 54, 58, 61, 64, 68, 71, 
  1427.           74, 78, 81, 84, 87, 91, 94, 97, 
  1428.           101, 104, 107, 111, 114, 117, 121, 124, 
  1429.           127, 131, 134, 137, 140, 144, 147, 150, 
  1430.           154, 157, 160, 164, 167, 170, 174, 177, 
  1431.           180, 184, 187, 190, 193, 197, 200, 203, 
  1432.           207, 210, 213, 217, 220, 223, 227, 230, 
  1433.           233, 237, 240, 243, 246, 250, 253, 256, 
  1434.           260, 263, 266, 270, 273, 276, 280, 283, 
  1435.           286, 289, 293 
  1436.   } ;
  1438.   /**
  1439.    * Mimics <a href="http://java.sun.com/j2se/1.4.2/docs/api/java/lang/Double.html#toString(double)">Double.toString(double)</a>.
  1440.    * <p>
  1441.    * String conversion is a bit of a gray area.  The J2SE implementation of
  1442.    * this function (<code>Double.toString(double)</code> has some problems.  
  1443.    * Often times it does not return the shortest valid String, even though it 
  1444.    * claims to do so, and it has a few
  1445.    * corner cases where it behaves oddly (e.g. 0.001 gets converted to 
  1446.    * the String "0.0010").
  1447.    * <p>
  1448.    * The implementation in MicroDouble uses a much simpler table-based 
  1449.    * algorithm.  It frequently returns slightly different results than 
  1450.    * <code>Double.toString(double)</code>.  Sometimes the results are better,
  1451.    * and sometimes worse.  Ususally the difference is confined to the last
  1452.    * character, which may be different or missing in one of the results.
  1453.    */
  1454.   public static String toString(long d) {
  1455.     return toString(d, 100);
  1456.   }
  1457.   
  1458.   /**
  1459.    * Returns a string representation of the double argument, rounded so that
  1460.    * the returned <code>String</code> is no longer than
  1461.    * <code>maxStringLength</code> characters (or 9 characters, if 
  1462.    * <code>maxStringLength</code> is less than 9).  
  1463.    *
  1464.    * @param      d   the <code>double</code> to be converted.
  1465.    * @param      maxStringLength the maximum length of the returned string 
  1466.    * @return     a string representation of the argument.
  1467.    *
  1468.    * @see #toString(long)
  1469.    */
  1470.   public static String toString(long d, int maxStringLength) {
  1471.     if (isNaN(d)) {
  1472.       return "NaN";
  1473.     }
  1474.     boolean n = unpackSign(d);
  1475.     if (isZero(d)) {
  1476.       return (n ? "-0.0" : "0.0");
  1477.     } else if (isInfinite(d)) {
  1478.       return (n ? "-Infinity" : "Infinity");
  1479.     }
  1480.     if (maxStringLength < 9) {
  1481.       maxStringLength = 9;
  1482.     }
  1483.     // convert from base 2 to base 10
  1484.     int base2x = unpackExponent(d);
  1485.     long base2m = unpackMantissa(d);
  1486.     int idx = base2x + 1075;
  1487.     int dx = idx % 11;
  1488.     base2m <<= dx;
  1489.     idx /= 11;
  1490.     int base10x = pow2x[idx];
  1491.     while (base2m <= 0xcccccccccccccccL) {
  1492.       base2m = (base2m << 3) + (base2m << 1); // base2m *= 10;
  1493.       base10x--;
  1494.     }
  1495.     long base10m = dpMul(base2m, pow2m[idx]);
  1496.     boolean roundedUp = false;
  1497.     while (true) {
  1498.       int r = (int) (base10m % 10);
  1499.       long mt = base10m / 10;
  1500.       int xt = base10x + 1;
  1501.       if (r != 0) {
  1502.         boolean rut;
  1503.         if ((r > 5) || ((r == 5) && (! roundedUp))) {
  1504.           rut = true;
  1505.           mt++;
  1506.         } else {
  1507.           rut = false;
  1508.         }
  1509.         long dt = decToDouble(n, xt, mt);
  1510.         if (dt != d) {
  1511.           if (rut) {
  1512.             mt--;
  1513.           } else {
  1514.             mt++;
  1515.           }
  1516.           rut ^= true;
  1517.           dt = decToDouble(n, xt, mt);
  1518.           if (dt != d) {
  1519.             break;
  1520.           }
  1521.         }
  1522.         roundedUp = rut;
  1523.       }
  1524.       base10m = mt;
  1525.       base10x = xt;
  1526.     }
  1527.     
  1528.     while (true) {
  1529.       String s = toString(n, base10x, base10m);
  1530.       if (s.length() <= maxStringLength) {
  1531.         return s;
  1532.       }
  1533.       int r = (int) (base10m % 10);
  1534.       base10m /= 10;
  1535.       base10x++;
  1536.       if ((r > 5) || ((r == 5) && (! roundedUp))) {
  1537.         roundedUp = true;
  1538.         base10m++;
  1539.       } else {
  1540.         roundedUp = false;
  1541.       }      
  1542.       while ((base10m % 10) == 0) {
  1543.         base10m /= 10;
  1544.         base10x++;
  1545.       }
  1546.     }
  1547.   }
  1548.   
  1549.   private static String toString(boolean negative, int base10x, long base10m) {
  1550.     StringBuffer sb = new StringBuffer(26);
  1551.     if (negative) {
  1552.       sb.append('-');
  1553.     }
  1554.     String s = Long.toString(base10m);
  1555.     base10x += s.length() - 1;
  1556.     boolean scientific = ((base10x < -3) || (base10x >= 7));
  1557.     int dp; // index of decimal point in final string
  1558.     if (scientific) {
  1559.       dp = 1;
  1560.     } else {
  1561.       dp = base10x + 1;
  1562.       if (dp < 1) {
  1563.         sb.append('0');
  1564.       }
  1565.     }
  1566.     for (int i=0; i<dp; i++) {
  1567.       if (i < s.length()) {
  1568.         sb.append(s.charAt(i));
  1569.       } else {
  1570.         sb.append('0');
  1571.       }
  1572.     }
  1573.     sb.append('.');
  1574.     if (dp >= s.length()) {
  1575.       sb.append('0');
  1576.     } else {
  1577.       for (int i=dp; i<s.length(); i++) {
  1578.         if (i < 0) {
  1579.           sb.append('0');
  1580.         } else {
  1581.           sb.append(s.charAt(i));
  1582.         }
  1583.       }
  1584.     }
  1585.     if (scientific) {
  1586.       sb.append('E');
  1587.       sb.append(Integer.toString(base10x));
  1588.     }
  1589.     return sb.toString();
  1590.   }
  1592.   private static final long ONE_EIGHTY =           0x4066800000000000L;
  1593.   private static final long TWO_HUNDRED =          0x4069000000000000L;
  1594.   
  1595.   /**
  1596.    * Mimics <a href="http://java.sun.com/j2se/1.4.2/docs/api/java/lang/Math.html#toDegrees(double)">Math.toDegrees(double)</a>.
  1597.    */
  1598.   public static long toDegrees(long angrad) {
  1599.     return div(mul(angrad, ONE_EIGHTY), PI);
  1600.   }
  1601.   
  1602.   /**
  1603.    * Mimics <a href="http://java.sun.com/j2se/1.4.2/docs/api/java/lang/Math.html#toRadians(double)">Math.toRadians(double)</a>.
  1604.    */
  1605.   public static long toRadians(long angdeg) {
  1606.     return mul(div(angdeg, ONE_EIGHTY), PI);
  1607.   }
  1609.   public static long toGradians(long angrad) {
  1610.     return div(mul(angrad, TWO_HUNDRED), PI);
  1611.   }
  1613.   public static long gradiansToRadians(long anggrad) {
  1614.     return mul(div(anggrad, TWO_HUNDRED), PI);
  1615.   }
  1616.   
  1617.   /////////////////////////////////////////////////////////////////////////////
  1618.   // Elementary functions.  Most are ported directly from fdlibm.
  1619.   /////////////////////////////////////////////////////////////////////////////
  1621.   private static long set(int newHiPart, int newLowPart) {
  1622.     return ((((long) newHiPart) << 32) | newLowPart);
  1623.   }
  1625.   private static long setLO(long d, int newLowPart) {
  1626.     return ((d & 0xFFFFFFFF00000000L) | newLowPart);
  1627.   }
  1629.   private static long setHI(long d, int newHiPart) {
  1630.     return ((d & 0x00000000FFFFFFFFL) | (((long) newHiPart) << 32));
  1631.   }
  1633.   private static int getHI(long d) {
  1634.     return ((int) (d >> 32));
  1635.   }
  1636.   
  1637.   private static int getLO(long d) {
  1638.     return ((int) d);
  1639.   }
  1641.   private static int ilogb(long d) {
  1642.     if (isZero(d)) {
  1643.       return 0x80000001;
  1644.     } else if (isNaN(d) || (isInfinite(d))) {
  1645.       return 0x7fffffff;
  1646.     }
  1647.     int x = (((int) (d >> 52)) & 0x7ff);
  1648.     if (x == 0) {
  1649.       long m = (d & FRACTION_MASK);
  1650.       while (m < IMPLIED_ONE) {
  1651.         m <<= 1;
  1652.         x--;
  1653.       }
  1654.     }
  1655.     return x - 1023;
  1656.   }
  1657.   
  1658.   /**
  1659.    * @return the magnitude of x with the sign of y
  1660.    */
  1661.   private static long copySign(long x, long y) {
  1662.     return (x & 0x7fffffffffffffffL) | (y & 0x8000000000000000L);
  1663.   }
  1665.   /** 
  1666.    * Returns the value of the first argument, multiplied by 2 raised to the
  1667.    * power of the second argument.  Note that the second argument is really
  1668.    * an <code>int</code>, not a <code>float</code> or <code>double</code>.
  1669.    *
  1670.    * @param d   a <code>double</code> value.
  1671.    * @param n   an <code>int</code> value.
  1672.    * @return  the value <code>d * 2<sup>n</sup></code>.
  1673.    */
  1674.   public static long scalbn(long d, int n) {
  1675.     if (isNaN(d)) {
  1676.       return NaN;
  1677.     } else if ((n == 0) || isInfinite(d) || isZero(d)) {
  1678.       return d;
  1679.     } else if (n >= 2098) {
  1680.       return copySign(POSITIVE_INFINITY, d);
  1681.     } else if (n <= -2099) {
  1682.       return copySign(ZERO, d);
  1683.     }
  1684.     int x = ((int) (d >> 52) & 0x7ff);
  1685.     int x2 = x + n;
  1686.     if ((x == 0) || (x2 <= 0)) { // argument and/or return value are subnormal 
  1687.       return pack(unpackSign(d), x2 - 1075, unpackMantissa(d));
  1688.     } else if (x2 >= 0x7ff) { // overflow
  1689.       return copySign(POSITIVE_INFINITY, d);
  1690.     }
  1691.     return ((d & 0x800fffffffffffffL) | (((long) x2) << 52));
  1692.   }
  1694.   /**
  1695.    * Mimics <a href="http://java.sun.com/j2se/1.4.2/docs/api/java/lang/Math.html#IEEEremainder(double, double)">Math.IEEEremainder(double, double)</a>.
  1696.    */
  1697.   public static long IEEEremainder(long d1, long d2) {
  1698.     if (isNaN(d1) || isNaN(d2) || isInfinite(d1) || isZero(d2)) {
  1699.       return NaN;
  1700.     } else if (isZero(d1) || isInfinite(d2)) {
  1701.       return d1;
  1702.     }
  1703.     int hx = getHI(d1); // high word of x 
  1704.     int lx = getLO(d1); // low  word of x 
  1705.     int hp = getHI(d2); // high word of p 
  1706.     int lp = getLO(d2); // low  word of p 
  1707.     boolean negative = unpackSign(d1);
  1708.     hp &= 0x7fffffff;
  1709.     hx &= 0x7fffffff;
  1711.     if (hp<=0x7fdfffff) d1 = mod(d1,scalbn(d2, 1)); // now x < 2p 
  1712.     if (((hx-hp)|(lx-lp))==0) return ZERO; //zero*x;
  1713.     d1  = abs(d1);
  1714.     d2  = abs(d2);
  1715.     if (hp<0x00200000) {
  1716.       if(gt(scalbn(d1, 1), d2)) {
  1717.         d1 = sub(d1, d2);
  1718.         if (ge(scalbn(d1, 1), d2)) d1 = sub(d1, d2);
  1719.       }
  1720.     } else {
  1721.       long p_half = scalbn(d2, -1);
  1722.       if (gt(d1, p_half)) {
  1723.         d1 = sub(d1, d2);
  1724.         if (ge(d1, p_half)) d1 = sub(d1, d2);
  1725.       }
  1726.     }
  1727.     if (negative) {
  1728.       return negate(d1);
  1729.     }
  1730.     return d1;
  1731.   }
  1733.   /**
  1734.    * Mimics <a href="http://java.sun.com/j2se/1.4.2/docs/api/java/lang/Math.html#sqrt(double)">Math.sqrt(double)</a>.
  1735.    */
  1736.   public static long sqrt(long d) {
  1737.     if (isZero(d)) {
  1738.       return d;
  1739.     } else if (unpackSign(d) || isNaN(d)) {
  1740.       return NaN;
  1741.     } else if (d == POSITIVE_INFINITY) {
  1742.       return d;
  1743.     }
  1744.     // f is positive, nonzero, and finite
  1746.     // unpack
  1747.     int x = unpackExponent(d);
  1748.     long m = unpackMantissa(d);
  1749.     // normalize 
  1750.     while (m < IMPLIED_ONE) {
  1751.       m <<= 1;
  1752.       x--;
  1753.     }
  1754.     // make exponent even
  1755.     if ((x & 1) != 0) {
  1756.       m <<= 1;
  1757.     }
  1758.     // compute final exponent
  1759.     x = (x >> 1) - 26;
  1760.     
  1761.     // generate sqrt(x) bit by bit
  1762.     m <<= 1;
  1763.     long q = 0L; // q = sqrt(x)
  1764.     long s = 0L;
  1765.     long r = 0x0020000000000000L;
  1766.     while (r != 0) {
  1767.       long t = s + r;
  1768.       if (t < m) {
  1769.         s = t + r;
  1770.         m -= t;
  1771.         q |= r;
  1772.       }
  1773.       m <<= 1;
  1774.       r >>= 1;
  1775.     }
  1776.     // round half even
  1777.     if (m != 0) {
  1778.       q += q & 1L;
  1779.     }
  1780.     q >>= 1;
  1781.     return (((x + 1075L) << 52) | (q & FRACTION_MASK));
  1782.   }
  1783.   
  1784.   private static final long EXP_UNDERFLOW = 0xc0874910d52d3051L; // -745.13321910194110842
  1785.   private static final long EXP_OVERFLOW  = 0x40862e42fefa39efL; // 709.782712893383973096
  1786.   private static final long LN2_HI        = 0x3fe62e42fee00000L;
  1787.   private static final long LN2_LO        = 0x3dea39ef35793c76L; //  1.90821492927058770002e-10
  1788.   private static final long INV_LN2       = 0x3ff71547652b82feL; //  1.44269504088896338700e+00
  1789.   private static final long P1            = 0x3fc555555555553eL; //  1.66666666666666019037e-01
  1790.   private static final long P2            = 0xbf66c16c16bebd93L; // -2.77777777770155933842e-03
  1791.   private static final long P3            = 0x3f11566aaf25de2cL; //  6.61375632143793436117e-05
  1792.   private static final long P4            = 0xbebbbd41c5d26bf1L; // -1.65339022054652515390e-06
  1793.   private static final long P5            = 0x3e66376972bea4d0L; //  4.13813679705723846039e-08
  1795.   /**
  1796.    * Mimics <a href="http://java.sun.com/j2se/1.4.2/docs/api/java/lang/Math.html#exp(double)">Math.exp(double)</a>.
  1797.    */
  1798.   public static long exp(long d) {
  1799.     long x = d;
  1800.     if (isNaN(x)) {
  1801.       return NaN;
  1802.     } else if (isZero(x)) {
  1803.       return ONE;
  1804.     } else if (le(x, EXP_UNDERFLOW)) {
  1805.       return ZERO;
  1806.     } else if (ge(x, EXP_OVERFLOW)) {
  1807.       return POSITIVE_INFINITY;
  1808.     }
  1810.     // argument reduction
  1811.     long hi=0, lo=0;
  1812.     int k=0;
  1813.     int hx = getHI(x) & 0x7fffffff;
  1814.     if (hx > 0x3fd62e42) { // if |x| > 0.5 ln2
  1815.       if (hx < 0x3ff0a2b2) { // and |x| < 1.5 ln2
  1816.         if (unpackSign(x)) {
  1817.           hi = add(x, LN2_HI);
  1818.           lo = LN2_LO | SIGN_MASK;
  1819.           k = -1;
  1820.         } else {
  1821.           hi = sub(x, LN2_HI);
  1822.           lo = LN2_LO;
  1823.           k = 1;
  1824.         }
  1825.       } else {
  1826.         long t = rint(mul(INV_LN2, x));
  1827.         k = intValue(t);
  1828.         hi = sub(x, mul(t, LN2_HI));
  1829.         lo = mul(t, LN2_LO);
  1830.       }
  1831.       x = sub(hi, lo);
  1832.     } else if (hx < 0x3e300000) { // when |x| < 2**-28
  1833.       return add(x, ONE);
  1834.     } else {
  1835.       k = 0;
  1836.     }
  1837.     long t  = mul(x, x);
  1838.     long c = sub(x, mul(t, add(P1, mul(t, add(P2, mul(t, 
  1839.             add(P3, mul(t, add(P4, mul(t, P5))))))))));
  1840.     if (k == 0) {
  1841.       return sub(ONE, sub(div(mul(x, c), 
  1842.               sub(c, TWO)), x));
  1843.     } 
  1844.     x = sub(ONE, sub(sub(lo, div(mul(x, c), 
  1845.             sub(TWO, c))), hi));
  1846.     return scalbn(x, k);
  1847.   }
  1849.   // scaled coefficients related to expm1 
  1850.   private static final long Q1 = 0xBFA11111111110F4L; // -3.33333333333331316428e-02
  1851.   private static final long Q2 = 0x3F5A01A019FE5585L; // 1.58730158725481460165e-03
  1852.   private static final long Q3 = 0xBF14CE199EAADBB7L; // -7.93650757867487942473e-05
  1853.   private static final long Q4 = 0x3ED0CFCA86E65239L; // 4.00821782732936239552e-06
  1854.   private static final long Q5 = 0xBE8AFDB76E09C32DL; // -2.01099218183624371326e-07
  1856.   /**
  1857.    * Returns Euler's number <i>e</i> raised to the power of a
  1858.    * <code>double</code> value, less 1, computed in a way that is accurate
  1859.    * even when the value of d is close to zero.
  1860.    *
  1861.    * @param   d   the exponent to raise <i>e</i> to.
  1862.    * @return  the value <i>e</i><sup><code>d</code></sup><code> - 1</code>, 
  1863.    *          where <i>e</i> is the base of the natural logarithms.
  1864.    * @see #exp(long)
  1865.    * @see #log1p(long)
  1866.    */
  1867.   public static long expm1(long d) {
  1868.     int hx = getHI(d); // high word of x
  1869.     int xsb = hx & 0x80000000; // sign bit of x
  1870.     long y;
  1871.     if (xsb==0) y=d; else y= -d; // y = |x| 
  1872.     hx &= 0x7fffffff; // high word of |x| 
  1874.     // filter out huge and non-finite argument
  1875.     if(hx >= 0x4043687A) { // if |x|>=56*ln2 
  1876.       if(hx >= 0x40862E42) { // if |x|>=709.78... 
  1877.         if(hx>=0x7ff00000) {
  1878.           if(((hx&0xfffff)|getLO(d))!=0) 
  1879.                return NaN;
  1880.           else return (xsb==0)? d : NEGATIVE_ONE; // exp(+-inf)={inf,-1}
  1881.         }
  1882.         if(d > 0x40862E42FEFA39EFL) return POSITIVE_INFINITY; // 7.09782712893383973096e+02 
  1883.       }
  1884.       if(xsb!=0) { // x < -56*ln2, return -1.0 with inexact 
  1885.         return NEGATIVE_ONE;
  1886.       }
  1887.     }
  1889.     // argument reduction
  1890.     long hi, lo, c;
  1891.     int k;
  1892.     if(hx > 0x3fd62e42) { //  if  |x| > 0.5 ln2 
  1893.       if(hx < 0x3FF0A2B2) { // and |x| < 1.5 ln2 
  1894.         if(xsb==0) {
  1895.           hi = sub(d, LN2_HI);
  1896.           lo = LN2_LO;
  1897.           k = 1;
  1898.         } else {
  1899.           hi = add(d, LN2_HI);