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 / math / BigDecimal.class (.txt) next >
Encoding:
Java Class File  |  1979-12-31  |  6.0 KB  |  370 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 implements Comparable {
  8.    private BigInteger intVal;
  9.    private int scale = 0;
  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) {
  21.       if (var1.charAt(0) == '+') {
  22.          var1 = var1.substring(1);
  23.          if (var1.charAt(0) == '-') {
  24.             throw new NumberFormatException();
  25.          }
  26.       }
  27.  
  28.       int var2 = 0;
  29.       int var3 = var1.indexOf(101);
  30.       if (var3 == -1) {
  31.          var3 = var1.indexOf(69);
  32.       }
  33.  
  34.       if (var3 != -1) {
  35.          String var4 = var1.substring(var3 + 1);
  36.          if (var4.length() == 0) {
  37.             throw new NumberFormatException();
  38.          }
  39.  
  40.          if (var4.charAt(0) == '+') {
  41.             var4 = var4.substring(1);
  42.             if (var4.charAt(0) == '-') {
  43.                throw new NumberFormatException();
  44.             }
  45.          }
  46.  
  47.          var2 = Integer.parseInt(var4);
  48.          if (var3 == 0) {
  49.             throw new NumberFormatException();
  50.          }
  51.  
  52.          var1 = var1.substring(0, var3);
  53.       }
  54.  
  55.       int var9 = var1.indexOf(46);
  56.       if (var9 == -1) {
  57.          this.intVal = new BigInteger(var1);
  58.       } else if (var9 == var1.length() - 1) {
  59.          this.intVal = new BigInteger(var1.substring(0, var1.length() - 1));
  60.       } else {
  61.          String var5 = var1.substring(var9 + 1);
  62.          this.scale = var5.length();
  63.          BigInteger var6 = new BigInteger(var5);
  64.          if (var1.charAt(var9 + 1) == '-') {
  65.             throw new NumberFormatException();
  66.          }
  67.  
  68.          if (var9 == 0) {
  69.             this.intVal = var6;
  70.          } else if (var1.charAt(0) == '-' && var9 == 1) {
  71.             this.intVal = var6.negate();
  72.          } else {
  73.             String var7 = var1.substring(0, var9);
  74.             BigInteger var8 = new BigInteger(var7);
  75.             if (var1.charAt(0) == '-') {
  76.                var6 = var6.negate();
  77.             }
  78.  
  79.             this.intVal = timesTenToThe(var8, this.scale).add(var6);
  80.          }
  81.       }
  82.  
  83.       this.scale -= var2;
  84.       if (this.scale < 0) {
  85.          this.intVal = timesTenToThe(this.intVal, -this.scale);
  86.          this.scale = 0;
  87.       }
  88.  
  89.    }
  90.  
  91.    public BigDecimal(double var1) {
  92.       if (!Double.isInfinite(var1) && !Double.isNaN(var1)) {
  93.          long var3 = Double.doubleToLongBits(var1);
  94.          int var5 = var3 >> 63 == 0L ? 1 : -1;
  95.          int var6 = (int)(var3 >> 52 & 2047L);
  96.          long var7 = var6 == 0 ? (var3 & 4503599627370495L) << 1 : var3 & 4503599627370495L | 4503599627370496L;
  97.          var6 -= 1075;
  98.          if (var7 == 0L) {
  99.             this.intVal = BigInteger.ZERO;
  100.          } else {
  101.             while((var7 & 1L) == 0L) {
  102.                var7 >>= 1;
  103.                ++var6;
  104.             }
  105.  
  106.             this.intVal = BigInteger.valueOf((long)var5 * var7);
  107.             if (var6 < 0) {
  108.                this.intVal = this.intVal.multiply(BigInteger.valueOf(5L).pow(-var6));
  109.                this.scale = -var6;
  110.             } else if (var6 > 0) {
  111.                this.intVal = this.intVal.multiply(BigInteger.valueOf(2L).pow(var6));
  112.             }
  113.  
  114.          }
  115.       } else {
  116.          throw new NumberFormatException("Infinite or NaN");
  117.       }
  118.    }
  119.  
  120.    public BigDecimal(BigInteger var1) {
  121.       this.intVal = var1;
  122.    }
  123.  
  124.    public BigDecimal(BigInteger var1, int var2) {
  125.       if (var2 < 0) {
  126.          throw new NumberFormatException("Negative scale");
  127.       } else {
  128.          this.intVal = var1;
  129.          this.scale = var2;
  130.       }
  131.    }
  132.  
  133.    public static BigDecimal valueOf(long var0, int var2) {
  134.       return new BigDecimal(BigInteger.valueOf(var0), var2);
  135.    }
  136.  
  137.    public static BigDecimal valueOf(long var0) {
  138.       return valueOf(var0, 0);
  139.    }
  140.  
  141.    public BigDecimal add(BigDecimal var1) {
  142.       BigDecimal[] var2 = new BigDecimal[]{this, var1};
  143.       matchScale(var2);
  144.       return new BigDecimal(var2[0].intVal.add(var2[1].intVal), var2[0].scale);
  145.    }
  146.  
  147.    public BigDecimal subtract(BigDecimal var1) {
  148.       BigDecimal[] var2 = new BigDecimal[]{this, var1};
  149.       matchScale(var2);
  150.       return new BigDecimal(var2[0].intVal.subtract(var2[1].intVal), var2[0].scale);
  151.    }
  152.  
  153.    public BigDecimal multiply(BigDecimal var1) {
  154.       return new BigDecimal(this.intVal.multiply(var1.intVal), this.scale + var1.scale);
  155.    }
  156.  
  157.    public BigDecimal divide(BigDecimal var1, int var2, int var3) {
  158.       if (var2 < 0) {
  159.          throw new ArithmeticException("Negative scale");
  160.       } else if (var3 >= 0 && var3 <= 7) {
  161.          BigDecimal var4;
  162.          BigDecimal var5;
  163.          if (var2 + var1.scale >= this.scale) {
  164.             var4 = this.setScale(var2 + var1.scale);
  165.             var5 = var1;
  166.          } else {
  167.             var4 = this;
  168.             var5 = var1.setScale(this.scale - var2);
  169.          }
  170.  
  171.          BigInteger[] var6 = var4.intVal.divideAndRemainder(var5.intVal);
  172.          BigInteger var7 = var6[0];
  173.          BigInteger var8 = var6[1];
  174.          if (var8.signum() == 0) {
  175.             return new BigDecimal(var7, var2);
  176.          } else if (var3 == 7) {
  177.             throw new ArithmeticException("Rounding necessary");
  178.          } else {
  179.             int var9 = var4.signum() * var5.signum();
  180.             boolean var10;
  181.             if (var3 == 0) {
  182.                var10 = true;
  183.             } else if (var3 == 1) {
  184.                var10 = false;
  185.             } else if (var3 == 2) {
  186.                var10 = var9 > 0;
  187.             } else if (var3 == 3) {
  188.                var10 = var9 < 0;
  189.             } else {
  190.                int var11 = var8.abs().multiply(BigInteger.valueOf(2L)).compareTo(var5.intVal.abs());
  191.                if (var11 < 0) {
  192.                   var10 = false;
  193.                } else if (var11 > 0) {
  194.                   var10 = true;
  195.                } else if (var3 == 4) {
  196.                   var10 = true;
  197.                } else if (var3 == 5) {
  198.                   var10 = false;
  199.                } else {
  200.                   var10 = var7.testBit(0);
  201.                }
  202.             }
  203.  
  204.             return var10 ? new BigDecimal(var7.add(BigInteger.valueOf((long)var9)), var2) : new BigDecimal(var7, var2);
  205.          }
  206.       } else {
  207.          throw new IllegalArgumentException("Invalid rounding mode");
  208.       }
  209.    }
  210.  
  211.    public BigDecimal divide(BigDecimal var1, int var2) {
  212.       return this.divide(var1, this.scale, var2);
  213.    }
  214.  
  215.    public BigDecimal abs() {
  216.       return this.signum() < 0 ? this.negate() : this;
  217.    }
  218.  
  219.    public BigDecimal negate() {
  220.       return new BigDecimal(this.intVal.negate(), this.scale);
  221.    }
  222.  
  223.    public int signum() {
  224.       return this.intVal.signum();
  225.    }
  226.  
  227.    public int scale() {
  228.       return this.scale;
  229.    }
  230.  
  231.    public BigInteger unscaledValue() {
  232.       return this.intVal;
  233.    }
  234.  
  235.    public BigDecimal setScale(int var1, int var2) {
  236.       if (var1 < 0) {
  237.          throw new ArithmeticException("Negative scale");
  238.       } else if (var2 >= 0 && var2 <= 7) {
  239.          if (var1 == this.scale) {
  240.             return this;
  241.          } else {
  242.             return var1 > this.scale ? new BigDecimal(timesTenToThe(this.intVal, var1 - this.scale), var1) : this.divide(valueOf(1L), var1, var2);
  243.          }
  244.       } else {
  245.          throw new IllegalArgumentException("Invalid rounding mode");
  246.       }
  247.    }
  248.  
  249.    public BigDecimal setScale(int var1) {
  250.       return this.setScale(var1, 7);
  251.    }
  252.  
  253.    public BigDecimal movePointLeft(int var1) {
  254.       return var1 >= 0 ? new BigDecimal(this.intVal, this.scale + var1) : this.movePointRight(-var1);
  255.    }
  256.  
  257.    public BigDecimal movePointRight(int var1) {
  258.       return this.scale >= var1 ? new BigDecimal(this.intVal, this.scale - var1) : new BigDecimal(timesTenToThe(this.intVal, var1 - this.scale), 0);
  259.    }
  260.  
  261.    public int compareTo(BigDecimal var1) {
  262.       int var2 = this.signum() - var1.signum();
  263.       if (var2 != 0) {
  264.          return var2 > 0 ? 1 : -1;
  265.       } else {
  266.          BigDecimal[] var3 = new BigDecimal[]{this, var1};
  267.          matchScale(var3);
  268.          return var3[0].intVal.compareTo(var3[1].intVal);
  269.       }
  270.    }
  271.  
  272.    public int compareTo(Object var1) {
  273.       return this.compareTo((BigDecimal)var1);
  274.    }
  275.  
  276.    public boolean equals(Object var1) {
  277.       if (!(var1 instanceof BigDecimal)) {
  278.          return false;
  279.       } else {
  280.          BigDecimal var2 = (BigDecimal)var1;
  281.          return this.scale == var2.scale && this.intVal.equals(var2.intVal);
  282.       }
  283.    }
  284.  
  285.    public BigDecimal min(BigDecimal var1) {
  286.       return this.compareTo(var1) < 0 ? this : var1;
  287.    }
  288.  
  289.    public BigDecimal max(BigDecimal var1) {
  290.       return this.compareTo(var1) > 0 ? this : var1;
  291.    }
  292.  
  293.    public int hashCode() {
  294.       return 31 * this.intVal.hashCode() + this.scale;
  295.    }
  296.  
  297.    public String toString() {
  298.       if (this.scale == 0) {
  299.          return this.intVal.toString();
  300.       } else {
  301.          String var2 = this.intVal.abs().toString();
  302.          int var3 = this.signum();
  303.          int var4 = var2.length() - this.scale;
  304.          if (var4 == 0) {
  305.             return (var3 < 0 ? "-0." : "0.") + var2;
  306.          } else {
  307.             StringBuffer var1;
  308.             if (var4 > 0) {
  309.                var1 = new StringBuffer(var2);
  310.                var1.insert(var4, '.');
  311.                if (var3 < 0) {
  312.                   var1.insert(0, '-');
  313.                }
  314.             } else {
  315.                var1 = new StringBuffer(3 - var4 + var2.length());
  316.                var1.append(var3 < 0 ? "-0." : "0.");
  317.  
  318.                for(int var5 = 0; var5 < -var4; ++var5) {
  319.                   var1.append('0');
  320.                }
  321.  
  322.                var1.append(var2);
  323.             }
  324.  
  325.             return var1.toString();
  326.          }
  327.       }
  328.    }
  329.  
  330.    public BigInteger toBigInteger() {
  331.       return this.scale == 0 ? this.intVal : this.intVal.divide(BigInteger.valueOf(10L).pow(this.scale));
  332.    }
  333.  
  334.    public int intValue() {
  335.       return this.toBigInteger().intValue();
  336.    }
  337.  
  338.    public long longValue() {
  339.       return this.toBigInteger().longValue();
  340.    }
  341.  
  342.    public float floatValue() {
  343.       return Float.valueOf(this.toString());
  344.    }
  345.  
  346.    public double doubleValue() {
  347.       return Double.valueOf(this.toString());
  348.    }
  349.  
  350.    private static BigInteger timesTenToThe(BigInteger var0, int var1) {
  351.       return var0.multiply(BigInteger.valueOf(10L).pow(var1));
  352.    }
  353.  
  354.    private static void matchScale(BigDecimal[] var0) {
  355.       if (var0[0].scale < var0[1].scale) {
  356.          var0[0] = var0[0].setScale(var0[1].scale);
  357.       } else if (var0[1].scale < var0[0].scale) {
  358.          var0[1] = var0[1].setScale(var0[0].scale);
  359.       }
  360.  
  361.    }
  362.  
  363.    private synchronized void readObject(ObjectInputStream var1) throws IOException, ClassNotFoundException {
  364.       var1.defaultReadObject();
  365.       if (this.scale < 0) {
  366.          throw new StreamCorruptedException("BigDecimal: Negative scale");
  367.       }
  368.    }
  369. }
  370.