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