home *** CD-ROM | disk | FTP | other *** search
/ Symantec Visual Cafe for Java 2.5 / symantec-visual-cafe-2.5-database-dev-edition.iso / Visual Cafe Pro v1.0 / VISCAFE.BIN / SQL.ZIP / symjava / math / BigDecimal.class (.txt) next >
Encoding:
Java Class File  |  1997-06-11  |  5.5 KB  |  322 lines
  1. package symjava.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.             int var7 = this.scale;
  39.             this.intVal = var6.multiply(BigInteger.valueOf(10L).pow(var7)).add(var4);
  40.          }
  41.       }
  42.    }
  43.  
  44.    public BigDecimal(double var1) throws NumberFormatException {
  45.       if (!Double.isInfinite(var1) && !Double.isNaN(var1)) {
  46.          long var3 = Double.doubleToLongBits(var1);
  47.          int var5 = var3 >> 63 == 0L ? 1 : -1;
  48.          int var6 = (int)(var3 >> 52 & 2047L);
  49.          long var7 = var6 == 0 ? (var3 & 4503599627370495L) << 1 : var3 & 4503599627370495L | 4503599627370496L;
  50.          var6 -= 1075;
  51.          if (var7 != 0L) {
  52.             while((var7 & 1L) == 0L) {
  53.                var7 >>= 1;
  54.                ++var6;
  55.             }
  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.       } else {
  69.          throw new NumberFormatException("Infinite or NaN");
  70.       }
  71.    }
  72.  
  73.    public BigDecimal(BigInteger var1) {
  74.       this.intVal = var1;
  75.    }
  76.  
  77.    public BigDecimal(BigInteger var1, int var2) throws NumberFormatException {
  78.       if (var2 < 0) {
  79.          throw new NumberFormatException("Negative scale");
  80.       } else {
  81.          this.intVal = var1;
  82.          this.scale = var2;
  83.       }
  84.    }
  85.  
  86.    public static BigDecimal valueOf(long var0, int var2) throws NumberFormatException {
  87.       return new BigDecimal(BigInteger.valueOf(var0), var2);
  88.    }
  89.  
  90.    public static BigDecimal valueOf(long var0) {
  91.       return new BigDecimal(BigInteger.valueOf(var0), 0);
  92.    }
  93.  
  94.    public BigDecimal add(BigDecimal var1) {
  95.       BigDecimal[] var2 = new BigDecimal[]{this, var1};
  96.       matchScale(var2);
  97.       return new BigDecimal(var2[0].intVal.add(var2[1].intVal), var2[0].scale);
  98.    }
  99.  
  100.    public BigDecimal subtract(BigDecimal var1) {
  101.       BigDecimal[] var2 = new BigDecimal[]{this, var1};
  102.       matchScale(var2);
  103.       return new BigDecimal(var2[0].intVal.subtract(var2[1].intVal), var2[0].scale);
  104.    }
  105.  
  106.    public BigDecimal multiply(BigDecimal var1) {
  107.       return new BigDecimal(this.intVal.multiply(var1.intVal), this.scale + var1.scale);
  108.    }
  109.  
  110.    public BigDecimal divide(BigDecimal var1, int var2, int var3) throws ArithmeticException, IllegalArgumentException {
  111.       if (var2 < 0) {
  112.          throw new NumberFormatException("Negative scale");
  113.       } else if (var3 >= 0 && var3 <= 7) {
  114.          BigDecimal var4;
  115.          BigDecimal var5;
  116.          if (var2 + var1.scale >= this.scale) {
  117.             var4 = this.setScale(var2 + var1.scale);
  118.             var5 = var1;
  119.          } else {
  120.             var4 = this;
  121.             var5 = var1.setScale(this.scale - var2);
  122.          }
  123.  
  124.          BigInteger[] var6 = var4.intVal.divideAndRemainder(var5.intVal);
  125.          BigInteger var7 = var6[0];
  126.          BigInteger var8 = var6[1];
  127.          if (var8.signum() == 0) {
  128.             return new BigDecimal(var7, var2);
  129.          } else if (var3 == 7) {
  130.             throw new ArithmeticException("Rounding necessary");
  131.          } else {
  132.             int var9 = var4.signum() * var5.signum();
  133.             boolean var10;
  134.             if (var3 == 0) {
  135.                var10 = true;
  136.             } else if (var3 == 1) {
  137.                var10 = false;
  138.             } else if (var3 == 2) {
  139.                var10 = var9 > 0;
  140.             } else if (var3 == 3) {
  141.                var10 = var9 < 0;
  142.             } else {
  143.                int var11 = var8.abs().multiply(BigInteger.valueOf(2L)).compareTo(var5.intVal.abs());
  144.                if (var11 < 0) {
  145.                   var10 = false;
  146.                } else if (var11 > 0) {
  147.                   var10 = true;
  148.                } else if (var3 == 4) {
  149.                   var10 = true;
  150.                } else if (var3 == 5) {
  151.                   var10 = false;
  152.                } else {
  153.                   var10 = var7.testBit(0);
  154.                }
  155.             }
  156.  
  157.             return var10 ? new BigDecimal(var7.add(BigInteger.valueOf((long)var9)), var2) : new BigDecimal(var7, var2);
  158.          }
  159.       } else {
  160.          throw new IllegalArgumentException("Invalid rounding mode");
  161.       }
  162.    }
  163.  
  164.    public BigDecimal divide(BigDecimal var1, int var2) throws ArithmeticException, IllegalArgumentException {
  165.       return this.divide(var1, this.scale, var2);
  166.    }
  167.  
  168.    public BigDecimal abs() {
  169.       return this.signum() < 0 ? this.negate() : this;
  170.    }
  171.  
  172.    public BigDecimal negate() {
  173.       return new BigDecimal(this.intVal.negate(), this.scale);
  174.    }
  175.  
  176.    public int signum() {
  177.       return this.intVal.signum();
  178.    }
  179.  
  180.    public int scale() {
  181.       return this.scale;
  182.    }
  183.  
  184.    public BigDecimal setScale(int var1, int var2) throws ArithmeticException, IllegalArgumentException {
  185.       if (var1 < 0) {
  186.          throw new NumberFormatException("Negative scale");
  187.       } else if (var1 == this.scale) {
  188.          return this;
  189.       } else if (var1 > this.scale) {
  190.          BigInteger var3 = this.intVal;
  191.          int var4 = var1 - this.scale;
  192.          return new BigDecimal(var3.multiply(BigInteger.valueOf(10L).pow(var4)), var1);
  193.       } else {
  194.          return this.divide(new BigDecimal(BigInteger.valueOf(1L), 0), var1, var2);
  195.       }
  196.    }
  197.  
  198.    public BigDecimal setScale(int var1) throws ArithmeticException, IllegalArgumentException {
  199.       return this.setScale(var1, 7);
  200.    }
  201.  
  202.    public BigDecimal movePointLeft(int var1) {
  203.       return var1 >= 0 ? new BigDecimal(this.intVal, this.scale + var1) : this.movePointRight(-var1);
  204.    }
  205.  
  206.    public BigDecimal movePointRight(int var1) {
  207.       if (this.scale >= var1) {
  208.          return new BigDecimal(this.intVal, this.scale - var1);
  209.       } else {
  210.          BigInteger var2 = this.intVal;
  211.          int var3 = var1 - this.scale;
  212.          return new BigDecimal(var2.multiply(BigInteger.valueOf(10L).pow(var3)), 0);
  213.       }
  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 checkScale(int var0) throws NumberFormatException {
  306.       if (var0 < 0) {
  307.          throw new NumberFormatException("Negative scale");
  308.       }
  309.    }
  310.  
  311.    private static void matchScale(BigDecimal[] var0) {
  312.       if (var0[0].scale < var0[1].scale) {
  313.          var0[0] = var0[0].setScale(var0[1].scale);
  314.       } else {
  315.          if (var0[1].scale < var0[0].scale) {
  316.             var0[1] = var0[1].setScale(var0[0].scale);
  317.          }
  318.  
  319.       }
  320.    }
  321. }
  322.