| Method from java.math.BigDecimal Detail: |
|---|
 public BigDecimal abs() {
return ((signum() < 0) ? negate() : this);
}
Returns a new {@code BigDecimal} whose value is the absolute value of
{@code this}. The scale of the result is the same as the scale of this. |
public BigDecimal abs(MathContext mc) {
return round(mc).abs();
} Returns a new {@code BigDecimal} whose value is the absolute value of
{@code this}. The result is rounded according to the passed context
{@code mc}. |
public BigDecimal add(BigDecimal augend) {
int diffScale = this.scale - augend.scale;
// Fast return when some operand is zero
if (this.isZero()) {
if (diffScale < = 0) {
return augend;
}
if (augend.isZero()) {
return this;
}
} else if (augend.isZero()) {
if (diffScale >= 0) {
return this;
}
}
// Let be: this = [u1,s1] and augend = [u2,s2]
if (diffScale == 0) {
// case s1 == s2: [u1 + u2 , s1]
if (Math.max(this.bitLength, augend.bitLength) + 1 < 64) {
return valueOf(this.smallValue + augend.smallValue, this.scale);
}
return new BigDecimal(this.getUnscaledValue().add(augend.getUnscaledValue()), this.scale);
} else if (diffScale > 0) {
// case s1 > s2 : [(u1 + u2) * 10 ^ (s1 - s2) , s1]
return addAndMult10(this, augend, diffScale);
} else {// case s2 > s1 : [(u2 + u1) * 10 ^ (s2 - s1) , s2]
return addAndMult10(augend, this, -diffScale);
}
} Returns a new {@code BigDecimal} whose value is {@code this + augend}.
The scale of the result is the maximum of the scales of the two
arguments. |
public BigDecimal add(BigDecimal augend,
MathContext mc) {
BigDecimal larger; // operand with the largest unscaled value
BigDecimal smaller; // operand with the smallest unscaled value
BigInteger tempBI;
long diffScale = (long)this.scale - augend.scale;
int largerSignum;
// Some operand is zero or the precision is infinity
if ((augend.isZero()) || (this.isZero())
|| (mc.getPrecision() == 0)) {
return add(augend).round(mc);
}
// Cases where there is room for optimizations
if (this.aproxPrecision() < diffScale - 1) {
larger = augend;
smaller = this;
} else if (augend.aproxPrecision() < -diffScale - 1) {
larger = this;
smaller = augend;
} else {// No optimization is done
return add(augend).round(mc);
}
if (mc.getPrecision() >= larger.aproxPrecision()) {
// No optimization is done
return add(augend).round(mc);
}
// Cases where it's unnecessary to add two numbers with very different scales
largerSignum = larger.signum();
if (largerSignum == smaller.signum()) {
tempBI = Multiplication.multiplyByPositiveInt(larger.getUnscaledValue(),10)
.add(BigInteger.valueOf(largerSignum));
} else {
tempBI = larger.getUnscaledValue().subtract(
BigInteger.valueOf(largerSignum));
tempBI = Multiplication.multiplyByPositiveInt(tempBI,10)
.add(BigInteger.valueOf(largerSignum * 9));
}
// Rounding the improved adding
larger = new BigDecimal(tempBI, larger.scale + 1);
return larger.round(mc);
} Returns a new {@code BigDecimal} whose value is {@code this + augend}.
The result is rounded according to the passed context {@code mc}. |
public byte byteValueExact() {
return (byte)valueExact(8);
} Returns this {@code BigDecimal} as a byte value if it has no fractional
part and if its value fits to the byte range ([-128..127]). If these
conditions are not met, an {@code ArithmeticException} is thrown. |
public int compareTo(BigDecimal val) {
int thisSign = signum();
int valueSign = val.signum();
if( thisSign == valueSign) {
if(this.scale == val.scale && this.bitLength< 64 && val.bitLength< 64 ) {
return (smallValue < val.smallValue) ? -1 : (smallValue > val.smallValue) ? 1 : 0;
}
long diffScale = (long)this.scale - val.scale;
int diffPrecision = this.aproxPrecision() - val.aproxPrecision();
if (diffPrecision > diffScale + 1) {
return thisSign;
} else if (diffPrecision < diffScale - 1) {
return -thisSign;
} else {// thisSign == val.signum() and diffPrecision is aprox. diffScale
BigInteger thisUnscaled = this.getUnscaledValue();
BigInteger valUnscaled = val.getUnscaledValue();
// If any of both precision is bigger, append zeros to the shorter one
if (diffScale < 0) {
thisUnscaled = thisUnscaled.multiply(Multiplication.powerOf10(-diffScale));
} else if (diffScale > 0) {
valUnscaled = valUnscaled.multiply(Multiplication.powerOf10(diffScale));
}
return thisUnscaled.compareTo(valUnscaled);
}
} else if (thisSign < valueSign) {
return -1;
} else {
return 1;
}
} Compares this {@code BigDecimal} with {@code val}. Returns one of the
three values {@code 1}, {@code 0}, or {@code -1}. The method behaves as
if {@code this.subtract(val)} is computed. If this difference is > 0 then
1 is returned, if the difference is < 0 then -1 is returned, and if the
difference is 0 then 0 is returned. This means, that if two decimal
instances are compared which are equal in value but differ in scale, then
these two instances are considered as equal. |
public BigDecimal divide(BigDecimal divisor) {
BigInteger p = this.getUnscaledValue();
BigInteger q = divisor.getUnscaledValue();
BigInteger gcd; // greatest common divisor between 'p' and 'q'
BigInteger quotAndRem[];
long diffScale = (long)scale - divisor.scale;
int newScale; // the new scale for final quotient
int k; // number of factors "2" in 'q'
int l = 0; // number of factors "5" in 'q'
int i = 1;
int lastPow = FIVE_POW.length - 1;
if (divisor.isZero()) {
// math.04=Division by zero
throw new ArithmeticException(Messages.getString("math.04")); //$NON-NLS-1$
}
if (p.signum() == 0) {
return zeroScaledBy(diffScale);
}
// To divide both by the GCD
gcd = p.gcd(q);
p = p.divide(gcd);
q = q.divide(gcd);
// To simplify all "2" factors of q, dividing by 2^k
k = q.getLowestSetBit();
q = q.shiftRight(k);
// To simplify all "5" factors of q, dividing by 5^l
do {
quotAndRem = q.divideAndRemainder(FIVE_POW[i]);
if (quotAndRem[1].signum() == 0) {
l += i;
if (i < lastPow) {
i++;
}
q = quotAndRem[0];
} else {
if (i == 1) {
break;
}
i = 1;
}
} while (true);
// If abs(q) != 1 then the quotient is periodic
if (!q.abs().equals(BigInteger.ONE)) {
// math.05=Non-terminating decimal expansion; no exact representable decimal result.
throw new ArithmeticException(Messages.getString("math.05")); //$NON-NLS-1$
}
// The sign of the is fixed and the quotient will be saved in 'p'
if (q.signum() < 0) {
p = p.negate();
}
// Checking if the new scale is out of range
newScale = toIntScale(diffScale + Math.max(k, l));
// k >= 0 and l >= 0 implies that k - l is in the 32-bit range
i = k - l;
p = (i > 0) ? Multiplication.multiplyByFivePow(p, i)
: p.shiftLeft(-i);
return new BigDecimal(p, newScale);
} Returns a new {@code BigDecimal} whose value is {@code this / divisor}.
The scale of the result is the difference of the scales of {@code this}
and {@code divisor}. If the exact result requires more digits, then the
scale is adjusted accordingly. For example, {@code 1/128 = 0.0078125}
which has a scale of {@code 7} and precision {@code 5}. |
public BigDecimal divide(BigDecimal divisor,
int roundingMode) {
return divide(divisor, scale, RoundingMode.valueOf(roundingMode));
} Returns a new {@code BigDecimal} whose value is {@code this / divisor}.
The scale of the result is the scale of {@code this}. If rounding is
required to meet the specified scale, then the specified rounding mode
{@code roundingMode} is applied. |
public BigDecimal divide(BigDecimal divisor,
RoundingMode roundingMode) {
return divide(divisor, scale, roundingMode);
} Returns a new {@code BigDecimal} whose value is {@code this / divisor}.
The scale of the result is the scale of {@code this}. If rounding is
required to meet the specified scale, then the specified rounding mode
{@code roundingMode} is applied. |
public BigDecimal divide(BigDecimal divisor,
MathContext mc) {
/* Calculating how many zeros must be append to 'dividend'
* to obtain a quotient with at least 'mc.precision()' digits */
long traillingZeros = mc.getPrecision() + 2L
+ divisor.aproxPrecision() - aproxPrecision();
long diffScale = (long)scale - divisor.scale;
long newScale = diffScale; // scale of the final quotient
int compRem; // to compare the remainder
int i = 1; // index
int lastPow = TEN_POW.length - 1; // last power of ten
BigInteger integerQuot; // for temporal results
BigInteger quotAndRem[] = {getUnscaledValue()};
// In special cases it reduces the problem to call the dual method
if ((mc.getPrecision() == 0) || (this.isZero())
|| (divisor.isZero())) {
return this.divide(divisor);
}
if (traillingZeros > 0) {
// To append trailing zeros at end of dividend
quotAndRem[0] = getUnscaledValue().multiply( Multiplication.powerOf10(traillingZeros) );
newScale += traillingZeros;
}
quotAndRem = quotAndRem[0].divideAndRemainder( divisor.getUnscaledValue() );
integerQuot = quotAndRem[0];
// Calculating the exact quotient with at least 'mc.precision()' digits
if (quotAndRem[1].signum() != 0) {
// Checking if: 2 * remainder >= divisor ?
compRem = quotAndRem[1].shiftLeftOneBit().compareTo( divisor.getUnscaledValue() );
// quot := quot * 10 + r; with 'r' in {-6,-5,-4, 0,+4,+5,+6}
integerQuot = integerQuot.multiply(BigInteger.TEN)
.add(BigInteger.valueOf(quotAndRem[0].signum() * (5 + compRem)));
newScale++;
} else {
// To strip trailing zeros until the preferred scale is reached
while (!integerQuot.testBit(0)) {
quotAndRem = integerQuot.divideAndRemainder(TEN_POW[i]);
if ((quotAndRem[1].signum() == 0)
&& (newScale - i >= diffScale)) {
newScale -= i;
if (i < lastPow) {
i++;
}
integerQuot = quotAndRem[0];
} else {
if (i == 1) {
break;
}
i = 1;
}
}
}
// To perform rounding
return new BigDecimal(integerQuot, toIntScale(newScale), mc);
} Returns a new {@code BigDecimal} whose value is {@code this / divisor}.
The result is rounded according to the passed context {@code mc}. If the
passed math context specifies precision {@code 0}, then this call is
equivalent to {@code this.divide(divisor)}. |
public BigDecimal divide(BigDecimal divisor,
int scale,
int roundingMode) {
return divide(divisor, scale, RoundingMode.valueOf(roundingMode));
} Returns a new {@code BigDecimal} whose value is {@code this / divisor}.
As scale of the result the parameter {@code scale} is used. If rounding
is required to meet the specified scale, then the specified rounding mode
{@code roundingMode} is applied. |
public BigDecimal divide(BigDecimal divisor,
int scale,
RoundingMode roundingMode) {
// Let be: this = [u1,s1] and divisor = [u2,s2]
if (roundingMode == null) {
throw new NullPointerException();
}
if (divisor.isZero()) {
// math.04=Division by zero
throw new ArithmeticException(Messages.getString("math.04")); //$NON-NLS-1$
}
long diffScale = ((long)this.scale - divisor.scale) - scale;
if(this.bitLength < 64 && divisor.bitLength < 64 ) {
if(diffScale == 0) {
return dividePrimitiveLongs(this.smallValue,
divisor.smallValue,
scale,
roundingMode );
} else if(diffScale > 0) {
if(diffScale < LONG_TEN_POW.length &&
divisor.bitLength + LONG_TEN_POW_BIT_LENGTH[(int)diffScale] < 64) {
return dividePrimitiveLongs(this.smallValue,
divisor.smallValue*LONG_TEN_POW[(int)diffScale],
scale,
roundingMode);
}
} else { // diffScale < 0
if(-diffScale < LONG_TEN_POW.length &&
this.bitLength + LONG_TEN_POW_BIT_LENGTH[(int)-diffScale] < 64) {
return dividePrimitiveLongs(this.smallValue*LONG_TEN_POW[(int)-diffScale],
divisor.smallValue,
scale,
roundingMode);
}
}
}
BigInteger scaledDividend = this.getUnscaledValue();
BigInteger scaledDivisor = divisor.getUnscaledValue(); // for scaling of 'u2'
if (diffScale > 0) {
// Multiply 'u2' by: 10^((s1 - s2) - scale)
scaledDivisor = Multiplication.multiplyByTenPow(scaledDivisor, (int)diffScale);
} else if (diffScale < 0) {
// Multiply 'u1' by: 10^(scale - (s1 - s2))
scaledDividend = Multiplication.multiplyByTenPow(scaledDividend, (int)-diffScale);
}
return divideBigIntegers(scaledDividend, scaledDivisor, scale, roundingMode);
} Returns a new {@code BigDecimal} whose value is {@code this / divisor}.
As scale of the result the parameter {@code scale} is used. If rounding
is required to meet the specified scale, then the specified rounding mode
{@code roundingMode} is applied. |
public BigDecimal[] divideAndRemainder(BigDecimal divisor) {
BigDecimal quotAndRem[] = new BigDecimal[2];
quotAndRem[0] = this.divideToIntegralValue(divisor);
quotAndRem[1] = this.subtract( quotAndRem[0].multiply(divisor) );
return quotAndRem;
} Returns a {@code BigDecimal} array which contains the integral part of
{@code this / divisor} at index 0 and the remainder {@code this %
divisor} at index 1. The quotient is rounded down towards zero to the
next integer. |
public BigDecimal[] divideAndRemainder(BigDecimal divisor,
MathContext mc) {
BigDecimal quotAndRem[] = new BigDecimal[2];
quotAndRem[0] = this.divideToIntegralValue(divisor, mc);
quotAndRem[1] = this.subtract( quotAndRem[0].multiply(divisor) );
return quotAndRem;
} Returns a {@code BigDecimal} array which contains the integral part of
{@code this / divisor} at index 0 and the remainder {@code this %
divisor} at index 1. The quotient is rounded down towards zero to the
next integer. The rounding mode passed with the parameter {@code mc} is
not considered. But if the precision of {@code mc > 0} and the integral
part requires more digits, then an {@code ArithmeticException} is thrown. |
public BigDecimal divideToIntegralValue(BigDecimal divisor) {
BigInteger integralValue; // the integer of result
BigInteger powerOfTen; // some power of ten
BigInteger quotAndRem[] = {getUnscaledValue()};
long newScale = (long)this.scale - divisor.scale;
long tempScale = 0;
int i = 1;
int lastPow = TEN_POW.length - 1;
if (divisor.isZero()) {
// math.04=Division by zero
throw new ArithmeticException(Messages.getString("math.04")); //$NON-NLS-1$
}
if ((divisor.aproxPrecision() + newScale > this.aproxPrecision() + 1L)
|| (this.isZero())) {
/* If the divisor's integer part is greater than this's integer part,
* the result must be zero with the appropriate scale */
integralValue = BigInteger.ZERO;
} else if (newScale == 0) {
integralValue = getUnscaledValue().divide( divisor.getUnscaledValue() );
} else if (newScale > 0) {
powerOfTen = Multiplication.powerOf10(newScale);
integralValue = getUnscaledValue().divide( divisor.getUnscaledValue().multiply(powerOfTen) );
integralValue = integralValue.multiply(powerOfTen);
} else {// (newScale < 0)
powerOfTen = Multiplication.powerOf10(-newScale);
integralValue = getUnscaledValue().multiply(powerOfTen).divide( divisor.getUnscaledValue() );
// To strip trailing zeros approximating to the preferred scale
while (!integralValue.testBit(0)) {
quotAndRem = integralValue.divideAndRemainder(TEN_POW[i]);
if ((quotAndRem[1].signum() == 0)
&& (tempScale - i >= newScale)) {
tempScale -= i;
if (i < lastPow) {
i++;
}
integralValue = quotAndRem[0];
} else {
if (i == 1) {
break;
}
i = 1;
}
}
newScale = tempScale;
}
return ((integralValue.signum() == 0)
? zeroScaledBy(newScale)
: new BigDecimal(integralValue, toIntScale(newScale)));
} Returns a new {@code BigDecimal} whose value is the integral part of
{@code this / divisor}. The quotient is rounded down towards zero to the
next integer. For example, {@code 0.5/0.2 = 2}. |
public BigDecimal divideToIntegralValue(BigDecimal divisor,
MathContext mc) {
int mcPrecision = mc.getPrecision();
int diffPrecision = this.precision() - divisor.precision();
int lastPow = TEN_POW.length - 1;
long diffScale = (long)this.scale - divisor.scale;
long newScale = diffScale;
long quotPrecision = diffPrecision - diffScale + 1;
BigInteger quotAndRem[] = new BigInteger[2];
// In special cases it call the dual method
if ((mcPrecision == 0) || (this.isZero()) || (divisor.isZero())) {
return this.divideToIntegralValue(divisor);
}
// Let be: this = [u1,s1] and divisor = [u2,s2]
if (quotPrecision < = 0) {
quotAndRem[0] = BigInteger.ZERO;
} else if (diffScale == 0) {
// CASE s1 == s2: to calculate u1 / u2
quotAndRem[0] = this.getUnscaledValue().divide( divisor.getUnscaledValue() );
} else if (diffScale > 0) {
// CASE s1 >= s2: to calculate u1 / (u2 * 10^(s1-s2)
quotAndRem[0] = this.getUnscaledValue().divide(
divisor.getUnscaledValue().multiply(Multiplication.powerOf10(diffScale)) );
// To chose 10^newScale to get a quotient with at least 'mc.precision()' digits
newScale = Math.min(diffScale, Math.max(mcPrecision - quotPrecision + 1, 0));
// To calculate: (u1 / (u2 * 10^(s1-s2)) * 10^newScale
quotAndRem[0] = quotAndRem[0].multiply(Multiplication.powerOf10(newScale));
} else {// CASE s2 > s1:
/* To calculate the minimum power of ten, such that the quotient
* (u1 * 10^exp) / u2 has at least 'mc.precision()' digits. */
long exp = Math.min(-diffScale, Math.max((long)mcPrecision - diffPrecision, 0));
long compRemDiv;
// Let be: (u1 * 10^exp) / u2 = [q,r]
quotAndRem = this.getUnscaledValue().multiply(Multiplication.powerOf10(exp)).
divideAndRemainder(divisor.getUnscaledValue());
newScale += exp; // To fix the scale
exp = -newScale; // The remaining power of ten
// If after division there is a remainder...
if ((quotAndRem[1].signum() != 0) && (exp > 0)) {
// Log10(r) + ((s2 - s1) - exp) > mc.precision ?
compRemDiv = (new BigDecimal(quotAndRem[1])).precision()
+ exp - divisor.precision();
if (compRemDiv == 0) {
// To calculate: (r * 10^exp2) / u2
quotAndRem[1] = quotAndRem[1].multiply(Multiplication.powerOf10(exp)).
divide(divisor.getUnscaledValue());
compRemDiv = Math.abs(quotAndRem[1].signum());
}
if (compRemDiv > 0) {
// The quotient won't fit in 'mc.precision()' digits
// math.06=Division impossible
throw new ArithmeticException(Messages.getString("math.06")); //$NON-NLS-1$
}
}
}
// Fast return if the quotient is zero
if (quotAndRem[0].signum() == 0) {
return zeroScaledBy(diffScale);
}
BigInteger strippedBI = quotAndRem[0];
BigDecimal integralValue = new BigDecimal(quotAndRem[0]);
long resultPrecision = integralValue.precision();
int i = 1;
// To strip trailing zeros until the specified precision is reached
while (!strippedBI.testBit(0)) {
quotAndRem = strippedBI.divideAndRemainder(TEN_POW[i]);
if ((quotAndRem[1].signum() == 0) &&
((resultPrecision - i >= mcPrecision)
|| (newScale - i >= diffScale)) ) {
resultPrecision -= i;
newScale -= i;
if (i < lastPow) {
i++;
}
strippedBI = quotAndRem[0];
} else {
if (i == 1) {
break;
}
i = 1;
}
}
// To check if the result fit in 'mc.precision()' digits
if (resultPrecision > mcPrecision) {
// math.06=Division impossible
throw new ArithmeticException(Messages.getString("math.06")); //$NON-NLS-1$
}
integralValue.scale = toIntScale(newScale);
integralValue.setUnscaledValue(strippedBI);
return integralValue;
} Returns a new {@code BigDecimal} whose value is the integral part of
{@code this / divisor}. The quotient is rounded down towards zero to the
next integer. The rounding mode passed with the parameter {@code mc} is
not considered. But if the precision of {@code mc > 0} and the integral
part requires more digits, then an {@code ArithmeticException} is thrown. |
public double doubleValue() {
int sign = signum();
int exponent = 1076; // bias + 53
int lowestSetBit;
int discardedSize;
long powerOfTwo = this.bitLength - (long)(scale / LOG10_2);
long bits; // IEEE-754 Standard
long tempBits; // for temporal calculations
BigInteger mantisa;
if ((powerOfTwo < -1074) || (sign == 0)) {
// Cases which 'this' is very small
return (sign * 0.0d);
} else if (powerOfTwo > 1025) {
// Cases which 'this' is very large
return (sign * Double.POSITIVE_INFINITY);
}
mantisa = getUnscaledValue().abs();
// Let be: this = [u,s], with s > 0
if (scale < = 0) {
// mantisa = abs(u) * 10^s
mantisa = mantisa.multiply(Multiplication.powerOf10(-scale));
} else {// (scale > 0)
BigInteger quotAndRem[];
BigInteger powerOfTen = Multiplication.powerOf10(scale);
int k = 100 - (int)powerOfTwo;
int compRem;
if (k > 0) {
/* Computing (mantisa * 2^k) , where 'k' is a enough big
* power of '2' to can divide by 10^s */
mantisa = mantisa.shiftLeft(k);
exponent -= k;
}
// Computing (mantisa * 2^k) / 10^s
quotAndRem = mantisa.divideAndRemainder(powerOfTen);
// To check if the fractional part >= 0.5
compRem = quotAndRem[1].shiftLeftOneBit().compareTo(powerOfTen);
// To add two rounded bits at end of mantisa
mantisa = quotAndRem[0].shiftLeft(2).add(
BigInteger.valueOf((compRem * (compRem + 3)) / 2 + 1));
exponent -= 2;
}
lowestSetBit = mantisa.getLowestSetBit();
discardedSize = mantisa.bitLength() - 54;
if (discardedSize > 0) {// (n > 54)
// mantisa = (abs(u) * 10^s) > > (n - 54)
bits = mantisa.shiftRight(discardedSize).longValue();
tempBits = bits;
// #bits = 54, to check if the discarded fraction produces a carry
if ((((bits & 1) == 1) && (lowestSetBit < discardedSize))
|| ((bits & 3) == 3)) {
bits += 2;
}
} else {// (n < = 54)
// mantisa = (abs(u) * 10^s) < < (54 - n)
bits = mantisa.longValue() < < -discardedSize;
tempBits = bits;
// #bits = 54, to check if the discarded fraction produces a carry:
if ((bits & 3) == 3) {
bits += 2;
}
}
// Testing bit 54 to check if the carry creates a new binary digit
if ((bits & 0x40000000000000L) == 0) {
// To drop the last bit of mantisa (first discarded)
bits > >= 1;
// exponent = 2^(s-n+53+bias)
exponent += discardedSize;
} else {// #bits = 54
bits > >= 2;
exponent += discardedSize + 1;
}
// To test if the 53-bits number fits in 'double'
if (exponent > 2046) {// (exponent - bias > 1023)
return (sign * Double.POSITIVE_INFINITY);
} else if (exponent < = 0) {// (exponent - bias < = -1023)
// Denormalized numbers (having exponent == 0)
if (exponent < -53) {// exponent - bias < -1076
return (sign * 0.0d);
}
// -1076 < = exponent - bias < = -1023
// To discard '- exponent + 1' bits
bits = tempBits > > 1;
tempBits = bits & (-1L > > > (63 + exponent));
bits > >= (-exponent );
// To test if after discard bits, a new carry is generated
if (((bits & 3) == 3) || (((bits & 1) == 1) && (tempBits != 0)
&& (lowestSetBit < discardedSize))) {
bits += 1;
}
exponent = 0;
bits > >= 1;
}
// Construct the 64 double bits: [sign(1), exponent(11), mantisa(52)]
bits = (sign & 0x8000000000000000L) | ((long)exponent < < 52)
| (bits & 0xFFFFFFFFFFFFFL);
return Double.longBitsToDouble(bits);
} Returns this {@code BigDecimal} as a double value. If {@code this} is too
big to be represented as an float, then {@code Double.POSITIVE_INFINITY}
or {@code Double.NEGATIVE_INFINITY} is returned.
Note, that if the unscaled value has more than 53 significant digits,
then this decimal cannot be represented exactly in a double variable. In
this case the result is rounded.
For example, if the instance {@code x1 = new BigDecimal("0.1")} cannot be
represented exactly as a double, and thus {@code x1.equals(new
BigDecimal(x1.doubleValue())} returns {@code false} for this case.
Similarly, if the instance {@code new BigDecimal(9007199254740993L)} is
converted to a double, the result is {@code 9.007199254740992E15}.
|
public boolean equals(Object x) {
if (this == x) {
return true;
}
if (x instanceof BigDecimal) {
BigDecimal x1 = (BigDecimal) x;
return x1.scale == scale
&& (bitLength < 64 ? (x1.smallValue == smallValue)
: intVal.equals(x1.intVal));
}
return false;
} Returns {@code true} if {@code x} is a {@code BigDecimal} instance and if
this instance is equal to this big decimal. Two big decimals are equal if
their unscaled value and their scale is equal. For example, 1.0
(10*10^(-1)) is not equal to 1.00 (100*10^(-2)). Similarly, zero
instances are not equal if their scale differs. |
public float floatValue() {
/* A similar code like in doubleValue() could be repeated here,
* but this simple implementation is quite efficient. */
float floatResult = signum();
long powerOfTwo = this.bitLength - (long)(scale / LOG10_2);
if ((powerOfTwo < -149) || (floatResult == 0.0f)) {
// Cases which 'this' is very small
floatResult *= 0.0f;
} else if (powerOfTwo > 129) {
// Cases which 'this' is very large
floatResult *= Float.POSITIVE_INFINITY;
} else {
floatResult = (float)doubleValue();
}
return floatResult;
} Returns this {@code BigDecimal} as a float value. If {@code this} is too
big to be represented as an float, then {@code Float.POSITIVE_INFINITY}
or {@code Float.NEGATIVE_INFINITY} is returned.
Note, that if the unscaled value has more than 24 significant digits,
then this decimal cannot be represented exactly in a float variable. In
this case the result is rounded.
For example, if the instance {@code x1 = new BigDecimal("0.1")} cannot be
represented exactly as a float, and thus {@code x1.equals(new
BigDecimal(x1.folatValue())} returns {@code false} for this case.
Similarly, if the instance {@code new BigDecimal(16777217)} is converted
to a float, the result is {@code 1.6777216E}7. |
public int hashCode() {
if (hashCode != 0) {
return hashCode;
}
if (bitLength < 64) {
hashCode = (int)(smallValue & 0xffffffff);
hashCode = 33 * hashCode + (int)((smallValue > > 32) & 0xffffffff);
hashCode = 17 * hashCode + scale;
return hashCode;
}
hashCode = 17 * intVal.hashCode() + scale;
return hashCode;
} Returns a hash code for this {@code BigDecimal}. |
public int intValue() {
/* If scale < = -32 there are at least 32 trailing bits zero in 10^(-scale).
* If the scale is positive and very large the long value could be zero. */
return ((scale < = -32) || (scale > aproxPrecision())
? 0
: toBigInteger().intValue());
} Returns this {@code BigDecimal} as an int value. Any fractional part is
discarded. If the integral part of {@code this} is too big to be
represented as an int, then {@code this} % 2^32 is returned. |
public int intValueExact() {
return (int)valueExact(32);
} Returns this {@code BigDecimal} as a int value if it has no fractional
part and if its value fits to the int range ([-2^{31}..2^{31}-1]). If
these conditions are not met, an {@code ArithmeticException} is thrown. |
public long longValue() {
/* If scale < = -64 there are at least 64 trailing bits zero in 10^(-scale).
* If the scale is positive and very large the long value could be zero. */
return ((scale < = -64) || (scale > aproxPrecision())
? 0L
: toBigInteger().longValue());
} Returns this {@code BigDecimal} as an long value. Any fractional part is
discarded. If the integral part of {@code this} is too big to be
represented as an long, then {@code this} % 2^64 is returned. |
public long longValueExact() {
return valueExact(64);
} Returns this {@code BigDecimal} as a long value if it has no fractional
part and if its value fits to the int range ([-2^{63}..2^{63}-1]). If
these conditions are not met, an {@code ArithmeticException} is thrown. |
public BigDecimal max(BigDecimal val) {
return ((compareTo(val) >= 0) ? this : val);
} Returns the maximum of this {@code BigDecimal} and {@code val}. |
public BigDecimal min(BigDecimal val) {
return ((compareTo(val) < = 0) ? this : val);
} Returns the minimum of this {@code BigDecimal} and {@code val}. |
public BigDecimal movePointLeft(int n) {
return movePoint(scale + (long)n);
} Returns a new {@code BigDecimal} instance where the decimal point has
been moved {@code n} places to the left. If {@code n < 0} then the
decimal point is moved {@code -n} places to the right.
The result is obtained by changing its scale. If the scale of the result
becomes negative, then its precision is increased such that the scale is
zero.
Note, that {@code movePointLeft(0)} returns a result which is
mathematically equivalent, but which has {@code scale >= 0}. |
public BigDecimal movePointRight(int n) {
return movePoint(scale - (long)n);
} Returns a new {@code BigDecimal} instance where the decimal point has
been moved {@code n} places to the right. If {@code n < 0} then the
decimal point is moved {@code -n} places to the left.
The result is obtained by changing its scale. If the scale of the result
becomes negative, then its precision is increased such that the scale is
zero.
Note, that {@code movePointRight(0)} returns a result which is
mathematically equivalent, but which has scale >= 0. |
public BigDecimal multiply(BigDecimal multiplicand) {
long newScale = (long)this.scale + multiplicand.scale;
if ((this.isZero()) || (multiplicand.isZero())) {
return zeroScaledBy(newScale);
}
/* Let be: this = [u1,s1] and multiplicand = [u2,s2] so:
* this x multiplicand = [ s1 * s2 , s1 + s2 ] */
if(this.bitLength + multiplicand.bitLength < 64) {
return valueOf(this.smallValue*multiplicand.smallValue,toIntScale(newScale));
}
return new BigDecimal(this.getUnscaledValue().multiply(
multiplicand.getUnscaledValue()), toIntScale(newScale));
} Returns a new {@code BigDecimal} whose value is {@code this *
multiplicand}. The scale of the result is the sum of the scales of the
two arguments. |
public BigDecimal multiply(BigDecimal multiplicand,
MathContext mc) {
BigDecimal result = multiply(multiplicand);
result.inplaceRound(mc);
return result;
} Returns a new {@code BigDecimal} whose value is {@code this *
multiplicand}. The result is rounded according to the passed context
{@code mc}. |
public BigDecimal negate() {
if(bitLength < 63 || (bitLength == 63 && smallValue!=Long.MIN_VALUE)) {
return valueOf(-smallValue,scale);
}
return new BigDecimal(getUnscaledValue().negate(), scale);
} Returns a new {@code BigDecimal} whose value is the {@code -this}. The
scale of the result is the same as the scale of this. |
public BigDecimal negate(MathContext mc) {
return round(mc).negate();
} Returns a new {@code BigDecimal} whose value is the {@code -this}. The
result is rounded according to the passed context {@code mc}. |
public BigDecimal plus() {
return this;
} Returns a new {@code BigDecimal} whose value is {@code +this}. The scale
of the result is the same as the scale of this. |
public BigDecimal plus(MathContext mc) {
return round(mc);
} Returns a new {@code BigDecimal} whose value is {@code +this}. The result
is rounded according to the passed context {@code mc}. |
public BigDecimal pow(int n) {
if (n == 0) {
return ONE;
}
if ((n < 0) || (n > 999999999)) {
// math.07=Invalid Operation
throw new ArithmeticException(Messages.getString("math.07")); //$NON-NLS-1$
}
long newScale = scale * (long)n;
// Let be: this = [u,s] so: this^n = [u^n, s*n]
return ((isZero())
? zeroScaledBy(newScale)
: new BigDecimal(getUnscaledValue().pow(n), toIntScale(newScale)));
} Returns a new {@code BigDecimal} whose value is {@code this ^ n}. The
scale of the result is {@code n} times the scales of {@code this}.
{@code x.pow(0)} returns {@code 1}, even if {@code x == 0}.
Implementation Note: The implementation is based on the ANSI standard
X3.274-1996 algorithm. |
public BigDecimal pow(int n,
MathContext mc) {
// The ANSI standard X3.274-1996 algorithm
int m = Math.abs(n);
int mcPrecision = mc.getPrecision();
int elength = (int)Math.log10(m) + 1; // decimal digits in 'n'
int oneBitMask; // mask of bits
BigDecimal accum; // the single accumulator
MathContext newPrecision = mc; // MathContext by default
// In particular cases, it reduces the problem to call the other 'pow()'
if ((n == 0) || ((isZero()) && (n > 0))) {
return pow(n);
}
if ((m > 999999999) || ((mcPrecision == 0) && (n < 0))
|| ((mcPrecision > 0) && (elength > mcPrecision))) {
// math.07=Invalid Operation
throw new ArithmeticException(Messages.getString("math.07")); //$NON-NLS-1$
}
if (mcPrecision > 0) {
newPrecision = new MathContext( mcPrecision + elength + 1,
mc.getRoundingMode());
}
// The result is calculated as if 'n' were positive
accum = round(newPrecision);
oneBitMask = Integer.highestOneBit(m) > > 1;
while (oneBitMask > 0) {
accum = accum.multiply(accum, newPrecision);
if ((m & oneBitMask) == oneBitMask) {
accum = accum.multiply(this, newPrecision);
}
oneBitMask > >= 1;
}
// If 'n' is negative, the value is divided into 'ONE'
if (n < 0) {
accum = ONE.divide(accum, newPrecision);
}
// The final value is rounded to the destination precision
accum.inplaceRound(mc);
return accum;
} |
public int precision() {
// Checking if the precision already was calculated
if (precision > 0) {
return precision;
}
int bitLength = this.bitLength;
int decimalDigits = 1; // the precision to be calculated
double doubleUnsc = 1; // intVal in 'double'
if (bitLength < 1024) {
// To calculate the precision for small numbers
if (bitLength >= 64) {
doubleUnsc = getUnscaledValue().doubleValue();
} else if (bitLength >= 1) {
doubleUnsc = smallValue;
}
decimalDigits += Math.log10(Math.abs(doubleUnsc));
} else {// (bitLength >= 1024)
/* To calculate the precision for large numbers
* Note that: 2 ^(bitlength() - 1) < = intVal < 10 ^(precision()) */
decimalDigits += (bitLength - 1) * LOG10_2;
// If after division the number isn't zero, exists an aditional digit
if (getUnscaledValue().divide(Multiplication.powerOf10(decimalDigits)).signum() != 0) {
decimalDigits++;
}
}
precision = decimalDigits;
return precision;
} Returns the precision of this {@code BigDecimal}. The precision is the
number of decimal digits used to represent this decimal. It is equivalent
to the number of digits of the unscaled value. The precision of {@code 0}
is {@code 1} (independent of the scale). |
public BigDecimal remainder(BigDecimal divisor) {
return divideAndRemainder(divisor)[1];
} |
public BigDecimal remainder(BigDecimal divisor,
MathContext mc) {
return divideAndRemainder(divisor, mc)[1];
} Returns a new {@code BigDecimal} whose value is {@code this % divisor}.
The remainder is defined as {@code this -
this.divideToIntegralValue(divisor) * divisor}.
The specified rounding mode {@code mc} is used for the division only. |
public BigDecimal round(MathContext mc) {
BigDecimal thisBD = new BigDecimal(getUnscaledValue(), scale);
thisBD.inplaceRound(mc);
return thisBD;
} Returns a new {@code BigDecimal} whose value is {@code this}, rounded
according to the passed context {@code mc}.
If {@code mc.precision = 0}, then no rounding is performed.
If {@code mc.precision > 0} and {@code mc.roundingMode == UNNECESSARY},
then an {@code ArithmeticException} is thrown if the result cannot be
represented exactly within the given precision. |
public int scale() {
return scale;
} Returns the scale of this {@code BigDecimal}. The scale is the number of
digits behind the decimal point. The value of this {@code BigDecimal} is
the unsignedValue * 10^(-scale). If the scale is negative, then this
{@code BigDecimal} represents a big integer. |
public BigDecimal scaleByPowerOfTen(int n) {
long newScale = scale - (long)n;
if(bitLength < 64) {
//Taking care when a 0 is to be scaled
if( smallValue==0 ){
return zeroScaledBy( newScale );
}
return valueOf(smallValue,toIntScale(newScale));
}
return new BigDecimal(getUnscaledValue(), toIntScale(newScale));
} Returns a new {@code BigDecimal} whose value is {@code this} 10^{@code n}.
The scale of the result is {@code this.scale()} - {@code n}.
The precision of the result is the precision of {@code this}.
This method has the same effect as #movePointRight , except that
the precision is not changed. |
public BigDecimal setScale(int newScale) {
return setScale(newScale, RoundingMode.UNNECESSARY);
} Returns a new {@code BigDecimal} instance with the specified scale. If
the new scale is greater than the old scale, then additional zeros are
added to the unscaled value. If the new scale is smaller than the old
scale, then trailing zeros are removed. If the trailing digits are not
zeros then an ArithmeticException is thrown.
If no exception is thrown, then the following equation holds: {@code
x.setScale(s).compareTo(x) == 0}. |
public BigDecimal setScale(int newScale,
RoundingMode roundingMode) {
if (roundingMode == null) {
throw new NullPointerException();
}
long diffScale = newScale - (long)scale;
// Let be: 'this' = [u,s]
if(diffScale == 0) {
return this;
}
if(diffScale > 0) {
// return [u * 10^(s2 - s), newScale]
if(diffScale < LONG_TEN_POW.length &&
(this.bitLength + LONG_TEN_POW_BIT_LENGTH[(int)diffScale]) < 64 ) {
return valueOf(this.smallValue*LONG_TEN_POW[(int)diffScale],newScale);
}
return new BigDecimal(Multiplication.multiplyByTenPow(getUnscaledValue(),(int)diffScale), newScale);
}
// diffScale < 0
// return [u,s] / [1,newScale] with the appropriate scale and rounding
if(this.bitLength < 64 && -diffScale < LONG_TEN_POW.length) {
return dividePrimitiveLongs(this.smallValue, LONG_TEN_POW[(int)-diffScale], newScale,roundingMode);
}
return divideBigIntegers(this.getUnscaledValue(),Multiplication.powerOf10(-diffScale),newScale,roundingMode);
} Returns a new {@code BigDecimal} instance with the specified scale.
If the new scale is greater than the old scale, then additional zeros are
added to the unscaled value. In this case no rounding is necessary.
If the new scale is smaller than the old scale, then trailing digits are
removed. If these trailing digits are not zero, then the remaining
unscaled value has to be rounded. For this rounding operation the
specified rounding mode is used. |
public BigDecimal setScale(int newScale,
int roundingMode) {
return setScale(newScale, RoundingMode.valueOf(roundingMode));
} Returns a new {@code BigDecimal} instance with the specified scale.
If the new scale is greater than the old scale, then additional zeros are
added to the unscaled value. In this case no rounding is necessary.
If the new scale is smaller than the old scale, then trailing digits are
removed. If these trailing digits are not zero, then the remaining
unscaled value has to be rounded. For this rounding operation the
specified rounding mode is used. |
public short shortValueExact() {
return (short)valueExact(16);
} Returns this {@code BigDecimal} as a short value if it has no fractional
part and if its value fits to the short range ([-2^{15}..2^{15}-1]). If
these conditions are not met, an {@code ArithmeticException} is thrown. |
public int signum() {
if( bitLength < 64) {
return Long.signum( this.smallValue );
}
return getUnscaledValue().signum();
} Returns the sign of this {@code BigDecimal}. |
public BigDecimal stripTrailingZeros() {
int i = 1; // 1 < = i < = 18
int lastPow = TEN_POW.length - 1;
long newScale = scale;
if (isZero()) {
return new BigDecimal("0");
}
BigInteger strippedBI = getUnscaledValue();
BigInteger[] quotAndRem;
// while the number is even...
while (!strippedBI.testBit(0)) {
// To divide by 10^i
quotAndRem = strippedBI.divideAndRemainder(TEN_POW[i]);
// To look the remainder
if (quotAndRem[1].signum() == 0) {
// To adjust the scale
newScale -= i;
if (i < lastPow) {
// To set to the next power
i++;
}
strippedBI = quotAndRem[0];
} else {
if (i == 1) {
// 'this' has no more trailing zeros
break;
}
// To set to the smallest power of ten
i = 1;
}
}
return new BigDecimal(strippedBI, toIntScale(newScale));
} Returns a new {@code BigDecimal} instance with the same value as {@code
this} but with a unscaled value where the trailing zeros have been
removed. If the unscaled value of {@code this} has n trailing zeros, then
the scale and the precision of the result has been reduced by n. |
public BigDecimal subtract(BigDecimal subtrahend) {
int diffScale = this.scale - subtrahend.scale;
// Fast return when some operand is zero
if (this.isZero()) {
if (diffScale < = 0) {
return subtrahend.negate();
}
if (subtrahend.isZero()) {
return this;
}
} else if (subtrahend.isZero()) {
if (diffScale >= 0) {
return this;
}
}
// Let be: this = [u1,s1] and subtrahend = [u2,s2] so:
if (diffScale == 0) {
// case s1 = s2 : [u1 - u2 , s1]
if (Math.max(this.bitLength, subtrahend.bitLength) + 1 < 64) {
return valueOf(this.smallValue - subtrahend.smallValue,this.scale);
}
return new BigDecimal(this.getUnscaledValue().subtract(subtrahend.getUnscaledValue()), this.scale);
} else if (diffScale > 0) {
// case s1 > s2 : [ u1 - u2 * 10 ^ (s1 - s2) , s1 ]
if(diffScale < LONG_TEN_POW.length &&
Math.max(this.bitLength,subtrahend.bitLength+LONG_TEN_POW_BIT_LENGTH[diffScale])+1< 64) {
return valueOf(this.smallValue-subtrahend.smallValue*LONG_TEN_POW[diffScale],this.scale);
}
return new BigDecimal(this.getUnscaledValue().subtract(
Multiplication.multiplyByTenPow(subtrahend.getUnscaledValue(),diffScale)), this.scale);
} else {// case s2 > s1 : [ u1 * 10 ^ (s2 - s1) - u2 , s2 ]
diffScale = -diffScale;
if(diffScale < LONG_TEN_POW.length &&
Math.max(this.bitLength+LONG_TEN_POW_BIT_LENGTH[diffScale],subtrahend.bitLength)+1< 64) {
return valueOf(this.smallValue*LONG_TEN_POW[diffScale]-subtrahend.smallValue,subtrahend.scale);
}
return new BigDecimal(Multiplication.multiplyByTenPow(this.getUnscaledValue(),diffScale)
.subtract(subtrahend.getUnscaledValue()), subtrahend.scale);
}
} Returns a new {@code BigDecimal} whose value is {@code this - subtrahend}.
The scale of the result is the maximum of the scales of the two arguments. |
public BigDecimal subtract(BigDecimal subtrahend,
MathContext mc) {
long diffScale = subtrahend.scale - (long)this.scale;
int thisSignum;
BigDecimal leftOperand; // it will be only the left operand (this)
BigInteger tempBI;
// Some operand is zero or the precision is infinity
if ((subtrahend.isZero()) || (this.isZero())
|| (mc.getPrecision() == 0)) {
return subtract(subtrahend).round(mc);
}
// Now: this != 0 and subtrahend != 0
if (subtrahend.aproxPrecision() < diffScale - 1) {
// Cases where it is unnecessary to subtract two numbers with very different scales
if (mc.getPrecision() < this.aproxPrecision()) {
thisSignum = this.signum();
if (thisSignum != subtrahend.signum()) {
tempBI = Multiplication.multiplyByPositiveInt(this.getUnscaledValue(), 10)
.add(BigInteger.valueOf(thisSignum));
} else {
tempBI = this.getUnscaledValue().subtract(BigInteger.valueOf(thisSignum));
tempBI = Multiplication.multiplyByPositiveInt(tempBI, 10)
.add(BigInteger.valueOf(thisSignum * 9));
}
// Rounding the improved subtracting
leftOperand = new BigDecimal(tempBI, this.scale + 1);
return leftOperand.round(mc);
}
}
// No optimization is done
return subtract(subtrahend).round(mc);
} Returns a new {@code BigDecimal} whose value is {@code this - subtrahend}.
The result is rounded according to the passed context {@code mc}. |
public BigInteger toBigInteger() {
if ((scale == 0) || (isZero())) {
return getUnscaledValue();
} else if (scale < 0) {
return getUnscaledValue().multiply(Multiplication.powerOf10(-(long)scale));
} else {// (scale > 0)
return getUnscaledValue().divide(Multiplication.powerOf10(scale));
}
} Returns this {@code BigDecimal} as a big integer instance. A fractional
part is discarded. |
public BigInteger toBigIntegerExact() {
if ((scale == 0) || (isZero())) {
return getUnscaledValue();
} else if (scale < 0) {
return getUnscaledValue().multiply(Multiplication.powerOf10(-(long)scale));
} else {// (scale > 0)
BigInteger[] integerAndFraction;
// An optimization before do a heavy division
if ((scale > aproxPrecision()) || (scale > getUnscaledValue().getLowestSetBit())) {
// math.08=Rounding necessary
throw new ArithmeticException(Messages.getString("math.08")); //$NON-NLS-1$
}
integerAndFraction = getUnscaledValue().divideAndRemainder(Multiplication.powerOf10(scale));
if (integerAndFraction[1].signum() != 0) {
// It exists a non-zero fractional part
// math.08=Rounding necessary
throw new ArithmeticException(Messages.getString("math.08")); //$NON-NLS-1$
}
return integerAndFraction[0];
}
} Returns this {@code BigDecimal} as a big integer instance if it has no
fractional part. If this {@code BigDecimal} has a fractional part, i.e.
if rounding would be necessary, an {@code ArithmeticException} is thrown. |
public String toEngineeringString() {
String intString = getUnscaledValue().toString();
if (scale == 0) {
return intString;
}
int begin = (getUnscaledValue().signum() < 0) ? 2 : 1;
int end = intString.length();
long exponent = -(long)scale + end - begin;
StringBuilder result = new StringBuilder(intString);
if ((scale > 0) && (exponent >= -6)) {
if (exponent >= 0) {
result.insert(end - scale, '.');
} else {
result.insert(begin - 1, "0."); //$NON-NLS-1$
result.insert(begin + 1, CH_ZEROS, 0, -(int)exponent - 1);
}
} else {
int delta = end - begin;
int rem = (int)(exponent % 3);
if (rem != 0) {
// adjust exponent so it is a multiple of three
if (getUnscaledValue().signum() == 0) {
// zero value
rem = (rem < 0) ? -rem : 3 - rem;
exponent += rem;
} else {
// nonzero value
rem = (rem < 0) ? rem + 3 : rem;
exponent -= rem;
begin += rem;
}
if (delta < 3) {
for (int i = rem - delta; i > 0; i--) {
result.insert(end++, '0');
}
}
}
if (end - begin >= 1) {
result.insert(begin, '.');
end++;
}
if (exponent != 0) {
result.insert(end, 'E');
if (exponent > 0) {
result.insert(++end, '+');
}
result.insert(++end, Long.toString(exponent));
}
}
return result.toString();
} Returns a string representation of this {@code BigDecimal}. This
representation always prints all significant digits of this value.
If the scale is negative or if {@code scale - precision >= 6} then
engineering notation is used. Engineering notation is similar to the
scientific notation except that the exponent is made to be a multiple of
3 such that the integer part is >= 1 and < 1000. |
public String toPlainString() {
String intStr = getUnscaledValue().toString();
if ((scale == 0) || ((isZero()) && (scale < 0))) {
return intStr;
}
int begin = (signum() < 0) ? 1 : 0;
int delta = scale;
// We take space for all digits, plus a possible decimal point, plus 'scale'
StringBuilder result = new StringBuilder(intStr.length() + 1 + Math.abs(scale));
if (begin == 1) {
// If the number is negative, we insert a '-' character at front
result.append('-');
}
if (scale > 0) {
delta -= (intStr.length() - begin);
if (delta >= 0) {
result.append("0."); //$NON-NLS-1$
// To append zeros after the decimal point
for (; delta > CH_ZEROS.length; delta -= CH_ZEROS.length) {
result.append(CH_ZEROS);
}
result.append(CH_ZEROS, 0, delta);
result.append(intStr.substring(begin));
} else {
delta = begin - delta;
result.append(intStr.substring(begin, delta));
result.append('.');
result.append(intStr.substring(delta));
}
} else {// (scale < = 0)
result.append(intStr.substring(begin));
// To append trailing zeros
for (; delta < -CH_ZEROS.length; delta += CH_ZEROS.length) {
result.append(CH_ZEROS);
}
result.append(CH_ZEROS, 0, -delta);
}
return result.toString();
} Returns a string representation of this {@code BigDecimal}. No scientific
notation is used. This methods adds zeros where necessary.
If this string representation is used to create a new instance, this
instance is generally not identical to {@code this} as the precision
changes.
{@code x.equals(new BigDecimal(x.toPlainString())} usually returns
{@code false}.
{@code x.compareTo(new BigDecimal(x.toPlainString())} returns {@code 0}. |
public String toString() {
if (toStringImage != null) {
return toStringImage;
}
if(bitLength < 32) {
toStringImage = Conversion.toDecimalScaledString(smallValue,scale);
return toStringImage;
}
String intString = getUnscaledValue().toString();
if (scale == 0) {
return intString;
}
int begin = (getUnscaledValue().signum() < 0) ? 2 : 1;
int end = intString.length();
long exponent = -(long)scale + end - begin;
StringBuilder result = new StringBuilder();
result.append(intString);
if ((scale > 0) && (exponent >= -6)) {
if (exponent >= 0) {
result.insert(end - scale, '.');
} else {
result.insert(begin - 1, "0."); //$NON-NLS-1$
result.insert(begin + 1, CH_ZEROS, 0, -(int)exponent - 1);
}
} else {
if (end - begin >= 1) {
result.insert(begin, '.');
end++;
}
result.insert(end, 'E');
if (exponent > 0) {
result.insert(++end, '+');
}
result.insert(++end, Long.toString(exponent));
}
toStringImage = result.toString();
return toStringImage;
} |
public BigDecimal ulp() {
return valueOf(1, scale);
} Returns the unit in the last place (ULP) of this {@code BigDecimal}
instance. An ULP is the distance to the nearest big decimal with the same
precision.
The amount of a rounding error in the evaluation of a floating-point
operation is often expressed in ULPs. An error of 1 ULP is often seen as
a tolerable error.
For class {@code BigDecimal}, the ULP of a number is simply 10^(-scale).
For example, {@code new BigDecimal(0.1).ulp()} returns {@code 1E-55}. |
public BigInteger unscaledValue() {
return getUnscaledValue();
} Returns the unscaled value (mantissa) of this {@code BigDecimal} instance
as a {@code BigInteger}. The unscaled value can be computed as {@code
this} 10^(scale). |
public static BigDecimal valueOf(long unscaledVal) {
if ((unscaledVal >= 0) && (unscaledVal < BI_SCALED_BY_ZERO_LENGTH)) {
return BI_SCALED_BY_ZERO[(int)unscaledVal];
}
return new BigDecimal(unscaledVal,0);
} Returns a new {@code BigDecimal} instance whose value is equal to {@code
unscaledVal}. The scale of the result is {@code 0}, and its unscaled
value is {@code unscaledVal}. |
public static BigDecimal valueOf(double val) {
if (Double.isInfinite(val) || Double.isNaN(val)) {
// math.03=Infinity or NaN
throw new NumberFormatException(Messages.getString("math.03")); //$NON-NLS-1$
}
return new BigDecimal(Double.toString(val));
} Returns a new {@code BigDecimal} instance whose value is equal to {@code
val}. The new decimal is constructed as if the {@code BigDecimal(String)}
constructor is called with an argument which is equal to {@code
Double.toString(val)}. For example, {@code valueOf("0.1")} is converted to
(unscaled=1, scale=1), although the double {@code 0.1} cannot be
represented exactly as a double value. In contrast to that, a new {@code
BigDecimal(0.1)} instance has the value {@code
0.1000000000000000055511151231257827021181583404541015625} with an
unscaled value {@code 1000000000000000055511151231257827021181583404541015625}
and the scale {@code 55}. |
public static BigDecimal valueOf(long unscaledVal,
int scale) {
if (scale == 0) {
return valueOf(unscaledVal);
}
if ((unscaledVal == 0) && (scale >= 0)
&& (scale < ZERO_SCALED_BY.length)) {
return ZERO_SCALED_BY[scale];
}
return new BigDecimal(unscaledVal, scale);
} Returns a new {@code BigDecimal} instance whose value is equal to {@code
unscaledVal} 10^(-{@code scale}). The scale of the result is {@code
scale}, and its unscaled value is {@code unscaledVal}. |
java.lang.Number
Save This Page