home *** CD-ROM | disk | FTP | other *** search
/ PC Pro 1999 April / DPPCPRO0499.ISO / April / Notes / 50b2wic.exe / DATA1.CAB / NotesProgramFilesJavaSupport / rt.jar / java / lang / FloatingDecimal.class (.txt) < prev    next >
Encoding:
Java Class File  |  1998-04-23  |  9.4 KB  |  632 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.    static final long signMask = Long.MIN_VALUE;
  10.    static final long expMask = 9218868437227405312L;
  11.    static final long fractMask = 4503599627370495L;
  12.    static final int expShift = 52;
  13.    static final int expBias = 1023;
  14.    static final long fractHOB = 1L << 52;
  15.    static final long expOne = 1023L << 52;
  16.    static final int maxSmallBinExp = 62;
  17.    static final int minSmallBinExp = -21;
  18.    static final long highbyte = -72057594037927936L;
  19.    static final long highbit = Long.MIN_VALUE;
  20.    static final long lowbytes = 72057594037927935L;
  21.    static final int singleSignMask = Integer.MIN_VALUE;
  22.    static final int singleExpMask = 2139095040;
  23.    static final int singleFractMask = 8388607;
  24.    static final int singleExpShift = 23;
  25.    static final int singleFractHOB = 8388608;
  26.    static final int singleExpBias = 127;
  27.    private static FDBigInt[] b5p;
  28.    private static final int[] small5pow = new int[]{1, 5, 25, 125, 625, 3125, 15625, 78125, 390625, 1953125, 9765625, 48828125, 244140625, 1220703125};
  29.    private static final long[] 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};
  30.    private static final int[] 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};
  31.    private static final char[] infinity = new char[]{'I', 'n', 'f', 'i', 'n', 'i', 't', 'y'};
  32.    private static final char[] notANumber = new char[]{'N', 'a', 'N'};
  33.    private static final char[] zero = new char[]{'0', '0', '0', '0', '0', '0', '0', '0'};
  34.  
  35.    private FloatingDecimal(boolean var1, int var2, char[] var3, int var4, boolean var5) {
  36.       this.isNegative = var1;
  37.       this.isExceptional = var5;
  38.       this.decExponent = var2;
  39.       this.digits = var3;
  40.       this.nDigits = var4;
  41.    }
  42.  
  43.    private static int countBits(long var0) {
  44.       if (var0 == 0L) {
  45.          return 0;
  46.       } else {
  47.          while((var0 & -72057594037927936L) == 0L) {
  48.             var0 <<= 8;
  49.          }
  50.  
  51.          while(var0 > 0L) {
  52.             var0 <<= 1;
  53.          }
  54.  
  55.          int var2;
  56.          for(var2 = 0; (var0 & 72057594037927935L) != 0L; var2 += 8) {
  57.             var0 <<= 8;
  58.          }
  59.  
  60.          while(var0 != 0L) {
  61.             var0 <<= 1;
  62.             ++var2;
  63.          }
  64.  
  65.          return var2;
  66.       }
  67.    }
  68.  
  69.    private static FDBigInt big5pow(int var0) {
  70.       if (var0 < 0) {
  71.          throw new RuntimeException("Assertion botch: negative power of 5");
  72.       } else {
  73.          if (b5p == null) {
  74.             b5p = new FDBigInt[var0 + 1];
  75.          } else if (b5p.length <= var0) {
  76.             FDBigInt[] var1 = new FDBigInt[var0 + 1];
  77.             System.arraycopy(b5p, 0, var1, 0, b5p.length);
  78.             b5p = var1;
  79.          }
  80.  
  81.          if (b5p[var0] != null) {
  82.             return b5p[var0];
  83.          } else if (var0 < small5pow.length) {
  84.             return b5p[var0] = new FDBigInt(small5pow[var0]);
  85.          } else if (var0 < long5pow.length) {
  86.             return b5p[var0] = new FDBigInt(long5pow[var0]);
  87.          } else {
  88.             int var5 = var0 >> 1;
  89.             int var2 = var0 - var5;
  90.             FDBigInt var3 = b5p[var5];
  91.             if (var3 == null) {
  92.                var3 = big5pow(var5);
  93.             }
  94.  
  95.             if (var2 < small5pow.length) {
  96.                return b5p[var0] = var3.mult(small5pow[var2]);
  97.             } else {
  98.                FDBigInt var4 = b5p[var2];
  99.                if (var4 == null) {
  100.                   var4 = big5pow(var2);
  101.                }
  102.  
  103.                return b5p[var0] = var3.mult(var4);
  104.             }
  105.          }
  106.       }
  107.    }
  108.  
  109.    private void developLongDigits(int var1, long var2, long var4) {
  110.       int var10;
  111.       for(var10 = 0; var4 >= 10L; ++var10) {
  112.          var4 /= 10L;
  113.       }
  114.  
  115.       if (var10 != 0) {
  116.          long var11 = long5pow[var10] << var10;
  117.          long var13 = var2 % var11;
  118.          var2 /= var11;
  119.          var1 += var10;
  120.          if (var13 >= var11 >> 1) {
  121.             ++var2;
  122.          }
  123.       }
  124.  
  125.       char[] var6;
  126.       byte var7;
  127.       int var8;
  128.       if (var2 <= 2147483647L) {
  129.          if (var2 <= 0L) {
  130.             throw new RuntimeException("Assertion botch: value " + var2 + " <= 0");
  131.          }
  132.  
  133.          int var18 = (int)var2;
  134.          var7 = 10;
  135.          var6 = new char[10];
  136.          var8 = var7 - 1;
  137.          int var9 = var18 % 10;
  138.  
  139.          for(var18 /= 10; var9 == 0; var18 /= 10) {
  140.             ++var1;
  141.             var9 = var18 % 10;
  142.          }
  143.  
  144.          while(var18 != 0) {
  145.             var6[var8--] = (char)(var9 + 48);
  146.             ++var1;
  147.             var9 = var18 % 10;
  148.             var18 /= 10;
  149.          }
  150.  
  151.          var6[var8] = (char)(var9 + 48);
  152.       } else {
  153.          var7 = 20;
  154.          var6 = new char[20];
  155.          var8 = var7 - 1;
  156.          int var17 = (int)(var2 % 10L);
  157.  
  158.          for(var2 /= 10L; var17 == 0; var2 /= 10L) {
  159.             ++var1;
  160.             var17 = (int)(var2 % 10L);
  161.          }
  162.  
  163.          while(var2 != 0L) {
  164.             var6[var8--] = (char)(var17 + 48);
  165.             ++var1;
  166.             var17 = (int)(var2 % 10L);
  167.             var2 /= 10L;
  168.          }
  169.  
  170.          var6[var8] = (char)(var17 + 48);
  171.       }
  172.  
  173.       var7 -= var8;
  174.       char[] var20;
  175.       if (var8 == 0) {
  176.          var20 = var6;
  177.       } else {
  178.          var20 = new char[var7];
  179.          System.arraycopy(var6, var8, var20, 0, var7);
  180.       }
  181.  
  182.       this.digits = var20;
  183.       this.decExponent = var1 + 1;
  184.       this.nDigits = var7;
  185.    }
  186.  
  187.    private void roundup() {
  188.       int var1;
  189.       char var2 = this.digits[var1 = this.nDigits - 1];
  190.       if (var2 == '9') {
  191.          while(var2 == '9' && var1 > 0) {
  192.             this.digits[var1] = '0';
  193.             --var1;
  194.             var2 = this.digits[var1];
  195.          }
  196.  
  197.          if (var2 == '9') {
  198.             ++this.decExponent;
  199.             this.digits[0] = '1';
  200.             return;
  201.          }
  202.       }
  203.  
  204.       this.digits[var1] = (char)(var2 + 1);
  205.    }
  206.  
  207.    public FloatingDecimal(double var1) {
  208.       long var3 = Double.doubleToLongBits(var1);
  209.       if ((var3 & Long.MIN_VALUE) != 0L) {
  210.          this.isNegative = true;
  211.          var3 ^= Long.MIN_VALUE;
  212.       } else {
  213.          this.isNegative = false;
  214.       }
  215.  
  216.       int var7 = (int)((var3 & 9218868437227405312L) >> 52);
  217.       long var5 = var3 & 4503599627370495L;
  218.       if (var7 == (int)(9218868437227405312L >> 52)) {
  219.          this.isExceptional = true;
  220.          if (var5 == 0L) {
  221.             this.digits = infinity;
  222.          } else {
  223.             this.digits = notANumber;
  224.             this.isNegative = false;
  225.          }
  226.  
  227.          this.nDigits = this.digits.length;
  228.       } else {
  229.          this.isExceptional = false;
  230.          int var8;
  231.          if (var7 == 0) {
  232.             if (var5 == 0L) {
  233.                this.decExponent = 0;
  234.                this.digits = zero;
  235.                this.nDigits = 1;
  236.                return;
  237.             }
  238.  
  239.             while((var5 & 1L << 52) == 0L) {
  240.                var5 <<= 1;
  241.                --var7;
  242.             }
  243.  
  244.             var8 = 52 + var7;
  245.             ++var7;
  246.          } else {
  247.             var5 |= 1L << 52;
  248.             var8 = 53;
  249.          }
  250.  
  251.          var7 -= 1023;
  252.          this.dtoa(var7, var5, var8);
  253.       }
  254.    }
  255.  
  256.    public FloatingDecimal(float var1) {
  257.       int var2 = Float.floatToIntBits(var1);
  258.       if ((var2 & Integer.MIN_VALUE) != 0) {
  259.          this.isNegative = true;
  260.          var2 ^= Integer.MIN_VALUE;
  261.       } else {
  262.          this.isNegative = false;
  263.       }
  264.  
  265.       int var4 = (var2 & 2139095040) >> 23;
  266.       int var3 = var2 & 8388607;
  267.       if (var4 == 255) {
  268.          this.isExceptional = true;
  269.          if ((long)var3 == 0L) {
  270.             this.digits = infinity;
  271.          } else {
  272.             this.digits = notANumber;
  273.             this.isNegative = false;
  274.          }
  275.  
  276.          this.nDigits = this.digits.length;
  277.       } else {
  278.          this.isExceptional = false;
  279.          int var5;
  280.          if (var4 == 0) {
  281.             if (var3 == 0) {
  282.                this.decExponent = 0;
  283.                this.digits = zero;
  284.                this.nDigits = 1;
  285.                return;
  286.             }
  287.  
  288.             while((var3 & 8388608) == 0) {
  289.                var3 <<= 1;
  290.                --var4;
  291.             }
  292.  
  293.             var5 = 23 + var4;
  294.             ++var4;
  295.          } else {
  296.             var3 |= 8388608;
  297.             var5 = 24;
  298.          }
  299.  
  300.          var4 -= 127;
  301.          this.dtoa(var4, (long)var3 << 29, var5);
  302.       }
  303.    }
  304.  
  305.    private void dtoa(int var1, long var2, int var4) {
  306.       int var5 = countBits(var2);
  307.       int var6 = Math.max(0, var5 - var1 - 1);
  308.       if (var1 <= 62 && var1 >= -21 && var6 < long5pow.length && var5 + n5bits[var6] < 64 && var6 == 0) {
  309.          long var39;
  310.          if (var1 > var4) {
  311.             var39 = 1L << var1 - var4 - 1;
  312.          } else {
  313.             var39 = 0L;
  314.          }
  315.  
  316.          if (var1 >= 52) {
  317.             var2 <<= var1 - 52;
  318.          } else {
  319.             var2 >>>= 52 - var1;
  320.          }
  321.  
  322.          this.developLongDigits(0, var2, var39);
  323.       } else {
  324.          double var8 = Double.longBitsToDouble(1023L << 52 | var2 & ~(1L << 52));
  325.          int var7 = (int)Math.floor((var8 - (double)1.5F) * 0.289529654 + 0.176091259 + (double)var1 * 0.301029995663981);
  326.          int var11 = Math.max(0, -var7);
  327.          int var10 = var11 + var6 + var1;
  328.          int var13 = Math.max(0, var7);
  329.          int var12 = var13 + var6;
  330.          int var14 = var10 - var4;
  331.          var2 >>>= 53 - var5;
  332.          var10 -= var5 - 1;
  333.          int var21 = Math.min(var10, var12);
  334.          var10 -= var21;
  335.          var12 -= var21;
  336.          var14 -= var21;
  337.          if (var5 == 1) {
  338.             --var14;
  339.          }
  340.  
  341.          if (var14 < 0) {
  342.             var10 -= var14;
  343.             var12 -= var14;
  344.             var14 = 0;
  345.          }
  346.  
  347.          char[] var22 = this.digits = new char[18];
  348.          int var23 = 0;
  349.          int var16 = var5 + var10 + (var11 < n5bits.length ? n5bits[var11] : var11 * 3);
  350.          int var17 = var12 + 1 + (var13 + 1 < n5bits.length ? n5bits[var13 + 1] : (var13 + 1) * 3);
  351.          boolean var24;
  352.          boolean var25;
  353.          long var26;
  354.          if (var16 < 64 && var17 < 64) {
  355.             if (var16 < 32 && var17 < 32) {
  356.                int var53 = (int)var2 * small5pow[var11] << var10;
  357.                int var55 = small5pow[var13] << var12;
  358.                int var56 = small5pow[var11] << var14;
  359.                int var32 = var55 * 10;
  360.                var23 = 0;
  361.                int var49 = var53 / var55;
  362.                var53 = 10 * (var53 % var55);
  363.                var56 *= 10;
  364.                var24 = var53 < var56;
  365.                var25 = var53 + var56 > var32;
  366.                if (var49 >= 10) {
  367.                   throw new RuntimeException("Assertion botch: excessivly large digit " + var49);
  368.                }
  369.  
  370.                if (var49 == 0 && !var25) {
  371.                   --var7;
  372.                } else {
  373.                   var22[var23++] = (char)(48 + var49);
  374.                }
  375.  
  376.                if (var7 <= -3 || var7 >= 8) {
  377.                   var24 = false;
  378.                   var25 = false;
  379.                }
  380.  
  381.                for(; !var24 && !var25; var22[var23++] = (char)(48 + var49)) {
  382.                   var49 = var53 / var55;
  383.                   var53 = 10 * (var53 % var55);
  384.                   var56 *= 10;
  385.                   if (var49 >= 10) {
  386.                      throw new RuntimeException("Assertion botch: excessivly large digit " + var49);
  387.                   }
  388.  
  389.                   if ((long)var56 > 0L) {
  390.                      var24 = var53 < var56;
  391.                      var25 = var53 + var56 > var32;
  392.                   } else {
  393.                      var24 = true;
  394.                      var25 = true;
  395.                   }
  396.                }
  397.  
  398.                var26 = (long)((var53 << 1) - var32);
  399.             } else {
  400.                long var51 = var2 * long5pow[var11] << var10;
  401.                long var31 = long5pow[var13] << var12;
  402.                long var33 = long5pow[var11] << var14;
  403.                long var35 = var31 * 10L;
  404.                var23 = 0;
  405.                int var47 = (int)(var51 / var31);
  406.                var51 = 10L * (var51 % var31);
  407.                var33 *= 10L;
  408.                var24 = var51 < var33;
  409.                var25 = var51 + var33 > var35;
  410.                if (var47 >= 10) {
  411.                   throw new RuntimeException("Assertion botch: excessivly large digit " + var47);
  412.                }
  413.  
  414.                if (var47 == 0 && !var25) {
  415.                   --var7;
  416.                } else {
  417.                   var22[var23++] = (char)(48 + var47);
  418.                }
  419.  
  420.                if (var7 <= -3 || var7 >= 8) {
  421.                   var24 = false;
  422.                   var25 = false;
  423.                }
  424.  
  425.                for(; !var24 && !var25; var22[var23++] = (char)(48 + var47)) {
  426.                   var47 = (int)(var51 / var31);
  427.                   var51 = 10L * (var51 % var31);
  428.                   var33 *= 10L;
  429.                   if (var47 >= 10) {
  430.                      throw new RuntimeException("Assertion botch: excessivly large digit " + var47);
  431.                   }
  432.  
  433.                   if (var33 > 0L) {
  434.                      var24 = var51 < var33;
  435.                      var25 = var51 + var33 > var35;
  436.                   } else {
  437.                      var24 = true;
  438.                      var25 = true;
  439.                   }
  440.                }
  441.  
  442.                var26 = (var51 << 1) - var35;
  443.             }
  444.          } else {
  445.             FDBigInt var19 = new FDBigInt(var2);
  446.             if (var11 != 0) {
  447.                if (var11 < small5pow.length) {
  448.                   var19 = var19.mult(small5pow[var11]);
  449.                } else {
  450.                   var19 = var19.mult(big5pow(var11));
  451.                }
  452.             }
  453.  
  454.             if (var10 != 0) {
  455.                var19.lshiftMe(var10);
  456.             }
  457.  
  458.             FDBigInt var18 = new FDBigInt(big5pow(var13));
  459.             if (var12 != 0) {
  460.                var18.lshiftMe(var12);
  461.             }
  462.  
  463.             FDBigInt var20 = new FDBigInt(big5pow(var11));
  464.             if (var14 != 0) {
  465.                var20.lshiftMe(var14);
  466.             }
  467.  
  468.             int var30;
  469.             var19.lshiftMe(var30 = var18.normalizeMe());
  470.             var20.lshiftMe(var30);
  471.             FDBigInt var29 = var18.mult(10);
  472.             var23 = 0;
  473.             int var28 = var19.quoRemIteration(var18);
  474.             var20 = var20.mult(10);
  475.             var24 = var19.cmp(var20) < 0;
  476.             var25 = var19.add(var20).cmp(var29) > 0;
  477.             if (var28 >= 10) {
  478.                throw new RuntimeException("Assertion botch: excessivly large digit " + var28);
  479.             }
  480.  
  481.             if (var28 == 0 && !var25) {
  482.                --var7;
  483.             } else {
  484.                var22[var23++] = (char)(48 + var28);
  485.             }
  486.  
  487.             if (var7 <= -3 || var7 >= 8) {
  488.                var24 = false;
  489.                var25 = false;
  490.             }
  491.  
  492.             while(!var24 && !var25) {
  493.                var28 = var19.quoRemIteration(var18);
  494.                var20 = var20.mult(10);
  495.                if (var28 >= 10) {
  496.                   throw new RuntimeException("Assertion botch: excessivly large digit " + var28);
  497.                }
  498.  
  499.                var24 = var19.cmp(var20) < 0;
  500.                var25 = var19.add(var20).cmp(var29) > 0;
  501.                var22[var23++] = (char)(48 + var28);
  502.             }
  503.  
  504.             if (var25 && var24) {
  505.                var19.lshiftMe(1);
  506.                var26 = (long)var19.cmp(var29);
  507.             } else {
  508.                var26 = 0L;
  509.             }
  510.          }
  511.  
  512.          this.decExponent = var7 + 1;
  513.          this.digits = var22;
  514.          this.nDigits = var23;
  515.          if (var25) {
  516.             if (var24) {
  517.                if (var26 == 0L) {
  518.                   if ((var22[this.nDigits - 1] & 1) != 0) {
  519.                      this.roundup();
  520.                      return;
  521.                   }
  522.  
  523.                   return;
  524.                }
  525.  
  526.                if (var26 > 0L) {
  527.                   this.roundup();
  528.                   return;
  529.                }
  530.             } else {
  531.                this.roundup();
  532.             }
  533.          }
  534.  
  535.       }
  536.    }
  537.  
  538.    public String toString() {
  539.       StringBuffer var1 = new StringBuffer(this.nDigits + 8);
  540.       if (this.isNegative) {
  541.          var1.append('-');
  542.       }
  543.  
  544.       if (this.isExceptional) {
  545.          var1.append(this.digits, 0, this.nDigits);
  546.       } else {
  547.          var1.append("0.");
  548.          var1.append(this.digits, 0, this.nDigits);
  549.          var1.append('e');
  550.          var1.append(this.decExponent);
  551.       }
  552.  
  553.       return new String(var1);
  554.    }
  555.  
  556.    public String toJavaFormatString() {
  557.       char[] var1 = new char[this.nDigits + 10];
  558.       int var2 = 0;
  559.       if (this.isNegative) {
  560.          var1[0] = '-';
  561.          var2 = 1;
  562.       }
  563.  
  564.       if (this.isExceptional) {
  565.          System.arraycopy(this.digits, 0, var1, var2, this.nDigits);
  566.          var2 += this.nDigits;
  567.       } else if (this.decExponent > 0 && this.decExponent < 8) {
  568.          int var20 = Math.min(this.nDigits, this.decExponent);
  569.          System.arraycopy(this.digits, 0, var1, var2, var20);
  570.          var2 += var20;
  571.          if (var20 < this.decExponent) {
  572.             var20 = this.decExponent - var20;
  573.             System.arraycopy(zero, 0, var1, var2, var20);
  574.             var2 += var20;
  575.             var1[var2++] = '.';
  576.             var1[var2++] = '0';
  577.          } else {
  578.             var1[var2++] = '.';
  579.             if (var20 < this.nDigits) {
  580.                int var4 = this.nDigits - var20;
  581.                System.arraycopy(this.digits, var20, var1, var2, var4);
  582.                var2 += var4;
  583.             } else {
  584.                var1[var2++] = '0';
  585.             }
  586.          }
  587.       } else if (this.decExponent <= 0 && this.decExponent > -3) {
  588.          var1[var2++] = '0';
  589.          var1[var2++] = '.';
  590.          if (this.decExponent != 0) {
  591.             System.arraycopy(zero, 0, var1, var2, -this.decExponent);
  592.             var2 -= this.decExponent;
  593.          }
  594.  
  595.          System.arraycopy(this.digits, 0, var1, var2, this.nDigits);
  596.          var2 += this.nDigits;
  597.       } else {
  598.          var1[var2++] = this.digits[0];
  599.          var1[var2++] = '.';
  600.          if (this.nDigits > 1) {
  601.             System.arraycopy(this.digits, 1, var1, var2, this.nDigits - 1);
  602.             var2 += this.nDigits - 1;
  603.          } else {
  604.             var1[var2++] = '0';
  605.          }
  606.  
  607.          var1[var2++] = 'E';
  608.          int var3;
  609.          if (this.decExponent <= 0) {
  610.             var1[var2++] = '-';
  611.             var3 = -this.decExponent + 1;
  612.          } else {
  613.             var3 = this.decExponent - 1;
  614.          }
  615.  
  616.          if (var3 <= 9) {
  617.             var1[var2++] = (char)(var3 + 48);
  618.          } else if (var3 <= 99) {
  619.             var1[var2++] = (char)(var3 / 10 + 48);
  620.             var1[var2++] = (char)(var3 % 10 + 48);
  621.          } else {
  622.             var1[var2++] = (char)(var3 / 100 + 48);
  623.             var3 %= 100;
  624.             var1[var2++] = (char)(var3 / 10 + 48);
  625.             var1[var2++] = (char)(var3 % 10 + 48);
  626.          }
  627.       }
  628.  
  629.       return new String(var1, 0, var2);
  630.    }
  631. }
  632.