2000-04-11 11:21:53 +02:00
|
|
|
/* java.math.BigDecimal -- Arbitrary precision decimals.
|
2001-01-10 10:38:08 +01:00
|
|
|
Copyright (C) 1999, 2000, 2001 Free Software Foundation, Inc.
|
2000-04-11 11:21:53 +02:00
|
|
|
|
|
|
|
This file is part of GNU Classpath.
|
|
|
|
|
|
|
|
GNU Classpath is free software; you can redistribute it and/or modify
|
|
|
|
it under the terms of the GNU General Public License as published by
|
|
|
|
the Free Software Foundation; either version 2, or (at your option)
|
|
|
|
any later version.
|
|
|
|
|
|
|
|
GNU Classpath is distributed in the hope that it will be useful, but
|
|
|
|
WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
General Public License for more details.
|
|
|
|
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
|
|
along with GNU Classpath; see the file COPYING. If not, write to the
|
|
|
|
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
|
|
|
|
02111-1307 USA.
|
|
|
|
|
2002-01-22 23:40:42 +01:00
|
|
|
Linking this library statically or dynamically with other modules is
|
|
|
|
making a combined work based on this library. Thus, the terms and
|
|
|
|
conditions of the GNU General Public License cover the whole
|
|
|
|
combination.
|
|
|
|
|
|
|
|
As a special exception, the copyright holders of this library give you
|
|
|
|
permission to link this library with independent modules to produce an
|
|
|
|
executable, regardless of the license terms of these independent
|
|
|
|
modules, and to copy and distribute the resulting executable under
|
|
|
|
terms of your choice, provided that you also meet, for each linked
|
|
|
|
independent module, the terms and conditions of the license of that
|
|
|
|
module. An independent module is a module which is not derived from
|
|
|
|
or based on this library. If you modify this library, you may extend
|
|
|
|
this exception to your version of the library, but you are not
|
|
|
|
obligated to do so. If you do not wish to do so, delete this
|
|
|
|
exception statement from your version. */
|
2000-04-11 11:21:53 +02:00
|
|
|
|
|
|
|
package java.math;
|
|
|
|
|
|
|
|
import java.math.BigInteger;
|
|
|
|
|
2001-11-25 20:32:28 +01:00
|
|
|
public class BigDecimal extends Number implements Comparable
|
|
|
|
{
|
2000-10-27 12:33:46 +02:00
|
|
|
private BigInteger intVal;
|
|
|
|
private int scale;
|
|
|
|
private static final long serialVersionUID = 6108874887143696463L;
|
2000-04-11 11:21:53 +02:00
|
|
|
|
|
|
|
private final static BigDecimal ZERO =
|
|
|
|
new BigDecimal (BigInteger.valueOf (0), 0);
|
|
|
|
|
|
|
|
private final static BigDecimal ONE =
|
|
|
|
new BigDecimal (BigInteger.valueOf (1), 0);
|
|
|
|
|
|
|
|
public final static int ROUND_UP = 0;
|
|
|
|
public final static int ROUND_DOWN = 1;
|
|
|
|
public final static int ROUND_CEILING = 2;
|
|
|
|
public final static int ROUND_FLOOR = 3;
|
|
|
|
public final static int ROUND_HALF_UP = 4;
|
|
|
|
public final static int ROUND_HALF_DOWN = 5;
|
|
|
|
public final static int ROUND_HALF_EVEN = 6;
|
|
|
|
public final static int ROUND_UNNECESSARY = 7;
|
|
|
|
|
|
|
|
public BigDecimal (BigInteger num)
|
|
|
|
{
|
|
|
|
this (num, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
public BigDecimal (BigInteger num, int scale) throws NumberFormatException
|
|
|
|
{
|
|
|
|
if (scale < 0)
|
|
|
|
throw new NumberFormatException ("scale of " + scale + " is < 0");
|
2000-10-27 12:33:46 +02:00
|
|
|
this.intVal = num;
|
2000-04-11 11:21:53 +02:00
|
|
|
this.scale = scale;
|
|
|
|
}
|
|
|
|
|
|
|
|
public BigDecimal (double num) throws NumberFormatException
|
|
|
|
{
|
2001-11-25 20:32:28 +01:00
|
|
|
if (Double.isInfinite (num) || Double.isNaN (num))
|
|
|
|
throw new NumberFormatException ("invalid argument: " + num);
|
|
|
|
// Note we can't convert NUM to a String and then use the
|
|
|
|
// String-based constructor. The BigDecimal documentation makes
|
|
|
|
// it clear that the two constructors work differently.
|
|
|
|
|
|
|
|
final int mantissaBits = 52;
|
|
|
|
final int exponentBits = 11;
|
|
|
|
final long mantMask = (1L << mantissaBits) - 1;
|
|
|
|
final long expMask = (1L << exponentBits) - 1;
|
|
|
|
|
|
|
|
long bits = Double.doubleToLongBits (num);
|
|
|
|
long mantissa = bits & mantMask;
|
|
|
|
long exponent = (bits >>> mantissaBits) & expMask;
|
|
|
|
boolean denormal = exponent == 0;
|
|
|
|
// Correct the exponent for the bias.
|
|
|
|
exponent -= denormal ? 1022 : 1023;
|
|
|
|
// Now correct the exponent to account for the bits to the right
|
|
|
|
// of the decimal.
|
|
|
|
exponent -= mantissaBits;
|
|
|
|
// Ordinary numbers have an implied leading `1' bit.
|
|
|
|
if (! denormal)
|
|
|
|
mantissa |= (1L << mantissaBits);
|
|
|
|
|
|
|
|
// Shave off factors of 10.
|
|
|
|
while (exponent < 0 && (mantissa & 1) == 0)
|
|
|
|
{
|
|
|
|
++exponent;
|
|
|
|
mantissa >>= 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
intVal = BigInteger.valueOf (bits < 0 ? - mantissa : mantissa);
|
|
|
|
if (exponent < 0)
|
|
|
|
{
|
|
|
|
// We have MANTISSA * 2 ^ (EXPONENT).
|
|
|
|
// Since (1/2)^N == 5^N * 10^-N we can easily convert this
|
|
|
|
// into a power of 10.
|
|
|
|
scale = (int) (- exponent);
|
|
|
|
BigInteger mult = BigInteger.valueOf (5).pow (scale);
|
|
|
|
intVal = intVal.multiply (mult);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
intVal = intVal.shiftLeft ((int) exponent);
|
|
|
|
scale = 0;
|
|
|
|
}
|
2000-04-11 11:21:53 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
public BigDecimal (String num) throws NumberFormatException
|
|
|
|
{
|
2001-11-25 20:32:28 +01:00
|
|
|
int len = num.length();
|
|
|
|
int start = 0, point = 0;
|
|
|
|
int dot = -1;
|
|
|
|
boolean negative = false;
|
|
|
|
if (num.charAt(0) == '+')
|
|
|
|
{
|
|
|
|
++start;
|
|
|
|
++point;
|
|
|
|
}
|
|
|
|
else if (num.charAt(0) == '-')
|
|
|
|
{
|
|
|
|
++start;
|
|
|
|
++point;
|
|
|
|
negative = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
while (point < len)
|
|
|
|
{
|
|
|
|
char c = num.charAt (point);
|
|
|
|
if (c == '.')
|
|
|
|
{
|
|
|
|
if (dot >= 0)
|
|
|
|
throw new NumberFormatException ("multiple `.'s in number");
|
|
|
|
dot = point;
|
|
|
|
}
|
|
|
|
else if (c == 'e' || c == 'E')
|
|
|
|
break;
|
|
|
|
else if (Character.digit (c, 10) < 0)
|
|
|
|
throw new NumberFormatException ("unrecognized character: " + c);
|
|
|
|
++point;
|
|
|
|
}
|
|
|
|
|
|
|
|
String val;
|
|
|
|
if (dot >= 0)
|
|
|
|
{
|
|
|
|
val = num.substring (start, dot) + num.substring (dot + 1, point);
|
|
|
|
scale = point - 1 - dot;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
val = num.substring (start, point);
|
|
|
|
scale = 0;
|
|
|
|
}
|
|
|
|
if (val.length () == 0)
|
|
|
|
throw new NumberFormatException ("no digits seen");
|
|
|
|
|
|
|
|
if (negative)
|
|
|
|
val = "-" + val;
|
|
|
|
intVal = new BigInteger (val);
|
|
|
|
|
|
|
|
// Now parse exponent.
|
|
|
|
if (point < len)
|
|
|
|
{
|
2003-02-07 22:05:12 +01:00
|
|
|
point++;
|
|
|
|
if (num.charAt(point) == '+')
|
|
|
|
point++;
|
|
|
|
|
|
|
|
if (point >= len )
|
|
|
|
throw new NumberFormatException ("no exponent following e or E");
|
|
|
|
|
|
|
|
try
|
2001-11-25 20:32:28 +01:00
|
|
|
{
|
2003-02-07 22:05:12 +01:00
|
|
|
int exp = Integer.parseInt (num.substring (point));
|
|
|
|
exp -= scale;
|
2003-02-14 19:48:50 +01:00
|
|
|
if (signum () == 0)
|
|
|
|
scale = 0;
|
|
|
|
else if (exp > 0)
|
2003-02-07 22:05:12 +01:00
|
|
|
{
|
|
|
|
intVal = intVal.multiply (BigInteger.valueOf (10).pow (exp));
|
|
|
|
scale = 0;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
scale = - exp;
|
|
|
|
}
|
|
|
|
catch (NumberFormatException ex)
|
|
|
|
{
|
|
|
|
throw new NumberFormatException ("malformed exponent");
|
2001-11-25 20:32:28 +01:00
|
|
|
}
|
|
|
|
}
|
2000-04-11 11:21:53 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
public static BigDecimal valueOf (long val)
|
|
|
|
{
|
|
|
|
return valueOf (val, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
public static BigDecimal valueOf (long val, int scale)
|
|
|
|
throws NumberFormatException
|
|
|
|
{
|
2003-02-07 22:05:12 +01:00
|
|
|
if ((scale == 0) && ((int)val == val))
|
2000-04-11 11:21:53 +02:00
|
|
|
switch ((int) val)
|
|
|
|
{
|
|
|
|
case 0:
|
|
|
|
return ZERO;
|
|
|
|
case 1:
|
|
|
|
return ONE;
|
|
|
|
}
|
|
|
|
|
|
|
|
return new BigDecimal (BigInteger.valueOf (val), scale);
|
|
|
|
}
|
|
|
|
|
|
|
|
public BigDecimal add (BigDecimal val)
|
|
|
|
{
|
|
|
|
// For addition, need to line up decimals. Note that the movePointRight
|
|
|
|
// method cannot be used for this as it might return a BigDecimal with
|
|
|
|
// scale == 0 instead of the scale we need.
|
2000-10-27 12:33:46 +02:00
|
|
|
BigInteger op1 = intVal;
|
|
|
|
BigInteger op2 = val.intVal;
|
2000-04-11 11:21:53 +02:00
|
|
|
if (scale < val.scale)
|
|
|
|
op1 = op1.multiply (BigInteger.valueOf (10).pow (val.scale - scale));
|
|
|
|
else if (scale > val.scale)
|
|
|
|
op2 = op2.multiply (BigInteger.valueOf (10).pow (scale - val.scale));
|
|
|
|
|
|
|
|
return new BigDecimal (op1.add (op2), Math.max (scale, val.scale));
|
|
|
|
}
|
|
|
|
|
|
|
|
public BigDecimal subtract (BigDecimal val)
|
|
|
|
{
|
|
|
|
return this.add(val.negate());
|
|
|
|
}
|
|
|
|
|
|
|
|
public BigDecimal multiply (BigDecimal val)
|
|
|
|
{
|
2000-10-27 12:33:46 +02:00
|
|
|
return new BigDecimal (intVal.multiply (val.intVal), scale + val.scale);
|
2000-04-11 11:21:53 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
public BigDecimal divide (BigDecimal val, int roundingMode)
|
|
|
|
throws ArithmeticException, IllegalArgumentException
|
|
|
|
{
|
|
|
|
return divide (val, scale, roundingMode);
|
|
|
|
}
|
|
|
|
|
|
|
|
public BigDecimal divide(BigDecimal val, int newScale, int roundingMode)
|
|
|
|
throws ArithmeticException, IllegalArgumentException
|
|
|
|
{
|
|
|
|
if (roundingMode < 0 || roundingMode > 7)
|
|
|
|
throw
|
|
|
|
new IllegalArgumentException("illegal rounding mode: " + roundingMode);
|
|
|
|
|
2001-01-10 10:38:08 +01:00
|
|
|
if (newScale < 0)
|
|
|
|
throw new ArithmeticException ("scale is negative: " + newScale);
|
2000-04-11 11:21:53 +02:00
|
|
|
|
2000-10-27 12:33:46 +02:00
|
|
|
if (intVal.signum () == 0) // handle special case of 0.0/0.0
|
2003-02-14 19:48:50 +01:00
|
|
|
return newScale == 0 ? ZERO : new BigDecimal (ZERO.intVal, newScale);
|
2000-04-11 11:21:53 +02:00
|
|
|
|
2001-01-10 10:38:08 +01:00
|
|
|
// Ensure that pow gets a non-negative value.
|
|
|
|
int valScale = val.scale;
|
|
|
|
BigInteger valIntVal = val.intVal;
|
|
|
|
int power = newScale + 1 - (scale - val.scale);
|
|
|
|
if (power < 0)
|
|
|
|
{
|
|
|
|
// Effectively increase the scale of val to avoid an
|
2001-01-10 11:26:34 +01:00
|
|
|
// ArithmeticException for a negative power.
|
2001-01-10 10:38:08 +01:00
|
|
|
valIntVal = valIntVal.multiply (BigInteger.valueOf (10).pow (-power));
|
|
|
|
power = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
BigInteger dividend = intVal.multiply (BigInteger.valueOf (10).pow (power));
|
2000-04-11 11:21:53 +02:00
|
|
|
|
2001-01-10 10:38:08 +01:00
|
|
|
BigInteger parts[] = dividend.divideAndRemainder (valIntVal);
|
2000-04-11 11:21:53 +02:00
|
|
|
// System.out.println("int: " + parts[0]);
|
|
|
|
// System.out.println("rem: " + parts[1]);
|
|
|
|
|
|
|
|
int roundDigit = parts[0].mod (BigInteger.valueOf (10)).intValue ();
|
|
|
|
BigInteger unrounded = parts[0].divide (BigInteger.valueOf (10));
|
|
|
|
|
|
|
|
if (roundDigit == 0 && parts[1].signum () == 0) // no rounding necessary
|
|
|
|
return new BigDecimal (unrounded, newScale);
|
|
|
|
|
|
|
|
int sign = unrounded.signum ();
|
|
|
|
|
|
|
|
switch (roundingMode)
|
|
|
|
{
|
|
|
|
case ROUND_UNNECESSARY:
|
|
|
|
throw new ArithmeticException ("newScale is not large enough");
|
|
|
|
case ROUND_CEILING:
|
|
|
|
roundingMode = (sign == 1) ? ROUND_UP : ROUND_DOWN;
|
|
|
|
break;
|
|
|
|
case ROUND_FLOOR:
|
|
|
|
roundingMode = (sign == 1) ? ROUND_DOWN : ROUND_UP;
|
|
|
|
break;
|
|
|
|
case ROUND_HALF_UP:
|
|
|
|
roundingMode = (roundDigit >= 5) ? ROUND_UP : ROUND_DOWN;
|
|
|
|
break;
|
|
|
|
case ROUND_HALF_DOWN:
|
|
|
|
roundingMode = (roundDigit > 5) ? ROUND_UP : ROUND_DOWN;
|
|
|
|
break;
|
|
|
|
case ROUND_HALF_EVEN:
|
|
|
|
if (roundDigit < 5)
|
|
|
|
roundingMode = ROUND_DOWN;
|
|
|
|
else
|
|
|
|
{
|
|
|
|
int rightmost =
|
|
|
|
unrounded.mod (BigInteger.valueOf (10)).intValue ();
|
|
|
|
if (rightmost % 2 == 1) // odd, then ROUND_HALF_UP
|
|
|
|
roundingMode = ROUND_UP;
|
|
|
|
else // even, then ROUND_HALF_DOWN
|
|
|
|
roundingMode = (roundDigit > 5) ? ROUND_UP : ROUND_DOWN;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (roundingMode == ROUND_UP)
|
|
|
|
return new BigDecimal (unrounded.add (BigInteger.valueOf (1)), newScale);
|
|
|
|
|
|
|
|
// roundingMode == ROUND_DOWN
|
|
|
|
return new BigDecimal (unrounded, newScale);
|
|
|
|
}
|
|
|
|
|
|
|
|
public int compareTo (BigDecimal val)
|
|
|
|
{
|
|
|
|
if (scale == val.scale)
|
2000-10-27 12:33:46 +02:00
|
|
|
return intVal.compareTo (val.intVal);
|
2000-04-11 11:21:53 +02:00
|
|
|
|
|
|
|
BigInteger thisParts[] =
|
2000-10-27 12:33:46 +02:00
|
|
|
intVal.divideAndRemainder (BigInteger.valueOf (10).pow (scale));
|
2000-04-11 11:21:53 +02:00
|
|
|
BigInteger valParts[] =
|
2000-10-27 12:33:46 +02:00
|
|
|
val.intVal.divideAndRemainder (BigInteger.valueOf (10).pow (val.scale));
|
2000-04-11 11:21:53 +02:00
|
|
|
|
|
|
|
int compare;
|
|
|
|
if ((compare = thisParts[0].compareTo (valParts[0])) != 0)
|
|
|
|
return compare;
|
|
|
|
|
|
|
|
// quotients are the same, so compare remainders
|
|
|
|
|
|
|
|
// remove trailing zeros
|
|
|
|
if (thisParts[1].equals (BigInteger.valueOf (0)) == false)
|
|
|
|
while (thisParts[1].mod (BigInteger.valueOf (10)).equals
|
|
|
|
(BigInteger.valueOf (0)))
|
|
|
|
thisParts[1] = thisParts[1].divide (BigInteger.valueOf (10));
|
|
|
|
// again...
|
|
|
|
if (valParts[1].equals(BigInteger.valueOf (0)) == false)
|
|
|
|
while (valParts[1].mod (BigInteger.valueOf (10)).equals
|
|
|
|
(BigInteger.valueOf (0)))
|
|
|
|
valParts[1] = valParts[1].divide (BigInteger.valueOf (10));
|
|
|
|
|
|
|
|
// and compare them
|
|
|
|
return thisParts[1].compareTo (valParts[1]);
|
|
|
|
}
|
|
|
|
|
|
|
|
public int compareTo (Object val)
|
|
|
|
{
|
|
|
|
return(compareTo((BigDecimal)val));
|
|
|
|
}
|
|
|
|
|
|
|
|
public boolean equals (Object o)
|
|
|
|
{
|
|
|
|
return (o instanceof BigDecimal
|
|
|
|
&& scale == ((BigDecimal) o).scale
|
|
|
|
&& compareTo ((BigDecimal) o) == 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
public int hashCode()
|
|
|
|
{
|
|
|
|
return intValue() ^ scale;
|
|
|
|
}
|
|
|
|
|
|
|
|
public BigDecimal max (BigDecimal val)
|
|
|
|
{
|
|
|
|
switch (compareTo (val))
|
|
|
|
{
|
|
|
|
case 1:
|
|
|
|
return this;
|
|
|
|
default:
|
|
|
|
return val;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
public BigDecimal min (BigDecimal val)
|
|
|
|
{
|
|
|
|
switch (compareTo (val))
|
|
|
|
{
|
|
|
|
case -1:
|
|
|
|
return this;
|
|
|
|
default:
|
|
|
|
return val;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
public BigDecimal movePointLeft (int n)
|
|
|
|
{
|
2000-10-27 12:33:46 +02:00
|
|
|
return (n < 0) ? movePointRight (-n) : new BigDecimal (intVal, scale + n);
|
2000-04-11 11:21:53 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
public BigDecimal movePointRight (int n)
|
|
|
|
{
|
|
|
|
if (n < 0)
|
|
|
|
return movePointLeft (-n);
|
|
|
|
|
|
|
|
if (scale >= n)
|
2000-10-27 12:33:46 +02:00
|
|
|
return new BigDecimal (intVal, scale - n);
|
2000-04-11 11:21:53 +02:00
|
|
|
|
2000-10-27 12:33:46 +02:00
|
|
|
return new BigDecimal (intVal.multiply
|
2000-04-11 11:21:53 +02:00
|
|
|
(BigInteger.valueOf (10).pow (n - scale)), 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
public int signum ()
|
|
|
|
{
|
2000-10-27 12:33:46 +02:00
|
|
|
return intVal.signum ();
|
2000-04-11 11:21:53 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
public int scale ()
|
|
|
|
{
|
|
|
|
return scale;
|
|
|
|
}
|
|
|
|
|
2003-04-19 21:26:41 +02:00
|
|
|
public BigInteger unscaledValue()
|
|
|
|
{
|
|
|
|
return intVal;
|
|
|
|
}
|
|
|
|
|
2000-04-11 11:21:53 +02:00
|
|
|
public BigDecimal abs ()
|
|
|
|
{
|
2000-10-27 12:33:46 +02:00
|
|
|
return new BigDecimal (intVal.abs (), scale);
|
2000-04-11 11:21:53 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
public BigDecimal negate ()
|
|
|
|
{
|
2000-10-27 12:33:46 +02:00
|
|
|
return new BigDecimal (intVal.negate (), scale);
|
2000-04-11 11:21:53 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
public String toString ()
|
|
|
|
{
|
2000-10-27 12:33:46 +02:00
|
|
|
String bigStr = intVal.toString();
|
2000-04-11 11:21:53 +02:00
|
|
|
if (scale == 0)
|
|
|
|
return bigStr;
|
|
|
|
|
|
|
|
boolean negative = (bigStr.charAt(0) == '-');
|
2003-02-07 22:05:12 +01:00
|
|
|
|
|
|
|
int point = bigStr.length() - scale - (negative ? 1 : 0);
|
|
|
|
|
|
|
|
StringBuffer sb = new StringBuffer(bigStr.length() + 2 +
|
|
|
|
(point <= 0 ? (-point + 1) : 0));
|
|
|
|
if (point <= 0)
|
|
|
|
{
|
|
|
|
if (negative)
|
|
|
|
sb.append('-');
|
|
|
|
sb.append('0').append('.');
|
|
|
|
while (point < 0)
|
|
|
|
{
|
|
|
|
sb.append('0');
|
|
|
|
point++;
|
|
|
|
}
|
|
|
|
sb.append(bigStr.substring(negative ? 1 : 0));
|
|
|
|
}
|
|
|
|
else
|
2000-04-11 11:21:53 +02:00
|
|
|
{
|
2003-02-07 22:05:12 +01:00
|
|
|
sb.append(bigStr);
|
|
|
|
sb.insert(point + (negative ? 1 : 0), '.');
|
2000-04-11 11:21:53 +02:00
|
|
|
}
|
|
|
|
return sb.toString();
|
|
|
|
}
|
|
|
|
|
|
|
|
public BigInteger toBigInteger ()
|
|
|
|
{
|
2000-10-27 12:33:46 +02:00
|
|
|
return scale == 0 ? intVal :
|
|
|
|
intVal.divide (BigInteger.valueOf (10).pow (scale));
|
2000-04-11 11:21:53 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
public int intValue ()
|
|
|
|
{
|
|
|
|
return toBigInteger ().intValue ();
|
|
|
|
}
|
|
|
|
|
|
|
|
public long longValue ()
|
|
|
|
{
|
|
|
|
return toBigInteger().longValue();
|
|
|
|
}
|
|
|
|
|
|
|
|
public float floatValue()
|
|
|
|
{
|
|
|
|
return Float.valueOf(toString()).floatValue();
|
|
|
|
}
|
|
|
|
|
|
|
|
public double doubleValue()
|
|
|
|
{
|
|
|
|
return Double.valueOf(toString()).doubleValue();
|
|
|
|
}
|
2001-01-10 10:38:08 +01:00
|
|
|
|
|
|
|
public BigDecimal setScale (int scale) throws ArithmeticException
|
|
|
|
{
|
|
|
|
return setScale (scale, ROUND_UNNECESSARY);
|
|
|
|
}
|
|
|
|
|
|
|
|
public BigDecimal setScale (int scale, int roundingMode)
|
|
|
|
throws ArithmeticException, IllegalArgumentException
|
|
|
|
{
|
|
|
|
return divide (ONE, scale, roundingMode);
|
|
|
|
}
|
2000-04-11 11:21:53 +02:00
|
|
|
}
|