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

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

J2ME

开发平台：

Java

MicroFloat.java：源码内容
  1. // $Id: MicroFloat.java,v 1.2 2004/08/03 04:57:42 Dave Exp $
  2. /*
  3.  * Float.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.  */
  21. package net.dclausen.microfloat;
  22. //Download by http://www.codefans.net
  23. /**
  24.  * A software implementation of IEEE-754 single precision math which does not
  25.  * rely on the <code>float</code> data type. 
  26.  * This class overloads the <code>int</code> data type by storing 
  27.  * <code>float</code> data in it.
  28.  * See the 
  29.  * <a href="package-summary.html#package_description">package description</a> 
  30.  * for more information.
  31.  * <p>
  32.  * @author David Clausen
  33.  * @see <a href="http://java.sun.com/j2se/1.4.2/docs/api/java/lang/Float.html">Float</a>
  34.  * @see MicroDouble
  35.  * @version $Revision: 1.2 $
  36.  */
  37. public final class MicroFloat {
  39.   /////////////////////////////////////////////////////////////////////////////
  40.   // General-purpose constants
  41.   /////////////////////////////////////////////////////////////////////////////
  43.   /**
  44.    * A constant representing the same value as 
  45.    * <a href="http://java.sun.com/j2se/1.4.2/docs/api/java/lang/Float.html#POSITIVE_INFINITY">Float.POSITIVE_INFINITY</a>
  46.    */
  47.   public  static final int POSITIVE_INFINITY = 0x7f800000;
  49.   /**
  50.    * A constant holding the same value as 
  51.    * <a href="http://java.sun.com/j2se/1.4.2/docs/api/java/lang/Float.html#NEGATIVE_INFINITY">Float.NEGATIVE_INFINITY</a>
  52.    */
  53.   public  static final int NEGATIVE_INFINITY = 0xff800000;
  54.   
  55.   /**
  56.    * A constant holding the same value as
  57.    * <a href="http://java.sun.com/j2se/1.4.2/docs/api/java/lang/Float.html#NaN">Float.NaN</a>
  58.    */
  59.   public  static final int NaN               = 0x7fc00000;
  61.   /**
  62.    * A constant holding the same value as 
  63.    * <a href="http://java.sun.com/j2se/1.4.2/docs/api/java/lang/Float.html#MAX_VALUE">Float.MAX_VALUE</a>
  64.    */
  65.   public  static final int MAX_VALUE         = 0x7f7fffff;
  66.   
  67.   /**
  68.    * A constant holding the same value as
  69.    * <a href="http://java.sun.com/j2se/1.4.2/docs/api/java/lang/Float.html#MIN_VALUE">Float.MIN_VALUE</a>
  70.    */
  71.   public  static final int MIN_VALUE         = 0x00000001;
  73.   /**
  74.    * A single-precision version of {@link MicroDouble#E}
  75.    */
  76.   public  static final int E                 = 0x402df854;
  78.   /**
  79.    * A single-precision version of {@link MicroDouble#PI}
  80.    */
  81.   public  static final int PI                = 0x40490fdb;
  82.   
  83.   // Other constants needed internally, and exposed as a convenience.
  84.   
  85.   /** A constant holding the value of 0.0f */
  86.   public static final int ZERO              = 0x00000000;
  88.   /** A constant holding the value of -0.0f */
  89.   public static final int NEGATIVE_ZERO     = 0x80000000;
  91.   /** A constant holding the value of 1.0f */
  92.   public static final int ONE               = 0x3f800000;
  94.   /** A constant holding the value of 2.0f */
  95.   public static final int TWO               = 0x40000000;
  97.   /** A constant holding the value of 0.5f */
  98.   public static final int ONE_HALF          = 0x3f000000;
  99.   
  101.   /////////////////////////////////////////////////////////////////////////////
  102.   // Packing and unpacking the IEEE-754 single precision format
  103.   /////////////////////////////////////////////////////////////////////////////
  105.   private static final int ABS_MASK          = 0x7fffffff;
  106.   private static final int SIGN_MASK         = 0x80000000; // 1 bit
  107.   private static final int EXPONENT_MASK     = 0x7f800000; // 8 bits
  108.   private static final int FRACTION_MASK     = 0x007fffff; // 23 bits
  109.   private static final int IMPLIED_ONE       = 0x00800000; // 24th bit
  111.   /** @return true iff d is negative */
  112.   static boolean unpackSign(int f) {
  113.     return (f < 0);
  114.   }
  116.   /** @return an integer in the range [-150, 105] */
  117.   static int unpackExponent(int f) {
  118.     return ((f >> 23) & 0xff) - 150;
  119.   }
  120.   
  121.   /** @return an integer in the range [0, 0x00ffffff] */
  122.   static int unpackMantissa(int f) {
  123.     if ((f & EXPONENT_MASK) == 0) {
  124.       return ((f & FRACTION_MASK) << 1);
  125.     } else {
  126.       return ((f & FRACTION_MASK) | IMPLIED_ONE);
  127.     }
  128.   }
  130.   /** 
  131.    * @return the float which most closely represents the given base-2 mantissa
  132.    *         and exponent
  133.    */
  134.   static int pack(boolean negative, int exponent, int mantissa) {
  135.     // left align mantissa
  136.     int shift = BitUtils.countLeadingZeros(mantissa);
  137.     mantissa <<= shift;
  138.     exponent -= shift;
  139.     return pack2(negative, exponent, mantissa);
  140.   }
  142.   /** 
  143.    * @return the float which most closely represents the given base-2 mantissa
  144.    *         and exponent
  145.    */
  146.   static int pack(boolean negative, int exponent, long mantissa) {
  147.     // shift mantissa so that it is left-aligned when cast to an int
  148.     int shift = 32 - BitUtils.countLeadingZeros(mantissa);
  149.     exponent += shift;
  150.     if (shift > 0) {
  151.       mantissa = BitUtils.stickyRightShift(mantissa, shift);
  152.     } else if (shift < 0) {
  153.       mantissa <<= -shift;
  154.     }
  155.     return pack2(negative, exponent, (int) mantissa);
  156.   }
  158.   /**
  159.    * @param mantissa must be left aligned (or zero)
  160.    */
  161.   private static int pack2(boolean negative, int exponent, int mantissa) {
  162.     // reduce precision of mantissa, rounding if necessary
  163.     if (mantissa != 0) {
  164.       if (exponent < -157) {
  165.         // subnormal
  166.         mantissa = BitUtils.roundingRightShift(mantissa, -149 - exponent);
  167.       } else {
  168.         // normal
  169.         mantissa = BitUtils.roundingRightShift(mantissa, 8);
  170.         if (mantissa == 0x1000000) {
  171.           // oops, the rounding carried into the 25th bit
  172.           mantissa = 0x800000;
  173.           exponent++;
  174.         }
  175.         // pack the exponent
  176.         if (exponent > 96) {
  177.           mantissa = POSITIVE_INFINITY;
  178.         } else {
  179.           mantissa ^= IMPLIED_ONE;
  180.           mantissa |= (exponent + 158) << 23;
  181.         }
  182.       }
  183.     }
  185.     // pack the sign bit
  186.     if (negative) {
  187.       mantissa |= SIGN_MASK;
  188.     }
  189.     
  190.     return mantissa;
  191.   }
  193.   
  194.   /////////////////////////////////////////////////////////////////////////////
  195.   // Simple tests 
  196.   /////////////////////////////////////////////////////////////////////////////
  198.   /**
  199.    * Mimics 
  200.    * <a href="http://java.sun.com/j2se/1.4.2/docs/api/java/lang/Float.html#isNaN(float)">Float.isNaN(float)</a>
  201.    */
  202.   public static boolean isNaN(int f) {
  203.     return ((f & ABS_MASK) > POSITIVE_INFINITY);
  204.   }
  206.   /**
  207.    * Mimics
  208.    * <a href="http://java.sun.com/j2se/1.4.2/docs/api/java/lang/Float.html#isInfinite(float)">Float.isInfinite(float)</a>
  209.    */
  210.   public static boolean isInfinite(int f) {
  211.     return ((f & ABS_MASK) == POSITIVE_INFINITY);
  212.   }
  213.   
  214.   /**
  215.    * Returns <code>true</code> if the specified number has zero
  216.    * magnitude, <code>false</code> otherwise.
  217.    *
  218.    * @param   f   the <code>float</code> value to be tested.
  219.    * @return  <code>true</code> if the value of the argument is positive
  220.    *          zero or negative zero; <code>false</code> otherwise.
  221.    */
  222.   public static boolean isZero(int f) {
  223.     return ((f & ABS_MASK) == 0);
  224.   }
  226.   
  227.   /////////////////////////////////////////////////////////////////////////////
  228.   // Sign changes
  229.   /////////////////////////////////////////////////////////////////////////////
  230.   
  231.   /**
  232.    * Mimics 
  233.    * <a href="http://java.sun.com/j2se/1.4.2/docs/api/java/lang/Math.html#abs(float)">Math.abs(float)</a>
  234.    */
  235.   public static int abs(int f) {
  236.     //if (isNaN(f)) {
  237.     //  return NaN;
  238.     //}
  239.     return (f & ABS_MASK);
  240.   }
  242.   /**
  243.    * Returns the negation of a <code>float</code> value.
  244.    * Special cases:
  245.    * <ul>
  246.    * <li>If the argument is negative zero, the result is positive zero.
  247.    * <li>If the argument is positive zero, the result is negative zero.
  248.    * <li>If the argument is negative infinity, the result is positive infinity.
  249.    * <li>If the argument is positive infinity, the result is negative infinity.
  250.    * <li>If the argument is NaN, the result is NaN.</ul>
  251.    * <p>
  252.    * This method takes the place of the unary <code>-</code> operator.
  253.    *
  254.    * @param   f   the <code>float</code> value whose negated value is to be 
  255.    *              determined
  256.    * @return  the negation of the argument.
  257.    */
  258.   public static int negate(int f) {
  259.     if (isNaN(f)) {
  260.       return NaN;
  261.     }
  262.     return (f ^ SIGN_MASK);
  263.   }
  265.   
  266.   /////////////////////////////////////////////////////////////////////////////
  267.   // Comparison
  268.   /////////////////////////////////////////////////////////////////////////////
  270.   /**
  271.    * Returns <code>true</code> if the specified numbers are considered equal
  272.    * according to 
  273.    * <a href="http://java.sun.com/docs/books/jls/second_edition/html/expressions.doc.html#5198">section 15.21.1
  274.    * of the JLS</a>.  Special cases:
  275.    * <ul>
  276.    * <li>If either operand is NaN, then the result is false
  277.    * <li>Positive zero and negative zero are considered equal
  278.    * </ul>
  279.    * <p>
  280.    * This method takes the place of the <code>==</code> operator.
  281.    *
  282.    * @param   f1   the first <code>float</code> value to be compared.
  283.    * @param   f2   the second <code>float</code> value to be compared.
  284.    * @return  <code>true</code> if the two values are considered equal;
  285.    *          <code>false</code> otherwise.
  286.    */
  287.   public static boolean eq(int f1, int f2) {
  288.     return (((f1 == f2) && (! isNaN(f1))) || (isZero(f1) && isZero(f2)));
  289.   }
  290.   
  291.   /**
  292.    * Returns <code>true</code> if the specified numbers are considered unequal
  293.    * according to 
  294.    * <a href="http://java.sun.com/docs/books/jls/second_edition/html/expressions.doc.html#5198">section
  295.    * 15.21.1 of the JLS</a>.  Special cases:
  296.    * <ul>
  297.    * <li>If either operand is NaN, then the result is true
  298.    * <li>Positive zero and negative zero are considered equal
  299.    * </ul>
  300.    * The value returned by <code>ne</code> is always the opposite of the value
  301.    * returned by <code>eq</code> for the same arguments.
  302.    * <p>
  303.    * This method takes the place of the <code>!=</code> operator.
  304.    *
  305.    * @param   f1   the first <code>float</code> value to be compared.
  306.    * @param   f2   the second <code>float</code> value to be compared.
  307.    * @return  <code>true</code> if the two values are considered equal;
  308.    *          <code>false</code> otherwise.
  309.    */
  310.   public static boolean ne(int f1, int f2) {
  311.     return (! eq(f1, f2));
  312.   }
  314.   /**
  315.    * Returns <code>true</code> if the first argument is considered less than
  316.    * the second argument according to 
  317.    * <a href="http://java.sun.com/docs/books/jls/second_edition/html/expressions.doc.html#153654">section
  318.    * 15.20.1 of the JLS</a>.  Special cases:
  319.    * <ul>
  320.    * <li>If either operand is NaN, then the result is false
  321.    * <li>Positive zero and negative zero are considered equal
  322.    * <li>Negative infinity is conisdered less than all other values except NaN
  323.    * <li>Positive infinity is conisdered greater than all other values except NaN
  324.    * </ul>
  325.    * <p>
  326.    * This method takes the place of the <code>&lt;</code> operator.
  327.    *
  328.    * @param   f1   the first <code>float</code> value to be compared.
  329.    * @param   f2   the second <code>float</code> value to be compared.
  330.    * @return  <code>true</code> if the first value is less than the second value;
  331.    *          <code>false</code> otherwise.
  332.    */
  333.   public static boolean lt(int f1, int f2) {
  334.     if (isNaN(f1) || isNaN(f2)) {
  335.       return false;
  336.     } else if (f2 == ZERO) {
  337.       f2 = NEGATIVE_ZERO;
  338.     }
  339.     return (cmp(f1, f2) < 0);
  340.   }
  341.   
  342.   /**
  343.    * Returns <code>true</code> if the first argument is considered less than
  344.    * or equal to the second argument according to 
  345.    * <a href="http://java.sun.com/docs/books/jls/second_edition/html/expressions.doc.html#153654">section
  346.    * 15.20.1 of the JLS</a>.  Special cases:
  347.    * <ul>
  348.    * <li>If either operand is NaN, then the result is false
  349.    * <li>Positive zero and negative zero are considered equal
  350.    * <li>Negative infinity is conisdered less than all other values except NaN
  351.    * <li>Positive infinity is conisdered greater than all other values except NaN
  352.    * </ul>
  353.    * <p>
  354.    * This method takes the place of the <code>&lt;=</code> operator.
  355.    *
  356.    * @param   f1   the first <code>float</code> value to be compared.
  357.    * @param   f2   the second <code>float</code> value to be compared.
  358.    * @return  <code>true</code> if the first value is less than or equal to 
  359.    *          the second value; <code>false</code> otherwise.
  360.    */
  361.   public static boolean le(int f1, int f2) {
  362.     if (isNaN(f1) || isNaN(f2)) {
  363.       return false;
  364.     } else if (f2 == NEGATIVE_ZERO) {
  365.       f2 = ZERO;
  366.     }
  367.     return (cmp(f1, f2) <= 0);
  368.   }
  370.   /**
  371.    * Returns <code>true</code> if the first argument is considered greater than
  372.    * the second argument according to 
  373.    * <a href="http://java.sun.com/docs/books/jls/second_edition/html/expressions.doc.html#153654">section
  374.    * 15.20.1 of the JLS</a>.  Special cases:
  375.    * <ul>
  376.    * <li>If either operand is NaN, then the result is false
  377.    * <li>Positive zero and negative zero are considered equal
  378.    * <li>Negative infinity is conisdered less than all other values except NaN
  379.    * <li>Positive infinity is conisdered greater than all other values except NaN
  380.    * </ul>
  381.    * <p>
  382.    * This method takes the place of the <code>&gt;</code> operator.
  383.    *
  384.    * @param   f1   the first <code>float</code> value to be compared.
  385.    * @param   f2   the second <code>float</code> value to be compared.
  386.    * @return  <code>true</code> if the first value is greater than the second value;
  387.    *          <code>false</code> otherwise.
  388.    */
  389.   public static boolean gt(int f1, int f2) {
  390.     if (isNaN(f1) || isNaN(f2)) {
  391.       return false;
  392.     } else if (f1 == ZERO) {
  393.       f1 = NEGATIVE_ZERO;
  394.     }
  395.     return (cmp(f1, f2) > 0);
  396.   }
  397.   
  398.   /**
  399.    * Returns <code>true</code> if the first argument is considered greater than
  400.    * or equal to the second argument according to 
  401.    * <a href="http://java.sun.com/docs/books/jls/second_edition/html/expressions.doc.html#153654">section
  402.    * 15.20.1 of the JLS</a>.  Special cases:
  403.    * <ul>
  404.    * <li>If either operand is NaN, then the result is false
  405.    * <li>Positive zero and negative zero are considered equal
  406.    * <li>Negative infinity is conisdered less than all other values except NaN
  407.    * <li>Positive infinity is conisdered greater than all other values except NaN
  408.    * </ul>
  409.    * <p>
  410.    * This method takes the place of the <code>&gt;=</code> operator.
  411.    *
  412.    * @param   f1   the first <code>float</code> value to be compared.
  413.    * @param   f2   the second <code>float</code> value to be compared.
  414.    * @return  <code>true</code> if the first value is greater than or equal to 
  415.    *          the second value; <code>false</code> otherwise.
  416.    */
  417.   public static boolean ge(int f1, int f2) {
  418.     if (isNaN(f1) || isNaN(f2)) {
  419.       return false;
  420.     } else if (f1 == NEGATIVE_ZERO) {
  421.       f1 = ZERO;
  422.     }
  423.     return (cmp(f1, f2) >= 0);
  424.   }
  427.   /**
  428.    * Mimics 
  429.    * <a href="http://java.sun.com/j2se/1.4.2/docs/api/java/lang/Float.html#compare(float, float)">Float.compare(float, float)</a>.
  430.    * <p>
  431.    * Note that when using this method (as well as <code>Float.compare</code>),
  432.    * the following rules apply:
  433.    * <ul><li>
  434.    * <code>NaN</code> is considered 
  435.    * to be equal to itself and greater than all other
  436.    * <code>float</code> values (including
  437.    * <code>POSITIVE_INFINITY</code>).
  438.    * <li>
  439.    * <code>0.0</code> is considered to be greater
  440.    * than <code>-0.0</code>.
  441.    * </ul>
  442.    */
  443.   public static int compare(int f1, int f2) {
  444.     boolean n1 = isNaN(f1);
  445.     boolean n2 = isNaN(f2);
  446.     if (n1 || n2) {
  447.       if (n1 && n2) {
  448.         return 0;
  449.       }
  450.       return (n1 ? 1 : -1);
  451.     }
  452.     return cmp(f1, f2);
  453.   }
  455.   /**
  456.    * Mimics 
  457.    * <a href="http://java.sun.com/j2se/1.4.2/docs/api/java/lang/Math.html#max(float, float)">Math.max(float, float)</a>.
  458.    */
  459.   public static int max(int f1, int f2) {
  460.     if (isNaN(f1) || isNaN(f2)) {
  461.       return NaN;
  462.     }
  463.     return ((cmp(f1, f2) < 0) ? f2 : f1);
  464.   }
  466.   /**
  467.    * Mimics 
  468.    * <a href="http://java.sun.com/j2se/1.4.2/docs/api/java/lang/Math.html#min(float, float)">Math.min(float, float)</a>.
  469.    */
  470.   public static int min(int f1, int f2) {
  471.     if (isNaN(f1) || isNaN(f2)) {
  472.       return NaN;
  473.     }
  474.     return ((cmp(f1, f2) > 0) ? f2 : f1);
  475.   }
  477.   private static int cmp(int f1, int f2) {
  478.     if (f1 < 0) {
  479.       if (f2 < 0) {
  480.         return f2 - f1;
  481.       } else {
  482.         return -1;
  483.       }
  484.     } else if (f2 < 0) {
  485.       return 1;
  486.     } else {
  487.       return f1 - f2;
  488.     }
  489.   }
  492.   /////////////////////////////////////////////////////////////////////////////
  493.   // Type conversion
  494.   /////////////////////////////////////////////////////////////////////////////
  496.   /** 
  497.    * Convert the given <code>int</code> to a <code>float</code> as would happen
  498.    * in a casting operation specified by 
  499.    * <a href="http://java.sun.com/docs/books/jls/second_edition/html/conversions.doc.html#25214">section
  500.    * 5.1.2 of the JLS</a>.  This is a widening primitive conversion which 
  501.    * will not result in a loss of magnitude, but might result in a loss of
  502.    * precision.
  503.    *
  504.    * @param x the <code>int</code> to be converted
  505.    * @return the <code>float</code> representation of the argument
  506.    */
  507.   public static int intToFloat(int x) {
  508.     if (x < 0) {
  509.       return pack(true, 0, -x);
  510.     }
  511.     return pack(false, 0, x);
  512.   }
  513.   
  514.   /** 
  515.    * Convert the given <code>long</code> to a <code>float</code> as would happen
  516.    * in a casting operation specified by 
  517.    * <a href="http://java.sun.com/docs/books/jls/second_edition/html/conversions.doc.html#25214">section
  518.    * 5.1.2 of the JLS</a>.  This is a widening primitive conversion which 
  519.    * will not result in a loss of magnitude, but might result in a loss of
  520.    * precision.
  521.    *
  522.    * @param x the <code>long</code> to be converted
  523.    * @return the <code>float</code> representation of the argument
  524.    */
  525.   public static int longToFloat(long x) {
  526.     if (x < 0) {
  527.       return pack(true, 0, -x);
  528.     }
  529.     return pack(false, 0, x);
  530.   }
  532.   /** 
  533.    * Convert the given <code>double</code> to a <code>float</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#25363">section
  536.    * 5.1.3 of the JLS</a>.  This is a narrowing primitive conversion which 
  537.    * may result in a loss of magnitude and/or precision.
  538.    *
  539.    * @param d the <code>double</code> to be converted
  540.    * @return the <code>float</code> representation of the argument
  541.    */
  542.   public static int doubleToFloat(long d) {
  543.     if (MicroDouble.isNaN(d)) {
  544.       return NaN;
  545.     }
  546.     boolean n = MicroDouble.unpackSign(d);
  547.     if (MicroDouble.isZero(d)) {
  548.       return (n ? NEGATIVE_ZERO : ZERO);
  549.     } else if (MicroDouble.isInfinite(d)) {
  550.       return (n ? NEGATIVE_INFINITY : POSITIVE_INFINITY);
  551.     }
  552.     int x = MicroDouble.unpackExponent(d);
  553.     long m = MicroDouble.unpackMantissa(d);
  554.     return pack(n, x, m);
  555.   }
  557.   /** 
  558.    * Convert the given <code>float</code> to a <code>byte</code> as would happen
  559.    * in a casting operation specified by 
  560.    * <a href="http://java.sun.com/docs/books/jls/second_edition/html/conversions.doc.html#25363">section
  561.    * 5.1.3 of the JLS</a>.  This is a narrowing primitive conversion which 
  562.    * may result in a loss of magnitude and/or precision.
  563.    * <p>
  564.    * Note that this is a non-intuitive conversion.  If the argument is outside
  565.    * of the range of the byte type, the result is basically meaningless.
  566.    *
  567.    * @param f the <code>float</code> to be converted
  568.    * @return the <code>byte</code> representation of the argument
  569.    */
  570.   public static byte byteValue(int f) {
  571.     long x = intValue(f);
  572.     return (byte) x;
  573.   }
  575.   /** 
  576.    * Convert the given <code>float</code> to a <code>short</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 short type, the result is basically meaningless.
  584.    *
  585.    * @param f the <code>float</code> to be converted
  586.    * @return the <code>short</code> representation of the argument
  587.    */
  588.   public static short shortValue(int f) {
  589.     long x = intValue(f);
  590.     return (short) x;
  591.   }
  593.   /** 
  594.    * Convert the given <code>float</code> to an <code>int</code> as would happen
  595.    * in a casting operation specified by 
  596.    * <a href="http://java.sun.com/docs/books/jls/second_edition/html/conversions.doc.html#25363">section
  597.    * 5.1.3 of the JLS</a>.  This is a narrowing primitive conversion which 
  598.    * may result in a loss of magnitude and/or precision.
  599.    *
  600.    * @param f the <code>float</code> to be converted
  601.    * @return the <code>int</code> representation of the argument
  602.    */
  603.   public static int intValue(int f) {
  604.     long x = longValue(f);
  605.     if (x >= Integer.MAX_VALUE) {
  606.       return Integer.MAX_VALUE;
  607.     } else if (x <= Integer.MIN_VALUE) {
  608.       return Integer.MIN_VALUE;
  609.     }
  610.     return (int) x;
  611.   }
  612.   
  613.   /** 
  614.    * Convert the given <code>float</code> to a <code>long</code> as would happen
  615.    * in a casting operation specified by 
  616.    * <a href="http://java.sun.com/docs/books/jls/second_edition/html/conversions.doc.html#25363">section
  617.    * 5.1.3 of the JLS</a>.  This is a narrowing primitive conversion which 
  618.    * may result in a loss of magnitude and/or precision.
  619.    *
  620.    * @param f the <code>float</code> to be converted
  621.    * @return the <code>long</code> representation of the argument
  622.    */
  623.   public static long longValue(int f) {
  624.     if (isNaN(f)) {
  625.       return 0;
  626.     }
  627.     boolean n = unpackSign(f);
  628.     int x = unpackExponent(f);
  629.     long m = unpackMantissa(f);
  630.     if (x > 0) {
  631.       if ((x >= 63) || ((m >> (63 - x)) != 0))  {
  632.         return (n ? Long.MIN_VALUE : Long.MAX_VALUE);
  633.       }
  634.       m <<= x;
  635.     } else if (x <= -24) {
  636.       return 0;
  637.     } else {
  638.       m >>>= -x;
  639.     }
  640.     return (n ? -m : m);
  641.   }
  643.   /** 
  644.    * Convert the given <code>float</code> to a <code>double</code> as would happen
  645.    * in a casting operation specified by 
  646.    * <a href="http://java.sun.com/docs/books/jls/second_edition/html/conversions.doc.html#25214">section
  647.    * 5.1.2 of the JLS</a>.  This is a widening primitive conversion which 
  648.    * will result in neither a loss of magnitude nor precision.
  649.    *
  650.    * @param f the <code>float</code> to be converted
  651.    * @return the <code>double</code> representation of the argument
  652.    */
  653.   public static long doubleValue(int f) {
  654.     return MicroDouble.floatToDouble(f);
  655.   }
  656.   
  658.   /////////////////////////////////////////////////////////////////////////////
  659.   // Basic arithmetic
  660.   /////////////////////////////////////////////////////////////////////////////
  662.   /**
  663.    * Returns the sum of the two <code>float</code> arguments according to 
  664.    * <a href="http://java.sun.com/docs/books/jls/second_edition/html/expressions.doc.html#13510">section
  665.    * 15.18.2 of the JLS</a>.
  666.    * <p>
  667.    * This method takes the place of the binary <code>+</code> operator.
  668.    *
  669.    * @param   f1   the first <code>float</code> value to be summed.
  670.    * @param   f2   the second <code>float</code> value to be summed.
  671.    * @return  the sum of the two arguments
  672.    */
  673.   public static int add(int f1, int f2) {
  674.     if (isNaN(f1) || isNaN(f2)) {
  675.       return NaN;
  676.     }
  677.     
  678.     boolean n1 = unpackSign(f1);
  679.     boolean n2 = unpackSign(f2);
  680.     
  681.     // special handling of infinity
  682.     boolean i1 = isInfinite(f1);
  683.     boolean i2 = isInfinite(f2);
  684.     if (i1 || i2) {
  685.       if (i1 && i2) {
  686.         if (n1 != n2) {
  687.           // infinites of opposite sign -> NaN
  688.           return NaN;
  689.         } else {
  690.           // infinites of same sign -> infinity the same sign
  691.           return f1;
  692.         }
  693.       } else if (i1) {
  694.         return f1; // infinite + finite = infinite
  695.       } else {
  696.         return f2; // finite + infinite = infinite
  697.       }
  698.     }
  699.     
  700.     // special handling of zero
  701.     boolean z1 = isZero(f1);
  702.     boolean z2 = isZero(f2);
  703.     if (z1 || z2) {
  704.       if (z1 && z2) {
  705.         if (n1 != n2) {
  706.           // zeros of opposite sign -> positive zero
  707.           return ZERO;
  708.         } else {
  709.           return f1; // zeros of same sign -> zero of the same sign
  710.         }
  711.       } else if (z1) {
  712.         return f2; // zero + nonzero = nonzero
  713.       } else {
  714.         return f1; // nonzero + zero = nonzero
  715.       }
  716.     }
  717.     
  718.     // unpack, and add 3 guard digits
  719.     int m1 = unpackMantissa(f1) << 3;
  720.     int x1 = unpackExponent(f1) - 3;
  721.     int m2 = unpackMantissa(f2) << 3;
  722.     int x2 = unpackExponent(f2) - 3;
  724.     // make exponents equal
  725.     int dx = x1 - x2;
  726.     if (dx > 0) {
  727.       m2 = BitUtils.stickyRightShift(m2, dx);
  728.       x2 = x1;
  729.     } else if (dx < 0) {
  730.       m1 = BitUtils.stickyRightShift(m1, -dx);
  731.       x1 = x2;
  732.     }
  734.     // if the signs are different, negate the smaller mantissa and choose
  735.     // the sign of the larger
  736.     if (n1 ^ n2) { 
  737.       if (m1 > m2) {
  738.         m2 = -m2;
  739.       } else {
  740.         m1 = -m1;
  741.         n1 = n2;
  742.       }
  743.     }
  744.     
  745.     // add (or subtract) mantissas
  746.     m1 += m2;
  748.     // pack result, and handle special case of zero (which always returns +0.0) 
  749.     int f = pack(n1, x1, m1);
  750.     if (f == NEGATIVE_ZERO) {
  751.       return ZERO;
  752.     }
  753.     return f;
  754.   }
  756.   /**
  757.    * Returns the difference of the two <code>float</code> arguments according to 
  758.    * <a href="http://java.sun.com/docs/books/jls/second_edition/html/expressions.doc.html#13510">section
  759.    * 15.18.2 of the JLS</a>.
  760.    * <p>
  761.    * This method takes the place of the binary <code>-</code> operator.
  762.    *
  763.    * @param   f1   the first <code>float</code> value 
  764.    * @param   f2   the second <code>float</code> value
  765.    * @return  the difference of the two arguments
  766.    */
  767.   public static int sub(int f1, int f2) {
  768.     return add(f1, negate(f2));
  769.   }
  771.   /**
  772.    * Returns the product of the two <code>float</code> arguments according to 
  773.    * <a href="http://java.sun.com/docs/books/jls/second_edition/html/expressions.doc.html#5036">section
  774.    * 15.17.1 of the JLS</a>.
  775.    * <p>
  776.    * This method takes the place of the <code>*</code> operator.
  777.    *
  778.    * @param   f1   the first <code>float</code> value
  779.    * @param   f2   the second <code>float</code> value
  780.    * @return  the product of the two arguments
  781.    */
  782.   public static int mul(int f1, int f2) {
  783.     if (isNaN(f1) || isNaN(f2)) {
  784.       return NaN;
  785.     }
  787.     boolean negative = unpackSign(f1) ^ unpackSign(f2);
  788.     
  789.     // special handling of infinity
  790.     if (isInfinite(f1) || isInfinite(f2)) {
  791.       if (isZero(f1) || isZero(f2)) {
  792.         return NaN;
  793.       } else {
  794.         return (negative ? NEGATIVE_INFINITY : POSITIVE_INFINITY);
  795.       }
  796.     }
  797.     
  798.     // unpack
  799.     int m1 = unpackMantissa(f1);
  800.     int x1 = unpackExponent(f1);
  801.     int m2 = unpackMantissa(f2);
  802.     int x2 = unpackExponent(f2);
  803.     
  804.     // compute the resultant exponent
  805.     x1 += x2;
  806.     
  807.     // compute the resultant mantissa using integer multiplication
  808.     long m = ((long) m1) * ((long) m2);
  809.     
  810.     // round and pack the result
  811.     return pack(negative, x1, m);
  812.   }
  814.   /**
  815.    * Returns the quotient of the two <code>float</code> arguments according to 
  816.    * <a href="http://java.sun.com/docs/books/jls/second_edition/html/expressions.doc.html#5047">section
  817.    * 15.17.2 of the JLS</a>.
  818.    * <p>
  819.    * This method takes the place of the <code>/</code> operator.
  820.    *
  821.    * @param   f1   the <code>float</code> dividend 
  822.    * @param   f2   the <code>float</code> divisor
  823.    * @return  the quotient of the two arguments
  824.    */
  825.   public static int div(int f1, int f2) {
  826.     if (isNaN(f1) || isNaN(f2)) {
  827.       return NaN;
  828.     }
  830.     boolean negative = unpackSign(f1) ^ unpackSign(f2);
  831.     
  832.     // special handling of infinity
  833.     boolean n1 = isInfinite(f1);
  834.     boolean n2 = isInfinite(f2);
  835.     if (n1 || n2) {
  836.       if (n1 && n2) {
  837.         return NaN;
  838.       } else if (n1) {
  839.         return (negative ? NEGATIVE_INFINITY : POSITIVE_INFINITY);
  840.       } else {
  841.         return (negative ? NEGATIVE_ZERO : ZERO);
  842.       }
  843.     }
  844.     // neither value is infinite
  845.     
  846.     // special handling of zero
  847.     n1 = isZero(f1);
  848.     n2 = isZero(f2);
  849.     if (n1 || n2) {
  850.       if (n1 && n2) {
  851.         return NaN;
  852.       } else if (n1) {
  853.         return (negative ? NEGATIVE_ZERO : ZERO);
  854.       } else {
  855.         return (negative ? NEGATIVE_INFINITY : POSITIVE_INFINITY);
  856.       }
  857.     }
  858.     // neither value is zero
  859.     
  860.     // unpack
  861.     int m1 = unpackMantissa(f1);
  862.     int x1 = unpackExponent(f1);
  863.     int m2 = unpackMantissa(f2);
  864.     int x2 = unpackExponent(f2);
  866.     // shift the dividend to the left to increase precision, then do an integer
  867.     // divide
  868.     int s = BitUtils.countLeadingZeros(m1) + 22;
  869.     long m3 = ((long) m1) << s;
  870.     int x = x1 - x2 - s;
  871.     long m = m3 / m2;
  872.     boolean r = ((m * m2) != m3);
  874.     // put a non-zero fraction into the sticky bit
  875.     if (r) {
  876.       m |= 1; 
  877.     }
  878.     return pack(negative, x, m);
  879.   }
  881.   /**
  882.    * Returns the remainder of the two <code>float</code> arguments according to 
  883.    * <a href="http://java.sun.com/docs/books/jls/second_edition/html/expressions.doc.html#24956">section
  884.    * 15.17.3 of the JLS</a>.
  885.    * <p>
  886.    * This method takes the place of the <code>%</code> operator.
  887.    *
  888.    * @param   f1   the <code>float</code> dividend 
  889.    * @param   f2   the <code>float</code> divisor
  890.    * @return  the remainder of the two arguments
  891.    */
  892.   public static int mod(int f1, int f2) {
  893.     if (isNaN(f1) || isNaN(f2) || isInfinite(f1) || isZero(f2)) {
  894.       return NaN;
  895.     } else if (isZero(f1) || isInfinite(f2)) {
  896.       return f1;
  897.     }
  898.     
  899.     // unpack
  900.     int x1 = unpackExponent(f1);
  901.     int x2 = unpackExponent(f2);
  902.     if (x1 < x2) {
  903.       return f1;
  904.     }
  905.     boolean n = unpackSign(f1);
  906.     int m1 = unpackMantissa(f1);
  907.     int m2 = unpackMantissa(f2);
  908.     if (x1 == x2) {
  909.       m1 %= m2;
  910.     } else {
  911.       // reduce m1 by left shifting and modding until the exponents x1 and x2 are 
  912.       // equal
  913.       while (x1 != x2) {
  914.         int s = Math.min(39, x1 - x2);
  915.         x1 -= s;
  916.         m1 = (int) ((((long) m1) << s) % m2);
  917.       }
  918.     }
  919.     return pack(n, x1, m1);
  920.   }
  923.   /////////////////////////////////////////////////////////////////////////////
  924.   // Rounding
  925.   /////////////////////////////////////////////////////////////////////////////
  927.   /**
  928.    * Returns the <code>float</code> of greatest magnitude (furthest from zero)
  929.    * that is equal to a mathematical integer and which has a mignitude not
  930.    * greater than the argument's magnitude.  Special cases:
  931.    * <ul><li>If the argument value is already equal to a mathematical 
  932.    * integer, then the result is the same as the argument. 
  933.    * <li>If the argument is NaN or an infinity or positive zero or 
  934.    * negative zero, then the result is the same as the argument.</ul>
  935.    *
  936.    * @param   f   a <code>float</code> value.
  937.    * @return the <code>float</code> of greatest magnitude (furthest from zero)
  938.    *         whose magnitude is not greater than the argument's and which 
  939.    *         is equal to a mathematical integer.
  940.    */
  941.   public static int truncate(int f) {
  942.     return round(f, false, unpackSign(f));
  943.   }
  945.   /**
  946.    * Mimics 
  947.    * <a href="http://java.sun.com/j2se/1.4.2/docs/api/java/lang/Math.html#rint(double)">Math.rint(double)</a>, 
  948.    * using single precision.
  949.    */
  950.   public static int rint(int f) {
  951.     return round(f, true, false);
  952.   }
  953.   
  954.   /**
  955.    * Mimics
  956.    * <a href="http://java.sun.com/j2se/1.4.2/docs/api/java/lang/Math.html#floor(double)">Math.floor(double)</a>, 
  957.    * using single precision.
  958.    */
  959.   public static int floor(int f) {
  960.     return round(f, false, false);
  961.   }
  962.   
  963.   /**
  964.    * Mimics
  965.    * <a href="http://java.sun.com/j2se/1.4.2/docs/api/java/lang/Math.html#ceil(double)">Math.ceil(double)</a>, 
  966.    * using single precision.
  967.    */
  968.   public static int ceil(int f) {
  969.     return round(f, false, true);
  970.   }
  972.   /**
  973.    * Mimics
  974.    * <a href="http://java.sun.com/j2se/1.4.2/docs/api/java/lang/Math.html#round(double)">Math.round(double)</a>, 
  975.    * using single precision.
  976.    */
  977.   public static int round(int f) {
  978.     return intValue(floor(add(f, ONE_HALF)));
  979.   }
  981.   private static int round(int f, boolean round, boolean ceil) {
  982.     if (isNaN(f)) {
  983.       return NaN;
  984.     } else if (isZero(f) || isInfinite(f)) {
  985.       return f;
  986.     }
  987.     int x = unpackExponent(f);
  988.     if (x >= 0) {
  989.       return f;
  990.     }
  991.     boolean n = unpackSign(f);
  992.     int m = unpackMantissa(f);
  993.     if (round) {
  994.       m = BitUtils.roundingRightShift(m, -x);
  995.     } else {
  996.       int r;
  997.       if (x <= -32) {
  998.         r = m;
  999.         m = 0;
  1000.       } else {
  1001.         r = m << (32 + x);
  1002.         m >>>= -x;
  1003.       }
  1004.       if ((n ^ ceil) && (r != 0)) {
  1005.         m++;
  1006.       }
  1007.     }
  1008.     return pack(n, 0, m);
  1009.   }
  1012.   /////////////////////////////////////////////////////////////////////////////
  1013.   // String conversion
  1014.   /////////////////////////////////////////////////////////////////////////////
  1016.   // decimal -> binary
  1017.   
  1018.   // base 2 mantissas for 10**-54 through 10**38, at intervals of 100
  1019.   private static final int[] pow10m = {
  1020.           0xc428d05b, 0x993fe2c7, 0xef73d257, 0xbb127c54, 0x92267121, 
  1021.           0xe45c10c4, 0xb267ed19, 0x8b61313c, 0xd9c7dced, 0xaa242499, 
  1022.           0x84ec3c98, 0xcfb11ead, 0xa2425ff7, 0xfd87b5f3, 0xc6120625, 
  1023.           0x9abe14cd, 0xf1c90081, 0xbce50865, 0x9392ee8f, 0xe69594bf, 
  1024.           0xb424dc35, 0x8cbccc09, 0xdbe6fecf, 0xabcc7712, 0x8637bd06, 
  1025.           0xd1b71759, 0xa3d70a3d, 0x80000000, 0xc8000000, 0x9c400000, 
  1026.           0xf4240000, 0xbebc2000, 0x9502f900, 0xe8d4a510, 0xb5e620f5, 
  1027.           0x8e1bc9bf, 0xde0b6b3a, 0xad78ebc6, 0x87867832, 0xd3c21bcf, 
  1028.           0xa56fa5ba, 0x813f3979, 0xc9f2c9cd, 0x9dc5ada8, 0xf684df57, 
  1029.           0xc097ce7c, 0x96769951,
  1030.   };
  1031.   
  1032.   // base 2 exponents for 10**-54 through 10**38, at intervals of 100
  1033.   private static final short[] pow10x = {
  1034.           -211, -204, -198, -191, -184, -178, -171, -164, 
  1035.           -158, -151, -144, -138, -131, -125, -118, -111, 
  1036.           -105, -98, -91, -85, -78, -71, -65, -58, 
  1037.           -51, -45, -38, -31, -25, -18, -12, -5, 
  1038.           2, 8, 15, 22, 28, 35, 42, 48, 
  1039.           55, 62, 68, 75, 81, 88, 95,
  1040.   };
  1041.           
  1042.   private static int decToFloat(boolean negative, int base10x, int base10m) {
  1043.     if (base10m == 0) {
  1044.       return (negative ? NEGATIVE_ZERO : ZERO);
  1045.     }
  1046.     // maximize base10m to ensure consistency between toString and parseFloat
  1047.     while ((base10m > 0) && (base10m <= 0x19999999)) { // (Integer.MAX_VALUE / 5))) {
  1048.       base10m = (base10m << 3) + (base10m << 1);
  1049.       base10x--;
  1050.     }
  1051.     // base10x needs to be a multiple of 2, because the tables are
  1052.     // spaced at intervals of 100 (not 10).
  1053.     base10x += 54;
  1054.     boolean mod = ((base10x & 1) != 0);
  1055.     base10x >>= 1;
  1056.     if (base10x < 0) { // -54
  1057.       return (negative ? NEGATIVE_ZERO : ZERO);
  1058.     } else if (base10x > 46) { // 38
  1059.       return (negative ? NEGATIVE_INFINITY : POSITIVE_INFINITY);
  1060.     }
  1061.     int base2x = pow10x[base10x];
  1062.     long base2m = (base10m & 0xffffffffL) * (pow10m[base10x] & 0xffffffffL);
  1063.     if (mod) {
  1064.       if (base2m < 0) {
  1065.         base2m >>>= 1;
  1066.         base2x++;
  1067.       }
  1068.       base2m += base2m >>> 2;
  1069.       base2x += 3;
  1070.     }
  1071.     return pack(negative, base2x, base2m);
  1072.   }
  1074.   /**
  1075.    * Mimics
  1076.    * <a href="http://java.sun.com/j2se/1.4.2/docs/api/java/lang/Float.html#parseFloat(String)">Float.parseFloat(String)</a>.
  1077.    * <p>
  1078.    * <b>This implementation is known to be inaccurate, and 
  1079.    * does not always return the same value as 
  1080.    * <code>Float.parseFloat</code>.</b>  However the difference should be no 
  1081.    * greater than 1 ulp.
  1082.    *
  1083.    * @exception  NumberFormatException  if the string does not contain a
  1084.    *               parsable number.
  1085.    */
  1086.   public static int parseFloat(String s) {
  1087.     // remove leading & trailing whitespace
  1088.     s = s.trim().toUpperCase();
  1089.     
  1090.     // check length
  1091.     int len = s.length();
  1092.     if (len == 0) {
  1093.       throw new NumberFormatException(s);
  1094.     }
  1095.     
  1096.     // check for NaN
  1097.     if ("NAN".equals(s)) {
  1098.       return NaN;
  1099.     }
  1100.     
  1101.     // begin parsing, one character at a time
  1102.     int idx = 0;
  1103.     
  1104.     // read sign
  1105.     boolean negative = false;
  1106.     char c = s.charAt(0);
  1107.     negative = (c == '-');
  1108.     if (negative || (c == '+')) {
  1109.       idx = 1;
  1110.     }
  1112.     // check for "Infinity"
  1113.     if (idx < len) {
  1114.       c = s.charAt(idx);
  1115.       if ((c == 'I') || (c == 'i')) {
  1116.         if ("INFINITY".equals(s.substring(idx))) {
  1117.           return (negative ? NEGATIVE_INFINITY : POSITIVE_INFINITY);
  1118.         }
  1119.       }
  1120.     }
  1122.     // read Digits.Digits
  1123.     int mantissa = 0;
  1124.     int exponent = 0;
  1125.     int fractionChars = 0;
  1126.     boolean sticky = false;
  1127.     boolean readingFraction = false;
  1128.     while (idx < len) {
  1129.       c = s.charAt(idx);
  1130.       if (c == '.') {
  1131.         if (readingFraction) {
  1132.           throw new NumberFormatException(s);
  1133.         }
  1134.         readingFraction = true;
  1135.       } else if ((c < '0') || (c > '9')) {
  1136.         break;
  1137.       } else {
  1138.         fractionChars++;
  1139.         if (mantissa <= 0x19999998) { // ((Integer.MAX_VALUE / 5) - 1)) { 
  1140.           mantissa = (mantissa << 3) + (mantissa << 1) + (c - '0');
  1141.           if (readingFraction) {
  1142.             exponent--;
  1143.           }
  1144.         } else {
  1145.           if (! readingFraction) {
  1146.             exponent++;
  1147.           }
  1148.           sticky |= (c != '0');
  1149.         }
  1150.       }
  1151.       idx++;
  1152.     }
  1153.     if (fractionChars == 0) {
  1154.       throw new NumberFormatException(s);
  1155.     }
  1156.     
  1157.     // read exponent
  1158.     if (((idx + 1) < len) && ((s.charAt(idx) == 'E') || (s.charAt(idx) == 'e'))) {
  1159.       try {
  1160.         exponent += Integer.parseInt(s.substring(idx + 1));
  1161.       } catch (NumberFormatException e) {
  1162.         throw new NumberFormatException(s);
  1163.       }
  1164.       idx = len;
  1165.     } else if (idx != len) {
  1166.       // check that we parsed the entire string
  1167.       throw new NumberFormatException(s);
  1168.     }
  1170.     // convert the decimal to a float
  1171.     return decToFloat(negative, exponent, mantissa);
  1172.   }
  1174.   // binary -> decimal
  1175.   
  1176.   // base 10 mantissas for 2**-150 through 2**98, at intervals of 2**8
  1177.   private static final int[] pow2m = {
  1178.           0xb35dbf82, 0x2deaf18a, 0x758ca7c7, 
  1179.           0x1e17b843, 0x4d0985cb, 0xc5371912, 
  1180.           0x327cb273, 0x813f3979, 0x21165458, 
  1181.           0x54b40b20, 0xd8d726b7, 0x3782dacf, 
  1182.           0x8e1bc9bf, 0x246139cb, 0x5d21dba0, 
  1183.           0xee6b2800, 0x3d090000, 0x9c400000, 
  1184.           0x28000000, 0x66666666, 0x1a36e2eb, 
  1185.           0x431bde83, 0xabcc7712, 0x2bfaffc3, 
  1186.           0x709709a1, 0x1cd2b298, 0x49c97747, 
  1187.           0xbce50865, 0x305b6680, 0x7bcb43d7, 
  1188.           0x1fb0f6be, 0x51212ffc, 
  1189.   };
  1191.   // base 10 exponents for 2 ^ -150 through 2 ^ 98, at intervals of 2 ^ 8
  1192.   private static final byte[] pow2x = {
  1193.           -45, -42, -40, -37, -35, -33, -30, -28, 
  1194.           -25, -23, -21, -18, -16, -13, -11, -9, 
  1195.           -6, -4, -1, 1, 4, 6, 8, 11, 
  1196.           13, 16, 18, 20, 23, 25, 28, 30, 
  1197.   };
  1199.   /**
  1200.    * Mimics
  1201.    * <a href="http://java.sun.com/j2se/1.4.2/docs/api/java/lang/Float.html#toString(float)">Float.toString(float)</a>.
  1202.    * <p>
  1203.    * <b>This implementation is known to be inaccurate, and 
  1204.    * does not always return the same value as 
  1205.    * <code>Float.toString</code>.</b>  However the difference should be no 
  1206.    * greater than 1 ulp.
  1207.    */
  1208.   public static String toString(int f) {
  1209.     if (isNaN(f)) {
  1210.       return "NaN";
  1211.     }
  1212.     boolean n = unpackSign(f);
  1213.     StringBuffer sb = new StringBuffer(15);
  1214.     if (n) {
  1215.       sb.append('-');
  1216.     }
  1217.     if (isZero(f)) {
  1218.       sb.append("0.0");
  1219.       return sb.toString();
  1220.     } else if (isInfinite(f)) {
  1221.       sb.append("Infinity");
  1222.       return sb.toString();
  1223.     }
  1224.     // convert from base 2 to base 10
  1225.     int base2x = unpackExponent(f);
  1226.     int base2m = unpackMantissa(f);
  1227.     int idx = base2x + 150;
  1228.     int dx = idx & 7;
  1229.     base2m <<= dx;
  1230.     idx >>= 3;
  1231.     int base10x = pow2x[idx];
  1232.     while (base2m <= 0xccccccc) {
  1233.       base2m = (base2m << 3) + (base2m << 1); // base2m *= 10;
  1234.       base10x--;
  1235.     }
  1236.     long base10ml = base2m * (pow2m[idx] & 0xffffffffL);
  1237.     int base10m = (int) (base10ml >>> 32);
  1238.     if ((base10ml << 32) < 0) {
  1239.       base10m++;
  1240.     }
  1242.     // reduce the number of digits in m10 
  1243.     boolean roundedUp = false;
  1244.     while (true) {
  1245.       int r = base10m % 10;
  1246.       int mt = base10m / 10;
  1247.       int xt = base10x + 1;
  1248.       if (r != 0) {
  1249.         if ((r > 5) || ((r == 5) && (! roundedUp))) {
  1250.           roundedUp = true;
  1251.           mt++;
  1252.         } else {
  1253.           roundedUp = false;
  1254.         }
  1255.         int ft = decToFloat(n, xt, mt);
  1256.         if (ft != f) {
  1257.           if (roundedUp) {
  1258.             mt--;
  1259.           } else {
  1260.             mt++;
  1261.           }
  1262.           roundedUp ^= true;
  1263.           ft = decToFloat(n, xt, mt);
  1264.           if (ft != f) {
  1265.             break;
  1266.           }
  1267.         }
  1268.       }
  1269.       base10m = mt;
  1270.       base10x = xt;
  1271.     }
  1272.     
  1273.     // convert to string
  1274.     String s = Integer.toString(base10m);
  1275.     base10x += s.length() - 1;
  1276.     boolean scientific = ((base10x < -3) || (base10x >= 7));
  1277.     int dp; // index of decimal point in final string
  1278.     if (scientific) {
  1279.       dp = 1;
  1280.     } else {
  1281.       dp = base10x + 1;
  1282.       if (dp < 1) {
  1283.         sb.append('0');
  1284.       }
  1285.     }
  1286.     for (int i=0; i<dp; i++) {
  1287.       if (i < s.length()) {
  1288.         sb.append(s.charAt(i));
  1289.       } else {
  1290.         sb.append('0');
  1291.       }
  1292.     }
  1293.     sb.append('.');
  1294.     if (dp >= s.length()) {
  1295.       sb.append('0');
  1296.     } else {
  1297.       for (int i=dp; i<s.length(); i++) {
  1298.         if (i < 0) {
  1299.           sb.append('0');
  1300.         } else {
  1301.           sb.append(s.charAt(i));
  1302.         }
  1303.       }
  1304.     }
  1305.     if (scientific) {
  1306.       sb.append('E');
  1307.       sb.append(Integer.toString(base10x));
  1308.     }
  1309.     return sb.toString();
  1310.   }
  1312.   
  1313.   /////////////////////////////////////////////////////////////////////////////
  1314.   // Instance members
  1315.   /////////////////////////////////////////////////////////////////////////////
  1317.   private final int value;
  1319.   
  1320.   /////////////////////////////////////////////////////////////////////////////
  1321.   // Constructors
  1322.   /////////////////////////////////////////////////////////////////////////////
  1324.   
  1325.   /**
  1326.    * Constructs a newly-allocated <code>MicroFloat</code> object that represents 
  1327.    * the argument. 
  1328.    *
  1329.    * @param f the <code>float</code> value to be represented by the <code>MicroFloat</code>.
  1330.    */
  1331.   public MicroFloat(int f) {
  1332.     // canonicalize NaN values so that hashCode() and equals() can be simpler
  1333.     if (isNaN(f)) {
  1334.       f = NaN;
  1335.     }
  1336.     value = f;
  1337.   }
  1338.   
  1339.   /**
  1340.    * Constructs a newly-allocated <code>MicroFloat</code> object that represents 
  1341.    * the argument.
  1342.    *
  1343.    * @param s a <code>String</code> to be converted to a <code>MicroFloat</code>.
  1344.    * @throws NumberFormatException if the <code>String</code> does not contain a
  1345.    *         parsable number.
  1346.    * @see #parseFloat(String)
  1347.    */
  1348.   public MicroFloat(String s) {
  1349.     this(parseFloat(s));
  1350.   }
  1352.   
  1353.   /////////////////////////////////////////////////////////////////////////////
  1354.   // Instance methods
  1355.   /////////////////////////////////////////////////////////////////////////////
  1356.   
  1357.   /**
  1358.    * Returns the <code>float</code> value of this <code>MicroFloat</code>
  1359.    * object.
  1360.    */
  1361.   public int floatValue() {
  1362.     return value;
  1363.   }
  1365.   /**
  1366.    * Returns a String object representing this MicroFloat's value.
  1367.    * Equivalent to <code>toString(floatValue())</code>.
  1368.    *
  1369.    * @see #toString(int)
  1370.    */
  1371.   public String toString() {
  1372.     return toString(value);
  1373.   }
  1375.   /**
  1376.    * Returns a hash code for this <code>MicroFloat</code> object.
  1377.    * Equivalent to floatValue().
  1378.    */
  1379.   public int hashCode() {
  1380.     return value;
  1381.   }
  1383.   /**
  1384.    * Compares this object against the specified object.
  1385.    * Equivalent to <code>((obj instanceof MicroFloat) && (compare(((MicroFloat) obj).floatValue(), floatValue()) == 0))</code>
  1386.    * 
  1387.    * @see #compare(int, int)
  1388.    */
  1389.   public boolean equals(Object obj) {
  1390.     return ((obj instanceof MicroFloat)
  1391.             && (((MicroFloat) obj).value == value));
  1392.   }
  1393.   
  1394. }