home *** CD-ROM | disk | FTP | other *** search
/ S283 Planetary Science &n…he Search for Life DVD 2 / DVD-ROM.iso / install / jre1_3 / lib / rt.jar / java / lang / FloatingDecimal.class (.txt) < prev    next >
Encoding:
Java Class File  |  1979-12-31  |  11.7 KB  |  1,113 lines
  1. package java.lang;
  2.  
  3. class FloatingDecimal {
  4.    boolean isExceptional;
  5.    boolean isNegative;
  6.    int decExponent;
  7.    char[] digits;
  8.    int nDigits;
  9.    int bigIntExp;
  10.    int bigIntNBits;
  11.    boolean mustSetRoundDir = false;
  12.    int roundDir;
  13.    static final long signMask = Long.MIN_VALUE;
  14.    static final long expMask = 9218868437227405312L;
  15.    static final long fractMask = 4503599627370495L;
  16.    static final int expShift = 52;
  17.    static final int expBias = 1023;
  18.    static final long fractHOB = 4503599627370496L;
  19.    static final long expOne = 4607182418800017408L;
  20.    static final int maxSmallBinExp = 62;
  21.    static final int minSmallBinExp = -21;
  22.    static final int maxDecimalDigits = 15;
  23.    static final int maxDecimalExponent = 308;
  24.    static final int minDecimalExponent = -324;
  25.    static final int bigDecimalExponent = 324;
  26.    static final long highbyte = -72057594037927936L;
  27.    static final long highbit = Long.MIN_VALUE;
  28.    static final long lowbytes = 72057594037927935L;
  29.    static final int singleSignMask = Integer.MIN_VALUE;
  30.    static final int singleExpMask = 2139095040;
  31.    static final int singleFractMask = 8388607;
  32.    static final int singleExpShift = 23;
  33.    static final int singleFractHOB = 8388608;
  34.    static final int singleExpBias = 127;
  35.    static final int singleMaxDecimalDigits = 7;
  36.    static final int singleMaxDecimalExponent = 38;
  37.    static final int singleMinDecimalExponent = -45;
  38.    static final int intDecimalDigits = 9;
  39.    private static FDBigInt[] b5p;
  40.    private static final double[] small10pow = new double[]{(double)1.0F, (double)10.0F, (double)100.0F, (double)1000.0F, (double)10000.0F, (double)100000.0F, (double)1000000.0F, (double)1.0E7F, (double)1.0E8F, (double)1.0E9F, (double)1.0E10F, 1.0E11, 1.0E12, 1.0E13, 1.0E14, 1.0E15, 1.0E16, 1.0E17, 1.0E18, 1.0E19, 1.0E20, 1.0E21, 1.0E22};
  41.    private static final float[] singleSmall10pow = new float[]{1.0F, 10.0F, 100.0F, 1000.0F, 10000.0F, 100000.0F, 1000000.0F, 1.0E7F, 1.0E8F, 1.0E9F, 1.0E10F};
  42.    private static final double[] big10pow = new double[]{1.0E16, 1.0E32, 1.0E64, 1.0E128, 1.0E256};
  43.    private static final double[] tiny10pow = new double[]{1.0E-16, 1.0E-32, 1.0E-64, 1.0E-128, 1.0E-256};
  44.    private static final int maxSmallTen;
  45.    private static final int singleMaxSmallTen;
  46.    private static final int[] small5pow;
  47.    private static final long[] long5pow;
  48.    private static final int[] n5bits;
  49.    private static final char[] infinity;
  50.    private static final char[] notANumber;
  51.    private static final char[] zero;
  52.  
  53.    private FloatingDecimal(boolean var1, int var2, char[] var3, int var4, boolean var5) {
  54.       this.isNegative = var1;
  55.       this.isExceptional = var5;
  56.       this.decExponent = var2;
  57.       this.digits = var3;
  58.       this.nDigits = var4;
  59.    }
  60.  
  61.    private static int countBits(long var0) {
  62.       if (var0 == 0L) {
  63.          return 0;
  64.       } else {
  65.          while((var0 & -72057594037927936L) == 0L) {
  66.             var0 <<= 8;
  67.          }
  68.  
  69.          while(var0 > 0L) {
  70.             var0 <<= 1;
  71.          }
  72.  
  73.          int var2;
  74.          for(var2 = 0; (var0 & 72057594037927935L) != 0L; var2 += 8) {
  75.             var0 <<= 8;
  76.          }
  77.  
  78.          while(var0 != 0L) {
  79.             var0 <<= 1;
  80.             ++var2;
  81.          }
  82.  
  83.          return var2;
  84.       }
  85.    }
  86.  
  87.    private static synchronized FDBigInt big5pow(int var0) {
  88.       if (var0 < 0) {
  89.          throw new RuntimeException("Assertion botch: negative power of 5");
  90.       } else {
  91.          if (b5p == null) {
  92.             b5p = new FDBigInt[var0 + 1];
  93.          } else if (b5p.length <= var0) {
  94.             FDBigInt[] var1 = new FDBigInt[var0 + 1];
  95.             System.arraycopy(b5p, 0, var1, 0, b5p.length);
  96.             b5p = var1;
  97.          }
  98.  
  99.          if (b5p[var0] != null) {
  100.             return b5p[var0];
  101.          } else if (var0 < small5pow.length) {
  102.             return b5p[var0] = new FDBigInt(small5pow[var0]);
  103.          } else if (var0 < long5pow.length) {
  104.             return b5p[var0] = new FDBigInt(long5pow[var0]);
  105.          } else {
  106.             int var5 = var0 >> 1;
  107.             int var2 = var0 - var5;
  108.             FDBigInt var3 = b5p[var5];
  109.             if (var3 == null) {
  110.                var3 = big5pow(var5);
  111.             }
  112.  
  113.             if (var2 < small5pow.length) {
  114.                return b5p[var0] = var3.mult(small5pow[var2]);
  115.             } else {
  116.                FDBigInt var4 = b5p[var2];
  117.                if (var4 == null) {
  118.                   var4 = big5pow(var2);
  119.                }
  120.  
  121.                return b5p[var0] = var3.mult(var4);
  122.             }
  123.          }
  124.       }
  125.    }
  126.  
  127.    private static FDBigInt multPow52(FDBigInt var0, int var1, int var2) {
  128.       if (var1 != 0) {
  129.          if (var1 < small5pow.length) {
  130.             var0 = var0.mult(small5pow[var1]);
  131.          } else {
  132.             var0 = var0.mult(big5pow(var1));
  133.          }
  134.       }
  135.  
  136.       if (var2 != 0) {
  137.          var0.lshiftMe(var2);
  138.       }
  139.  
  140.       return var0;
  141.    }
  142.  
  143.    private static FDBigInt constructPow52(int var0, int var1) {
  144.       FDBigInt var2 = new FDBigInt(big5pow(var0));
  145.       if (var1 != 0) {
  146.          var2.lshiftMe(var1);
  147.       }
  148.  
  149.       return var2;
  150.    }
  151.  
  152.    private FDBigInt doubleToBigInt(double var1) {
  153.       // $FF: Couldn't be decompiled
  154.    }
  155.  
  156.    private static double ulp(double var0, boolean var2) {
  157.       long var3 = Double.doubleToLongBits(var0) & Long.MAX_VALUE;
  158.       int var5 = (int)(var3 >>> 52);
  159.       if (var2 && var5 >= 52 && (var3 & 4503599627370495L) == 0L) {
  160.          --var5;
  161.       }
  162.  
  163.       double var6;
  164.       if (var5 > 52) {
  165.          var6 = Double.longBitsToDouble((long)(var5 - 52) << 52);
  166.       } else if (var5 == 0) {
  167.          var6 = Double.MIN_VALUE;
  168.       } else {
  169.          var6 = Double.longBitsToDouble(1L << var5 - 1);
  170.       }
  171.  
  172.       if (var2) {
  173.          var6 = -var6;
  174.       }
  175.  
  176.       return var6;
  177.    }
  178.  
  179.    float stickyRound(double var1) {
  180.       long var3 = Double.doubleToLongBits(var1);
  181.       long var5 = var3 & 9218868437227405312L;
  182.       if (var5 != 0L && var5 != 9218868437227405312L) {
  183.          var3 += (long)this.roundDir;
  184.          return (float)Double.longBitsToDouble(var3);
  185.       } else {
  186.          return (float)var1;
  187.       }
  188.    }
  189.  
  190.    private void developLongDigits(int var1, long var2, long var4) {
  191.       int var10;
  192.       for(var10 = 0; var4 >= 10L; ++var10) {
  193.          var4 /= 10L;
  194.       }
  195.  
  196.       if (var10 != 0) {
  197.          long var11 = long5pow[var10] << var10;
  198.          long var13 = var2 % var11;
  199.          var2 /= var11;
  200.          var1 += var10;
  201.          if (var13 >= var11 >> 1) {
  202.             ++var2;
  203.          }
  204.       }
  205.  
  206.       char[] var6;
  207.       byte var7;
  208.       int var8;
  209.       if (var2 <= 2147483647L) {
  210.          if (var2 <= 0L) {
  211.             throw new RuntimeException("Assertion botch: value " + var2 + " <= 0");
  212.          }
  213.  
  214.          int var18 = (int)var2;
  215.          var7 = 10;
  216.          var6 = new char[10];
  217.          var8 = var7 - 1;
  218.          int var9 = var18 % 10;
  219.  
  220.          for(var18 /= 10; var9 == 0; var18 /= 10) {
  221.             ++var1;
  222.             var9 = var18 % 10;
  223.          }
  224.  
  225.          while(var18 != 0) {
  226.             var6[var8--] = (char)(var9 + 48);
  227.             ++var1;
  228.             var9 = var18 % 10;
  229.             var18 /= 10;
  230.          }
  231.  
  232.          var6[var8] = (char)(var9 + 48);
  233.       } else {
  234.          var7 = 20;
  235.          var6 = new char[20];
  236.          var8 = var7 - 1;
  237.          int var17 = (int)(var2 % 10L);
  238.  
  239.          for(var2 /= 10L; var17 == 0; var2 /= 10L) {
  240.             ++var1;
  241.             var17 = (int)(var2 % 10L);
  242.          }
  243.  
  244.          while(var2 != 0L) {
  245.             var6[var8--] = (char)(var17 + 48);
  246.             ++var1;
  247.             var17 = (int)(var2 % 10L);
  248.             var2 /= 10L;
  249.          }
  250.  
  251.          var6[var8] = (char)(var17 + 48);
  252.       }
  253.  
  254.       var7 -= var8;
  255.       char[] var20;
  256.       if (var8 == 0) {
  257.          var20 = var6;
  258.       } else {
  259.          var20 = new char[var7];
  260.          System.arraycopy(var6, var8, var20, 0, var7);
  261.       }
  262.  
  263.       this.digits = var20;
  264.       this.decExponent = var1 + 1;
  265.       this.nDigits = var7;
  266.    }
  267.  
  268.    private void roundup() {
  269.       int var1;
  270.       char var2 = this.digits[var1 = this.nDigits - 1];
  271.       if (var2 == '9') {
  272.          while(var2 == '9' && var1 > 0) {
  273.             this.digits[var1] = '0';
  274.             --var1;
  275.             var2 = this.digits[var1];
  276.          }
  277.  
  278.          if (var2 == '9') {
  279.             ++this.decExponent;
  280.             this.digits[0] = '1';
  281.             return;
  282.          }
  283.       }
  284.  
  285.       this.digits[var1] = (char)(var2 + 1);
  286.    }
  287.  
  288.    public FloatingDecimal(double var1) {
  289.       long var3 = Double.doubleToLongBits(var1);
  290.       if ((var3 & Long.MIN_VALUE) != 0L) {
  291.          this.isNegative = true;
  292.          var3 ^= Long.MIN_VALUE;
  293.       } else {
  294.          this.isNegative = false;
  295.       }
  296.  
  297.       int var7 = (int)((var3 & 9218868437227405312L) >> 52);
  298.       long var5 = var3 & 4503599627370495L;
  299.       if (var7 == 2047) {
  300.          this.isExceptional = true;
  301.          if (var5 == 0L) {
  302.             this.digits = infinity;
  303.          } else {
  304.             this.digits = notANumber;
  305.             this.isNegative = false;
  306.          }
  307.  
  308.          this.nDigits = this.digits.length;
  309.       } else {
  310.          this.isExceptional = false;
  311.          int var8;
  312.          if (var7 == 0) {
  313.             if (var5 == 0L) {
  314.                this.decExponent = 0;
  315.                this.digits = zero;
  316.                this.nDigits = 1;
  317.                return;
  318.             }
  319.  
  320.             while((var5 & 4503599627370496L) == 0L) {
  321.                var5 <<= 1;
  322.                --var7;
  323.             }
  324.  
  325.             var8 = 52 + var7 + 1;
  326.             ++var7;
  327.          } else {
  328.             var5 |= 4503599627370496L;
  329.             var8 = 53;
  330.          }
  331.  
  332.          var7 -= 1023;
  333.          this.dtoa(var7, var5, var8);
  334.       }
  335.    }
  336.  
  337.    public FloatingDecimal(float var1) {
  338.       int var2 = Float.floatToIntBits(var1);
  339.       if ((var2 & Integer.MIN_VALUE) != 0) {
  340.          this.isNegative = true;
  341.          var2 ^= Integer.MIN_VALUE;
  342.       } else {
  343.          this.isNegative = false;
  344.       }
  345.  
  346.       int var4 = (var2 & 2139095040) >> 23;
  347.       int var3 = var2 & 8388607;
  348.       if (var4 == 255) {
  349.          this.isExceptional = true;
  350.          if ((long)var3 == 0L) {
  351.             this.digits = infinity;
  352.          } else {
  353.             this.digits = notANumber;
  354.             this.isNegative = false;
  355.          }
  356.  
  357.          this.nDigits = this.digits.length;
  358.       } else {
  359.          this.isExceptional = false;
  360.          int var5;
  361.          if (var4 == 0) {
  362.             if (var3 == 0) {
  363.                this.decExponent = 0;
  364.                this.digits = zero;
  365.                this.nDigits = 1;
  366.                return;
  367.             }
  368.  
  369.             while((var3 & 8388608) == 0) {
  370.                var3 <<= 1;
  371.                --var4;
  372.             }
  373.  
  374.             var5 = 23 + var4 + 1;
  375.             ++var4;
  376.          } else {
  377.             var3 |= 8388608;
  378.             var5 = 24;
  379.          }
  380.  
  381.          var4 -= 127;
  382.          this.dtoa(var4, (long)var3 << 29, var5);
  383.       }
  384.    }
  385.  
  386.    private void dtoa(int var1, long var2, int var4) {
  387.       int var5 = countBits(var2);
  388.       int var6 = Math.max(0, var5 - var1 - 1);
  389.       if (var1 <= 62 && var1 >= -21 && var6 < long5pow.length && var5 + n5bits[var6] < 64 && var6 == 0) {
  390.          long var39;
  391.          if (var1 > var4) {
  392.             var39 = 1L << var1 - var4 - 1;
  393.          } else {
  394.             var39 = 0L;
  395.          }
  396.  
  397.          if (var1 >= 52) {
  398.             var2 <<= var1 - 52;
  399.          } else {
  400.             var2 >>>= 52 - var1;
  401.          }
  402.  
  403.          this.developLongDigits(0, var2, var39);
  404.       } else {
  405.          double var8 = Double.longBitsToDouble(4607182418800017408L | var2 & -4503599627370497L);
  406.          int var7 = (int)Math.floor((var8 - (double)1.5F) * 0.289529654 + 0.176091259 + (double)var1 * 0.301029995663981);
  407.          int var11 = Math.max(0, -var7);
  408.          int var10 = var11 + var6 + var1;
  409.          int var13 = Math.max(0, var7);
  410.          int var12 = var13 + var6;
  411.          int var14 = var10 - var4;
  412.          var2 >>>= 53 - var5;
  413.          var10 -= var5 - 1;
  414.          int var21 = Math.min(var10, var12);
  415.          var10 -= var21;
  416.          var12 -= var21;
  417.          var14 -= var21;
  418.          if (var5 == 1) {
  419.             --var14;
  420.          }
  421.  
  422.          if (var14 < 0) {
  423.             var10 -= var14;
  424.             var12 -= var14;
  425.             var14 = 0;
  426.          }
  427.  
  428.          char[] var22 = this.digits = new char[18];
  429.          int var23 = 0;
  430.          int var16 = var5 + var10 + (var11 < n5bits.length ? n5bits[var11] : var11 * 3);
  431.          int var17 = var12 + 1 + (var13 + 1 < n5bits.length ? n5bits[var13 + 1] : (var13 + 1) * 3);
  432.          boolean var24;
  433.          boolean var25;
  434.          long var26;
  435.          if (var16 < 64 && var17 < 64) {
  436.             if (var16 < 32 && var17 < 32) {
  437.                int var53 = (int)var2 * small5pow[var11] << var10;
  438.                int var55 = small5pow[var13] << var12;
  439.                int var56 = small5pow[var11] << var14;
  440.                int var32 = var55 * 10;
  441.                var23 = 0;
  442.                int var49 = var53 / var55;
  443.                var53 = 10 * (var53 % var55);
  444.                var56 *= 10;
  445.                var24 = var53 < var56;
  446.                var25 = var53 + var56 > var32;
  447.                if (var49 >= 10) {
  448.                   throw new RuntimeException("Assertion botch: excessivly large digit " + var49);
  449.                }
  450.  
  451.                if (var49 == 0 && !var25) {
  452.                   --var7;
  453.                } else {
  454.                   var22[var23++] = (char)(48 + var49);
  455.                }
  456.  
  457.                if (var7 <= -3 || var7 >= 8) {
  458.                   var24 = false;
  459.                   var25 = false;
  460.                }
  461.  
  462.                for(; !var24 && !var25; var22[var23++] = (char)(48 + var49)) {
  463.                   var49 = var53 / var55;
  464.                   var53 = 10 * (var53 % var55);
  465.                   var56 *= 10;
  466.                   if (var49 >= 10) {
  467.                      throw new RuntimeException("Assertion botch: excessivly large digit " + var49);
  468.                   }
  469.  
  470.                   if ((long)var56 > 0L) {
  471.                      var24 = var53 < var56;
  472.                      var25 = var53 + var56 > var32;
  473.                   } else {
  474.                      var24 = true;
  475.                      var25 = true;
  476.                   }
  477.                }
  478.  
  479.                var26 = (long)((var53 << 1) - var32);
  480.             } else {
  481.                long var51 = var2 * long5pow[var11] << var10;
  482.                long var31 = long5pow[var13] << var12;
  483.                long var33 = long5pow[var11] << var14;
  484.                long var35 = var31 * 10L;
  485.                var23 = 0;
  486.                int var47 = (int)(var51 / var31);
  487.                var51 = 10L * (var51 % var31);
  488.                var33 *= 10L;
  489.                var24 = var51 < var33;
  490.                var25 = var51 + var33 > var35;
  491.                if (var47 >= 10) {
  492.                   throw new RuntimeException("Assertion botch: excessivly large digit " + var47);
  493.                }
  494.  
  495.                if (var47 == 0 && !var25) {
  496.                   --var7;
  497.                } else {
  498.                   var22[var23++] = (char)(48 + var47);
  499.                }
  500.  
  501.                if (var7 <= -3 || var7 >= 8) {
  502.                   var24 = false;
  503.                   var25 = false;
  504.                }
  505.  
  506.                for(; !var24 && !var25; var22[var23++] = (char)(48 + var47)) {
  507.                   var47 = (int)(var51 / var31);
  508.                   var51 = 10L * (var51 % var31);
  509.                   var33 *= 10L;
  510.                   if (var47 >= 10) {
  511.                      throw new RuntimeException("Assertion botch: excessivly large digit " + var47);
  512.                   }
  513.  
  514.                   if (var33 > 0L) {
  515.                      var24 = var51 < var33;
  516.                      var25 = var51 + var33 > var35;
  517.                   } else {
  518.                      var24 = true;
  519.                      var25 = true;
  520.                   }
  521.                }
  522.  
  523.                var26 = (var51 << 1) - var35;
  524.             }
  525.          } else {
  526.             FDBigInt var19 = multPow52(new FDBigInt(var2), var11, var10);
  527.             FDBigInt var18 = constructPow52(var13, var12);
  528.             FDBigInt var20 = constructPow52(var11, var14);
  529.             int var30;
  530.             var19.lshiftMe(var30 = var18.normalizeMe());
  531.             var20.lshiftMe(var30);
  532.             FDBigInt var29 = var18.mult(10);
  533.             var23 = 0;
  534.             int var28 = var19.quoRemIteration(var18);
  535.             var20 = var20.mult(10);
  536.             var24 = var19.cmp(var20) < 0;
  537.             var25 = var19.add(var20).cmp(var29) > 0;
  538.             if (var28 >= 10) {
  539.                throw new RuntimeException("Assertion botch: excessivly large digit " + var28);
  540.             }
  541.  
  542.             if (var28 == 0 && !var25) {
  543.                --var7;
  544.             } else {
  545.                var22[var23++] = (char)(48 + var28);
  546.             }
  547.  
  548.             if (var7 <= -3 || var7 >= 8) {
  549.                var24 = false;
  550.                var25 = false;
  551.             }
  552.  
  553.             while(!var24 && !var25) {
  554.                var28 = var19.quoRemIteration(var18);
  555.                var20 = var20.mult(10);
  556.                if (var28 >= 10) {
  557.                   throw new RuntimeException("Assertion botch: excessivly large digit " + var28);
  558.                }
  559.  
  560.                var24 = var19.cmp(var20) < 0;
  561.                var25 = var19.add(var20).cmp(var29) > 0;
  562.                var22[var23++] = (char)(48 + var28);
  563.             }
  564.  
  565.             if (var25 && var24) {
  566.                var19.lshiftMe(1);
  567.                var26 = (long)var19.cmp(var29);
  568.             } else {
  569.                var26 = 0L;
  570.             }
  571.          }
  572.  
  573.          this.decExponent = var7 + 1;
  574.          this.digits = var22;
  575.          this.nDigits = var23;
  576.          if (var25) {
  577.             if (var24) {
  578.                if (var26 == 0L) {
  579.                   if ((var22[this.nDigits - 1] & 1) != 0) {
  580.                      this.roundup();
  581.                   }
  582.                } else if (var26 > 0L) {
  583.                   this.roundup();
  584.                }
  585.             } else {
  586.                this.roundup();
  587.             }
  588.          }
  589.  
  590.       }
  591.    }
  592.  
  593.    public String toString() {
  594.       StringBuffer var1 = new StringBuffer(this.nDigits + 8);
  595.       if (this.isNegative) {
  596.          var1.append('-');
  597.       }
  598.  
  599.       if (this.isExceptional) {
  600.          var1.append(this.digits, 0, this.nDigits);
  601.       } else {
  602.          var1.append("0.");
  603.          var1.append(this.digits, 0, this.nDigits);
  604.          var1.append('e');
  605.          var1.append(this.decExponent);
  606.       }
  607.  
  608.       return new String(var1);
  609.    }
  610.  
  611.    public String toJavaFormatString() {
  612.       char[] var1 = new char[this.nDigits + 10];
  613.       int var2 = 0;
  614.       if (this.isNegative) {
  615.          var1[0] = '-';
  616.          var2 = 1;
  617.       }
  618.  
  619.       if (this.isExceptional) {
  620.          System.arraycopy(this.digits, 0, var1, var2, this.nDigits);
  621.          var2 += this.nDigits;
  622.       } else if (this.decExponent > 0 && this.decExponent < 8) {
  623.          int var20 = Math.min(this.nDigits, this.decExponent);
  624.          System.arraycopy(this.digits, 0, var1, var2, var20);
  625.          var2 += var20;
  626.          if (var20 < this.decExponent) {
  627.             var20 = this.decExponent - var20;
  628.             System.arraycopy(zero, 0, var1, var2, var20);
  629.             var2 += var20;
  630.             var1[var2++] = '.';
  631.             var1[var2++] = '0';
  632.          } else {
  633.             var1[var2++] = '.';
  634.             if (var20 < this.nDigits) {
  635.                int var4 = this.nDigits - var20;
  636.                System.arraycopy(this.digits, var20, var1, var2, var4);
  637.                var2 += var4;
  638.             } else {
  639.                var1[var2++] = '0';
  640.             }
  641.          }
  642.       } else if (this.decExponent <= 0 && this.decExponent > -3) {
  643.          var1[var2++] = '0';
  644.          var1[var2++] = '.';
  645.          if (this.decExponent != 0) {
  646.             System.arraycopy(zero, 0, var1, var2, -this.decExponent);
  647.             var2 -= this.decExponent;
  648.          }
  649.  
  650.          System.arraycopy(this.digits, 0, var1, var2, this.nDigits);
  651.          var2 += this.nDigits;
  652.       } else {
  653.          var1[var2++] = this.digits[0];
  654.          var1[var2++] = '.';
  655.          if (this.nDigits > 1) {
  656.             System.arraycopy(this.digits, 1, var1, var2, this.nDigits - 1);
  657.             var2 += this.nDigits - 1;
  658.          } else {
  659.             var1[var2++] = '0';
  660.          }
  661.  
  662.          var1[var2++] = 'E';
  663.          int var3;
  664.          if (this.decExponent <= 0) {
  665.             var1[var2++] = '-';
  666.             var3 = -this.decExponent + 1;
  667.          } else {
  668.             var3 = this.decExponent - 1;
  669.          }
  670.  
  671.          if (var3 <= 9) {
  672.             var1[var2++] = (char)(var3 + 48);
  673.          } else if (var3 <= 99) {
  674.             var1[var2++] = (char)(var3 / 10 + 48);
  675.             var1[var2++] = (char)(var3 % 10 + 48);
  676.          } else {
  677.             var1[var2++] = (char)(var3 / 100 + 48);
  678.             var3 %= 100;
  679.             var1[var2++] = (char)(var3 / 10 + 48);
  680.             var1[var2++] = (char)(var3 % 10 + 48);
  681.          }
  682.       }
  683.  
  684.       return new String(var1, 0, var2);
  685.    }
  686.  
  687.    public static FloatingDecimal readJavaFormatString(String var0) throws NumberFormatException {
  688.       boolean var1 = false;
  689.       boolean var2 = false;
  690.  
  691.       try {
  692.          var0 = var0.trim();
  693.          int var5 = var0.length();
  694.          if (var5 == 0) {
  695.             throw new NumberFormatException("empty String");
  696.          }
  697.  
  698.          int var6 = 0;
  699.          char var4;
  700.          char[] var7;
  701.          int var8;
  702.          boolean var9;
  703.          int var10;
  704.          int var11;
  705.          int var12;
  706.          switch (var4 = var0.charAt(var6)) {
  707.             case '-':
  708.                var1 = true;
  709.             case '+':
  710.                ++var6;
  711.                var2 = true;
  712.             default:
  713.                var7 = new char[var5];
  714.                var8 = 0;
  715.                var9 = false;
  716.                var10 = 0;
  717.                var11 = 0;
  718.                var12 = 0;
  719.          }
  720.  
  721.          label91:
  722.          for(; var6 < var5; ++var6) {
  723.             switch (var4 = var0.charAt(var6)) {
  724.                case '.':
  725.                   if (var9) {
  726.                      throw new NumberFormatException("multiple points");
  727.                   }
  728.  
  729.                   var10 = var6;
  730.                   if (var2) {
  731.                      var10 = var6 - 1;
  732.                   }
  733.  
  734.                   var9 = true;
  735.                   continue;
  736.                case '/':
  737.                default:
  738.                   break label91;
  739.                case '0':
  740.                   if (var8 > 0) {
  741.                      ++var12;
  742.                   } else {
  743.                      ++var11;
  744.                   }
  745.                   continue;
  746.                case '1':
  747.                case '2':
  748.                case '3':
  749.                case '4':
  750.                case '5':
  751.                case '6':
  752.                case '7':
  753.                case '8':
  754.                case '9':
  755.             }
  756.  
  757.             while(var12 > 0) {
  758.                var7[var8++] = '0';
  759.                --var12;
  760.             }
  761.  
  762.             var7[var8++] = var4;
  763.          }
  764.  
  765.          if (var8 == 0) {
  766.             var7 = zero;
  767.             var8 = 1;
  768.             if (var11 == 0) {
  769.                throw new NumberFormatException(var0);
  770.             }
  771.          }
  772.  
  773.          int var3;
  774.          if (var9) {
  775.             var3 = var10 - var11;
  776.          } else {
  777.             var3 = var8 + var12;
  778.          }
  779.  
  780.          if (var6 < var5 && (var4 = var0.charAt(var6)) == 'e' || var4 == 'E') {
  781.             byte var13 = 1;
  782.             int var14 = 0;
  783.             int var15 = 214748364;
  784.             boolean var16 = false;
  785.             ++var6;
  786.             int var17;
  787.             switch (var0.charAt(var6)) {
  788.                case '-':
  789.                   var13 = -1;
  790.                case '+':
  791.                   ++var6;
  792.                default:
  793.                   var17 = var6;
  794.             }
  795.  
  796.             label116:
  797.             while(var6 < var5) {
  798.                if (var14 >= var15) {
  799.                   var16 = true;
  800.                }
  801.  
  802.                switch (var4 = var0.charAt(var6++)) {
  803.                   case '0':
  804.                   case '1':
  805.                   case '2':
  806.                   case '3':
  807.                   case '4':
  808.                   case '5':
  809.                   case '6':
  810.                   case '7':
  811.                   case '8':
  812.                   case '9':
  813.                      var14 = var14 * 10 + (var4 - 48);
  814.                      break;
  815.                   default:
  816.                      --var6;
  817.                      break label116;
  818.                }
  819.             }
  820.  
  821.             int var18 = 324 + var8 + var12;
  822.             if (!var16 && var14 <= var18) {
  823.                var3 += var13 * var14;
  824.             } else {
  825.                var3 = var13 * var18;
  826.             }
  827.  
  828.             if (var6 == var17) {
  829.                throw new NumberFormatException(var0);
  830.             }
  831.          }
  832.  
  833.          if (var6 >= var5 || var6 == var5 - 1 && (var0.charAt(var6) == 'f' || var0.charAt(var6) == 'F' || var0.charAt(var6) == 'd' || var0.charAt(var6) == 'D')) {
  834.             return new FloatingDecimal(var1, var3, var7, var8, false);
  835.          }
  836.       } catch (StringIndexOutOfBoundsException var19) {
  837.       }
  838.  
  839.       throw new NumberFormatException(var0);
  840.    }
  841.  
  842.    public double doubleValue() {
  843.       int var1 = Math.min(this.nDigits, 16);
  844.       this.roundDir = 0;
  845.       int var10 = this.digits[0] - 48;
  846.       int var11 = Math.min(var1, 9);
  847.  
  848.       for(int var12 = 1; var12 < var11; ++var12) {
  849.          var10 = var10 * 10 + this.digits[var12] - 48;
  850.       }
  851.  
  852.       long var2 = (long)var10;
  853.  
  854.       for(int var13 = var11; var13 < var1; ++var13) {
  855.          var2 = var2 * 10L + (long)(this.digits[var13] - 48);
  856.       }
  857.  
  858.       double var4 = (double)var2;
  859.       int var14 = this.decExponent - var1;
  860.       if (this.nDigits <= 15) {
  861.          if (var14 == 0 || var4 == (double)0.0F) {
  862.             return this.isNegative ? -var4 : var4;
  863.          }
  864.  
  865.          if (var14 >= 0) {
  866.             if (var14 <= maxSmallTen) {
  867.                double var30 = var4 * small10pow[var14];
  868.                if (this.mustSetRoundDir) {
  869.                   double var32 = var30 / small10pow[var14];
  870.                   this.roundDir = var32 == var4 ? 0 : (var32 < var4 ? 1 : -1);
  871.                }
  872.  
  873.                return this.isNegative ? -var30 : var30;
  874.             }
  875.  
  876.             int var15 = 15 - var1;
  877.             if (var14 <= maxSmallTen + var15) {
  878.                var4 *= small10pow[var15];
  879.                double var6 = var4 * small10pow[var14 - var15];
  880.                if (this.mustSetRoundDir) {
  881.                   double var8 = var6 / small10pow[var14 - var15];
  882.                   this.roundDir = var8 == var4 ? 0 : (var8 < var4 ? 1 : -1);
  883.                }
  884.  
  885.                return this.isNegative ? -var6 : var6;
  886.             }
  887.          } else if (var14 >= -maxSmallTen) {
  888.             double var31 = var4 / small10pow[-var14];
  889.             double var33 = var31 * small10pow[-var14];
  890.             if (this.mustSetRoundDir) {
  891.                this.roundDir = var33 == var4 ? 0 : (var33 < var4 ? 1 : -1);
  892.             }
  893.  
  894.             return this.isNegative ? -var31 : var31;
  895.          }
  896.       }
  897.  
  898.       if (var14 > 0) {
  899.          if (this.decExponent > 309) {
  900.             return this.isNegative ? Double.NEGATIVE_INFINITY : Double.POSITIVE_INFINITY;
  901.          }
  902.  
  903.          if ((var14 & 15) != 0) {
  904.             var4 *= small10pow[var14 & 15];
  905.          }
  906.  
  907.          if ((var14 = var14 >> 4) != 0) {
  908.             int var38;
  909.             for(var38 = 0; var14 > 1; var14 >>= 1) {
  910.                if ((var14 & 1) != 0) {
  911.                   var4 *= big10pow[var38];
  912.                }
  913.  
  914.                ++var38;
  915.             }
  916.  
  917.             double var16 = var4 * big10pow[var38];
  918.             if (Double.isInfinite(var16)) {
  919.                var16 = var4 / (double)2.0F;
  920.                var16 *= big10pow[var38];
  921.                if (Double.isInfinite(var16)) {
  922.                   return this.isNegative ? Double.NEGATIVE_INFINITY : Double.POSITIVE_INFINITY;
  923.                }
  924.  
  925.                var16 = Double.MAX_VALUE;
  926.             }
  927.  
  928.             var4 = var16;
  929.          }
  930.       } else if (var14 < 0) {
  931.          var14 = -var14;
  932.          if (this.decExponent < -325) {
  933.             return this.isNegative ? (double)-0.0F : (double)0.0F;
  934.          }
  935.  
  936.          if ((var14 & 15) != 0) {
  937.             var4 /= small10pow[var14 & 15];
  938.          }
  939.  
  940.          if ((var14 = var14 >> 4) != 0) {
  941.             int var39;
  942.             for(var39 = 0; var14 > 1; var14 >>= 1) {
  943.                if ((var14 & 1) != 0) {
  944.                   var4 *= tiny10pow[var39];
  945.                }
  946.  
  947.                ++var39;
  948.             }
  949.  
  950.             double var43 = var4 * tiny10pow[var39];
  951.             if (var43 == (double)0.0F) {
  952.                var43 = var4 * (double)2.0F;
  953.                var43 *= tiny10pow[var39];
  954.                if (var43 == (double)0.0F) {
  955.                   return this.isNegative ? (double)-0.0F : (double)0.0F;
  956.                }
  957.  
  958.                var43 = Double.MIN_VALUE;
  959.             }
  960.  
  961.             var4 = var43;
  962.          }
  963.       }
  964.  
  965.       FDBigInt var40 = new FDBigInt(var2, this.digits, var1, this.nDigits);
  966.       var14 = this.decExponent - this.nDigits;
  967.  
  968.       do {
  969.          FDBigInt var46 = this.doubleToBigInt(var4);
  970.          int var17;
  971.          int var18;
  972.          int var19;
  973.          int var20;
  974.          if (var14 >= 0) {
  975.             var18 = 0;
  976.             var17 = 0;
  977.             var20 = var14;
  978.             var19 = var14;
  979.          } else {
  980.             var17 = var18 = -var14;
  981.             var20 = 0;
  982.             var19 = 0;
  983.          }
  984.  
  985.          if (this.bigIntExp >= 0) {
  986.             var17 += this.bigIntExp;
  987.          } else {
  988.             var19 -= this.bigIntExp;
  989.          }
  990.  
  991.          int var22;
  992.          if (this.bigIntExp + this.bigIntNBits <= -1022) {
  993.             var22 = this.bigIntExp + 1023 + 52;
  994.          } else {
  995.             var22 = 54 - this.bigIntNBits;
  996.          }
  997.  
  998.          int var48 = var17 + var22;
  999.          var19 += var22;
  1000.          int var23 = Math.min(var48, Math.min(var19, var17));
  1001.          int var49 = var48 - var23;
  1002.          var19 -= var23;
  1003.          int var52 = var17 - var23;
  1004.          var46 = multPow52(var46, var18, var49);
  1005.          FDBigInt var24 = multPow52(new FDBigInt(var40), var20, var19);
  1006.          FDBigInt var25;
  1007.          int var26;
  1008.          boolean var27;
  1009.          if ((var26 = var46.cmp(var24)) > 0) {
  1010.             var27 = true;
  1011.             var25 = var46.sub(var24);
  1012.             if (this.bigIntNBits == 1 && this.bigIntExp > -1023) {
  1013.                --var52;
  1014.                if (var52 < 0) {
  1015.                   var52 = 0;
  1016.                   var25.lshiftMe(1);
  1017.                }
  1018.             }
  1019.          } else {
  1020.             if (var26 >= 0) {
  1021.                break;
  1022.             }
  1023.  
  1024.             var27 = false;
  1025.             var25 = var24.sub(var46);
  1026.          }
  1027.  
  1028.          FDBigInt var28 = constructPow52(var18, var52);
  1029.          if ((var26 = var25.cmp(var28)) < 0) {
  1030.             this.roundDir = var27 ? -1 : 1;
  1031.             break;
  1032.          }
  1033.  
  1034.          if (var26 == 0) {
  1035.             var4 += (double)0.5F * ulp(var4, var27);
  1036.             this.roundDir = var27 ? -1 : 1;
  1037.             break;
  1038.          }
  1039.  
  1040.          var4 += ulp(var4, var27);
  1041.       } while(var4 != (double)0.0F && var4 != Double.POSITIVE_INFINITY);
  1042.  
  1043.       return this.isNegative ? -var4 : var4;
  1044.    }
  1045.  
  1046.    public float floatValue() {
  1047.       int var1 = Math.min(this.nDigits, 8);
  1048.       int var2 = this.digits[0] - 48;
  1049.  
  1050.       for(int var4 = 1; var4 < var1; ++var4) {
  1051.          var2 = var2 * 10 + this.digits[var4] - 48;
  1052.       }
  1053.  
  1054.       float var3 = (float)var2;
  1055.       int var5 = this.decExponent - var1;
  1056.       if (this.nDigits <= 7) {
  1057.          if (var5 == 0 || var3 == 0.0F) {
  1058.             return this.isNegative ? -var3 : var3;
  1059.          }
  1060.  
  1061.          if (var5 >= 0) {
  1062.             if (var5 <= singleMaxSmallTen) {
  1063.                var3 *= singleSmall10pow[var5];
  1064.                return this.isNegative ? -var3 : var3;
  1065.             }
  1066.  
  1067.             int var6 = 7 - var1;
  1068.             if (var5 <= singleMaxSmallTen + var6) {
  1069.                var3 *= singleSmall10pow[var6];
  1070.                var3 *= singleSmall10pow[var5 - var6];
  1071.                return this.isNegative ? -var3 : var3;
  1072.             }
  1073.          } else if (var5 >= -singleMaxSmallTen) {
  1074.             var3 /= singleSmall10pow[-var5];
  1075.             return this.isNegative ? -var3 : var3;
  1076.          }
  1077.       } else if (this.decExponent >= this.nDigits && this.nDigits + this.decExponent <= 15) {
  1078.          long var18 = (long)var2;
  1079.  
  1080.          for(int var8 = var1; var8 < this.nDigits; ++var8) {
  1081.             var18 = var18 * 10L + (long)(this.digits[var8] - 48);
  1082.          }
  1083.  
  1084.          double var9 = (double)var18;
  1085.          var5 = this.decExponent - this.nDigits;
  1086.          var9 *= small10pow[var5];
  1087.          var3 = (float)var9;
  1088.          return this.isNegative ? -var3 : var3;
  1089.       }
  1090.  
  1091.       if (this.decExponent > 39) {
  1092.          return this.isNegative ? Float.NEGATIVE_INFINITY : Float.POSITIVE_INFINITY;
  1093.       } else if (this.decExponent < -46) {
  1094.          return this.isNegative ? -0.0F : 0.0F;
  1095.       } else {
  1096.          this.mustSetRoundDir = true;
  1097.          double var17 = this.doubleValue();
  1098.          return this.stickyRound(var17);
  1099.       }
  1100.    }
  1101.  
  1102.    static {
  1103.       maxSmallTen = small10pow.length - 1;
  1104.       singleMaxSmallTen = singleSmall10pow.length - 1;
  1105.       small5pow = new int[]{1, 5, 25, 125, 625, 3125, 15625, 78125, 390625, 1953125, 9765625, 48828125, 244140625, 1220703125};
  1106.       long5pow = new long[]{1L, 5L, 25L, 125L, 625L, 3125L, 15625L, 78125L, 390625L, 1953125L, 9765625L, 48828125L, 244140625L, 1220703125L, 6103515625L, 30517578125L, 152587890625L, 762939453125L, 3814697265625L, 19073486328125L, 95367431640625L, 476837158203125L, 2384185791015625L, 11920928955078125L, 59604644775390625L, 298023223876953125L, 1490116119384765625L};
  1107.       n5bits = new int[]{0, 3, 5, 7, 10, 12, 14, 17, 19, 21, 24, 26, 28, 31, 33, 35, 38, 40, 42, 45, 47, 49, 52, 54, 56, 59, 61};
  1108.       infinity = new char[]{'I', 'n', 'f', 'i', 'n', 'i', 't', 'y'};
  1109.       notANumber = new char[]{'N', 'a', 'N'};
  1110.       zero = new char[]{'0', '0', '0', '0', '0', '0', '0', '0'};
  1111.    }
  1112. }
  1113.