home *** CD-ROM | disk | FTP | other *** search
/ PC Pro 1999 April / DPPCPRO0499.ISO / April / Notes / 50b2wic.exe / DATA1.CAB / NotesProgramFilesJavaSupport / rt.jar / java / math / BigDecimal.class (.txt) next >
Encoding:
Java Class File  |  1998-04-23  |  6.3 KB  |  311 lines
  1. package java.math;
  2.  
  3. public class BigDecimal extends Number {
  4.    private BigInteger intVal;
  5.    private int scale;
  6.    public static final int ROUND_UP = 0;
  7.    public static final int ROUND_DOWN = 1;
  8.    public static final int ROUND_CEILING = 2;
  9.    public static final int ROUND_FLOOR = 3;
  10.    public static final int ROUND_HALF_UP = 4;
  11.    public static final int ROUND_HALF_DOWN = 5;
  12.    public static final int ROUND_HALF_EVEN = 6;
  13.    public static final int ROUND_UNNECESSARY = 7;
  14.  
  15.    public BigDecimal(String var1) throws NumberFormatException {
  16.       int var2 = var1.indexOf(46);
  17.       if (var2 == -1) {
  18.          this.intVal = new BigInteger(var1);
  19.       } else if (var2 == var1.length() - 1) {
  20.          this.intVal = new BigInteger(var1.substring(0, var1.length() - 1));
  21.       } else {
  22.          String var3 = var1.substring(var2 + 1);
  23.          this.scale = var3.length();
  24.          BigInteger var4 = new BigInteger(var3);
  25.          if (var4.signum() < 0) {
  26.             throw new NumberFormatException();
  27.          } else if (var2 == 0) {
  28.             this.intVal = var4;
  29.          } else if (var1.charAt(0) == '-' && var2 == 1) {
  30.             this.intVal = var4.negate();
  31.          } else {
  32.             String var5 = var1.substring(0, var2);
  33.             BigInteger var6 = new BigInteger(var5);
  34.             if (var1.charAt(0) == '-') {
  35.                var4 = var4.negate();
  36.             }
  37.  
  38.             this.intVal = timesTenToThe(var6, this.scale).add(var4);
  39.          }
  40.       }
  41.    }
  42.  
  43.    public BigDecimal(double var1) throws NumberFormatException {
  44.       if (!Double.isInfinite(var1) && !Double.isNaN(var1)) {
  45.          long var3 = Double.doubleToLongBits(var1);
  46.          int var5 = var3 >> 63 == 0L ? 1 : -1;
  47.          int var6 = (int)(var3 >> 52 & 2047L);
  48.          long var7 = var6 == 0 ? (var3 & (1L << 52) - 1L) << 1 : var3 & (1L << 52) - 1L | 1L << 52;
  49.          var6 -= 1075;
  50.          if (var7 == 0L) {
  51.             this.intVal = BigInteger.valueOf(0L);
  52.          } else {
  53.             while((var7 & 1L) == 0L) {
  54.                var7 >>= 1;
  55.                ++var6;
  56.             }
  57.  
  58.             this.intVal = BigInteger.valueOf((long)var5 * var7);
  59.             if (var6 < 0) {
  60.                this.intVal = this.intVal.multiply(BigInteger.valueOf(5L).pow(-var6));
  61.                this.scale = -var6;
  62.             } else {
  63.                if (var6 > 0) {
  64.                   this.intVal = this.intVal.multiply(BigInteger.valueOf(2L).pow(var6));
  65.                }
  66.  
  67.             }
  68.          }
  69.       } else {
  70.          throw new NumberFormatException("Infinite or NaN");
  71.       }
  72.    }
  73.  
  74.    public BigDecimal(BigInteger var1) {
  75.       this.intVal = var1;
  76.    }
  77.  
  78.    public BigDecimal(BigInteger var1, int var2) throws NumberFormatException {
  79.       if (var2 < 0) {
  80.          throw new NumberFormatException("Negative scale");
  81.       } else {
  82.          this.intVal = var1;
  83.          this.scale = var2;
  84.       }
  85.    }
  86.  
  87.    public static BigDecimal valueOf(long var0, int var2) throws NumberFormatException {
  88.       return new BigDecimal(BigInteger.valueOf(var0), var2);
  89.    }
  90.  
  91.    public static BigDecimal valueOf(long var0) {
  92.       return valueOf(var0, 0);
  93.    }
  94.  
  95.    public BigDecimal add(BigDecimal var1) {
  96.       BigDecimal[] var2 = new BigDecimal[]{this, var1};
  97.       matchScale(var2);
  98.       return new BigDecimal(var2[0].intVal.add(var2[1].intVal), var2[0].scale);
  99.    }
  100.  
  101.    public BigDecimal subtract(BigDecimal var1) {
  102.       BigDecimal[] var2 = new BigDecimal[]{this, var1};
  103.       matchScale(var2);
  104.       return new BigDecimal(var2[0].intVal.subtract(var2[1].intVal), var2[0].scale);
  105.    }
  106.  
  107.    public BigDecimal multiply(BigDecimal var1) {
  108.       return new BigDecimal(this.intVal.multiply(var1.intVal), this.scale + var1.scale);
  109.    }
  110.  
  111.    public BigDecimal divide(BigDecimal var1, int var2, int var3) throws ArithmeticException, IllegalArgumentException {
  112.       if (var2 < 0) {
  113.          throw new ArithmeticException("Negative scale");
  114.       } else if (var3 >= 0 && var3 <= 7) {
  115.          BigDecimal var4;
  116.          BigDecimal var5;
  117.          if (var2 + var1.scale >= this.scale) {
  118.             var4 = this.setScale(var2 + var1.scale);
  119.             var5 = var1;
  120.          } else {
  121.             var4 = this;
  122.             var5 = var1.setScale(this.scale - var2);
  123.          }
  124.  
  125.          BigInteger[] var6 = var4.intVal.divideAndRemainder(var5.intVal);
  126.          BigInteger var7 = var6[0];
  127.          BigInteger var8 = var6[1];
  128.          if (var8.signum() == 0) {
  129.             return new BigDecimal(var7, var2);
  130.          } else if (var3 == 7) {
  131.             throw new ArithmeticException("Rounding necessary");
  132.          } else {
  133.             int var9 = var4.signum() * var5.signum();
  134.             boolean var10;
  135.             if (var3 == 0) {
  136.                var10 = true;
  137.             } else if (var3 == 1) {
  138.                var10 = false;
  139.             } else if (var3 == 2) {
  140.                var10 = var9 > 0;
  141.             } else if (var3 == 3) {
  142.                var10 = var9 < 0;
  143.             } else {
  144.                int var11 = var8.abs().multiply(BigInteger.valueOf(2L)).compareTo(var5.intVal.abs());
  145.                if (var11 < 0) {
  146.                   var10 = false;
  147.                } else if (var11 > 0) {
  148.                   var10 = true;
  149.                } else if (var3 == 4) {
  150.                   var10 = true;
  151.                } else if (var3 == 5) {
  152.                   var10 = false;
  153.                } else {
  154.                   var10 = var7.testBit(0);
  155.                }
  156.             }
  157.  
  158.             return var10 ? new BigDecimal(var7.add(BigInteger.valueOf((long)var9)), var2) : new BigDecimal(var7, var2);
  159.          }
  160.       } else {
  161.          throw new IllegalArgumentException("Invalid rounding mode");
  162.       }
  163.    }
  164.  
  165.    public BigDecimal divide(BigDecimal var1, int var2) throws ArithmeticException, IllegalArgumentException {
  166.       return this.divide(var1, this.scale, var2);
  167.    }
  168.  
  169.    public BigDecimal abs() {
  170.       return this.signum() < 0 ? this.negate() : this;
  171.    }
  172.  
  173.    public BigDecimal negate() {
  174.       return new BigDecimal(this.intVal.negate(), this.scale);
  175.    }
  176.  
  177.    public int signum() {
  178.       return this.intVal.signum();
  179.    }
  180.  
  181.    public int scale() {
  182.       return this.scale;
  183.    }
  184.  
  185.    public BigDecimal setScale(int var1, int var2) throws ArithmeticException, IllegalArgumentException {
  186.       if (var1 < 0) {
  187.          throw new ArithmeticException("Negative scale");
  188.       } else if (var2 >= 0 && var2 <= 7) {
  189.          if (var1 == this.scale) {
  190.             return this;
  191.          } else {
  192.             return var1 > this.scale ? new BigDecimal(timesTenToThe(this.intVal, var1 - this.scale), var1) : this.divide(valueOf(1L), var1, var2);
  193.          }
  194.       } else {
  195.          throw new IllegalArgumentException("Invalid rounding mode");
  196.       }
  197.    }
  198.  
  199.    public BigDecimal setScale(int var1) throws ArithmeticException, IllegalArgumentException {
  200.       return this.setScale(var1, 7);
  201.    }
  202.  
  203.    public BigDecimal movePointLeft(int var1) {
  204.       return var1 >= 0 ? new BigDecimal(this.intVal, this.scale + var1) : this.movePointRight(-var1);
  205.    }
  206.  
  207.    public BigDecimal movePointRight(int var1) {
  208.       return this.scale >= var1 ? new BigDecimal(this.intVal, this.scale - var1) : new BigDecimal(timesTenToThe(this.intVal, var1 - this.scale), 0);
  209.    }
  210.  
  211.    public int compareTo(BigDecimal var1) {
  212.       int var2 = this.signum() - var1.signum();
  213.       if (var2 != 0) {
  214.          return var2 > 0 ? 1 : -1;
  215.       } else {
  216.          BigDecimal[] var3 = new BigDecimal[]{this, var1};
  217.          matchScale(var3);
  218.          return var3[0].intVal.compareTo(var3[1].intVal);
  219.       }
  220.    }
  221.  
  222.    public boolean equals(Object var1) {
  223.       if (!(var1 instanceof BigDecimal)) {
  224.          return false;
  225.       } else {
  226.          BigDecimal var2 = (BigDecimal)var1;
  227.          return this.scale == var2.scale && this.intVal.equals(var2.intVal);
  228.       }
  229.    }
  230.  
  231.    public BigDecimal min(BigDecimal var1) {
  232.       return this.compareTo(var1) < 0 ? this : var1;
  233.    }
  234.  
  235.    public BigDecimal max(BigDecimal var1) {
  236.       return this.compareTo(var1) > 0 ? this : var1;
  237.    }
  238.  
  239.    public int hashCode() {
  240.       return 37 * this.intVal.hashCode() + this.scale;
  241.    }
  242.  
  243.    public String toString() {
  244.       if (this.scale == 0) {
  245.          return this.intVal.toString();
  246.       } else {
  247.          String var2 = this.intVal.abs().toString();
  248.          int var3 = this.signum();
  249.          int var4 = var2.length() - this.scale;
  250.          if (var4 == 0) {
  251.             return (var3 < 0 ? "-0." : "0.") + var2;
  252.          } else {
  253.             StringBuffer var1;
  254.             if (var4 > 0) {
  255.                var1 = new StringBuffer(var2);
  256.                var1.insert(var4, '.');
  257.                if (var3 < 0) {
  258.                   var1.insert(0, '-');
  259.                }
  260.             } else {
  261.                var1 = new StringBuffer(3 - var4 + var2.length());
  262.                var1.append(var3 < 0 ? "-0." : "0.");
  263.  
  264.                for(int var5 = 0; var5 < -var4; ++var5) {
  265.                   var1.append('0');
  266.                }
  267.  
  268.                var1.append(var2);
  269.             }
  270.  
  271.             return var1.toString();
  272.          }
  273.       }
  274.    }
  275.  
  276.    public BigInteger toBigInteger() {
  277.       return this.scale == 0 ? this.intVal : this.intVal.divide(BigInteger.valueOf(10L).pow(this.scale));
  278.    }
  279.  
  280.    public int intValue() {
  281.       return this.toBigInteger().intValue();
  282.    }
  283.  
  284.    public long longValue() {
  285.       return this.toBigInteger().longValue();
  286.    }
  287.  
  288.    public float floatValue() {
  289.       return Float.valueOf(this.toString());
  290.    }
  291.  
  292.    public double doubleValue() {
  293.       return Double.valueOf(this.toString());
  294.    }
  295.  
  296.    private static BigInteger timesTenToThe(BigInteger var0, int var1) {
  297.       return var0.multiply(BigInteger.valueOf(10L).pow(var1));
  298.    }
  299.  
  300.    private static void matchScale(BigDecimal[] var0) {
  301.       if (var0[0].scale < var0[1].scale) {
  302.          var0[0] = var0[0].setScale(var0[1].scale);
  303.       } else {
  304.          if (var0[1].scale < var0[0].scale) {
  305.             var0[1] = var0[1].setScale(var0[0].scale);
  306.          }
  307.  
  308.       }
  309.    }
  310. }
  311.