/** * Returns a new {@code BigDecimal} whose value is {@code this * 10<sup>n</sup>}. * The scale of the result is {@code this.scale()} - {@code n}. * The precision of the result is the precision of {@code this}. * * <p>This method has the same effect as {@link #movePointRight}, except that * the precision is not changed. */ 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, safeLongToInt(newScale)); } return new BigDecimal(getUnscaledValue(), safeLongToInt(newScale)); }
/** * Returns a new {@code BigDecimal} whose value is {@code this<sup>n</sup>}. The * scale of the result is {@code n * this.scale()}. * * <p>{@code x.pow(0)} returns {@code 1}, even if {@code x == 0}. * * <p>Implementation Note: The implementation is based on the ANSI standard * X3.274-1996 algorithm. * * @throws ArithmeticException * if {@code n < 0} or {@code n > 999999999}. */ public BigDecimal pow(int n) { if (n == 0) { return ONE; } if ((n < 0) || (n > 999999999)) { throw new ArithmeticException("Invalid operation"); } 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), safeLongToInt(newScale)); }
private BigDecimal movePoint(long newScale) { if (isZero()) { return zeroScaledBy(Math.max(newScale, 0)); } /* * When: 'n'== Integer.MIN_VALUE isn't possible to call to * movePointRight(-n) since -Integer.MIN_VALUE == Integer.MIN_VALUE */ if(newScale >= 0) { if(bitLength < 64) { return valueOf(smallValue, safeLongToInt(newScale)); } return new BigDecimal(getUnscaledValue(), safeLongToInt(newScale)); } if(-newScale < MathUtils.LONG_POWERS_OF_TEN.length && bitLength + LONG_POWERS_OF_TEN_BIT_LENGTH[(int)-newScale] < 64 ) { return valueOf(smallValue*MathUtils.LONG_POWERS_OF_TEN[(int)-newScale],0); } return new BigDecimal(Multiplication.multiplyByTenPow( getUnscaledValue(), safeLongToInt(-newScale)), 0); }
/** * 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. * * @param multiplicand * value to be multiplied with {@code this}. * @return {@code this * multiplicand}. * @throws NullPointerException * if {@code multiplicand == null}. */ 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, safeLongToInt(newScale)); } return new BigDecimal(this.getUnscaledValue().multiply( multiplicand.getUnscaledValue()), safeLongToInt(newScale)); }
return zeroScaledBy(diffScale);
return zeroScaledBy(diffScale);
? zeroScaledBy(newScale) : new BigDecimal(integralValue, safeLongToInt(newScale)));
/** * Returns a new {@code BigDecimal} whose value is {@code this * 10<sup>n</sup>}. * The scale of the result is {@code this.scale()} - {@code n}. * The precision of the result is the precision of {@code this}. * * <p>This method has the same effect as {@link #movePointRight}, except that * the precision is not changed. */ 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, safeLongToInt(newScale)); } return new BigDecimal(getUnscaledValue(), safeLongToInt(newScale)); }
/** * Returns a new {@code BigDecimal} whose value is {@code this * 10<sup>n</sup>}. * The scale of the result is {@code this.scale()} - {@code n}. * The precision of the result is the precision of {@code this}. * * <p>This method has the same effect as {@link #movePointRight}, except that * the precision is not changed. */ 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, safeLongToInt(newScale)); } return new BigDecimal(getUnscaledValue(), safeLongToInt(newScale)); }
/** * Returns a new {@code BigDecimal} whose value is {@code this * 10<sup>n</sup>}. * The scale of the result is {@code this.scale()} - {@code n}. * The precision of the result is the precision of {@code this}. * * <p>This method has the same effect as {@link #movePointRight}, except that * the precision is not changed. */ 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, safeLongToInt(newScale)); } return new BigDecimal(getUnscaledValue(), safeLongToInt(newScale)); }
/** * Returns a new {@code BigDecimal} whose value is {@code this * 10<sup>n</sup>}. * The scale of the result is {@code this.scale()} - {@code n}. * The precision of the result is the precision of {@code this}. * * <p>This method has the same effect as {@link #movePointRight}, except that * the precision is not changed. */ 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, safeLongToInt(newScale)); } return new BigDecimal(getUnscaledValue(), safeLongToInt(newScale)); }
/** * Returns a new {@code BigDecimal} whose value is {@code this * 10<sup>n</sup>}. * The scale of the result is {@code this.scale()} - {@code n}. * The precision of the result is the precision of {@code this}. * * <p>This method has the same effect as {@link #movePointRight}, except that * the precision is not changed. */ 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, safeLongToInt(newScale)); } return new BigDecimal(getUnscaledValue(), safeLongToInt(newScale)); }
/** * Returns a new {@code BigDecimal} whose value is {@code this * 10<sup>n</sup>}. * The scale of the result is {@code this.scale()} - {@code n}. * The precision of the result is the precision of {@code this}. * * <p>This method has the same effect as {@link #movePointRight}, except that * the precision is not changed. */ 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, safeLongToInt(newScale)); } return new BigDecimal(getUnscaledValue(), safeLongToInt(newScale)); }
private BigDecimal movePoint(long newScale) { if (isZero()) { return zeroScaledBy(Math.max(newScale, 0)); } /* * When: 'n'== Integer.MIN_VALUE isn't possible to call to * movePointRight(-n) since -Integer.MIN_VALUE == Integer.MIN_VALUE */ if(newScale >= 0) { if(bitLength < 64) { return valueOf(smallValue, safeLongToInt(newScale)); } return new BigDecimal(getUnscaledValue(), safeLongToInt(newScale)); } if(-newScale < MathUtils.LONG_POWERS_OF_TEN.length && bitLength + LONG_POWERS_OF_TEN_BIT_LENGTH[(int)-newScale] < 64 ) { return valueOf(smallValue*MathUtils.LONG_POWERS_OF_TEN[(int)-newScale],0); } return new BigDecimal(Multiplication.multiplyByTenPow( getUnscaledValue(), safeLongToInt(-newScale)), 0); }
private BigDecimal movePoint(long newScale) { if (isZero()) { return zeroScaledBy(Math.max(newScale, 0)); } /* * When: 'n'== Integer.MIN_VALUE isn't possible to call to * movePointRight(-n) since -Integer.MIN_VALUE == Integer.MIN_VALUE */ if(newScale >= 0) { if(bitLength < 64) { return valueOf(smallValue, safeLongToInt(newScale)); } return new BigDecimal(getUnscaledValue(), safeLongToInt(newScale)); } if(-newScale < MathUtils.LONG_POWERS_OF_TEN.length && bitLength + LONG_POWERS_OF_TEN_BIT_LENGTH[(int)-newScale] < 64 ) { return valueOf(smallValue*MathUtils.LONG_POWERS_OF_TEN[(int)-newScale],0); } return new BigDecimal(Multiplication.multiplyByTenPow( getUnscaledValue(), safeLongToInt(-newScale)), 0); }
private BigDecimal movePoint(long newScale) { if (isZero()) { return zeroScaledBy(Math.max(newScale, 0)); } /* * When: 'n'== Integer.MIN_VALUE isn't possible to call to * movePointRight(-n) since -Integer.MIN_VALUE == Integer.MIN_VALUE */ if(newScale >= 0) { if(bitLength < 64) { return valueOf(smallValue, safeLongToInt(newScale)); } return new BigDecimal(getUnscaledValue(), safeLongToInt(newScale)); } if(-newScale < MathUtils.LONG_POWERS_OF_TEN.length && bitLength + LONG_POWERS_OF_TEN_BIT_LENGTH[(int)-newScale] < 64 ) { return valueOf(smallValue*MathUtils.LONG_POWERS_OF_TEN[(int)-newScale],0); } return new BigDecimal(Multiplication.multiplyByTenPow( getUnscaledValue(), safeLongToInt(-newScale)), 0); }
private BigDecimal movePoint(long newScale) { if (isZero()) { return zeroScaledBy(Math.max(newScale, 0)); } /* * When: 'n'== Integer.MIN_VALUE isn't possible to call to * movePointRight(-n) since -Integer.MIN_VALUE == Integer.MIN_VALUE */ if(newScale >= 0) { if(bitLength < 64) { return valueOf(smallValue, safeLongToInt(newScale)); } return new BigDecimal(getUnscaledValue(), safeLongToInt(newScale)); } if(-newScale < MathUtils.LONG_POWERS_OF_TEN.length && bitLength + LONG_POWERS_OF_TEN_BIT_LENGTH[(int)-newScale] < 64 ) { return valueOf(smallValue*MathUtils.LONG_POWERS_OF_TEN[(int)-newScale],0); } return new BigDecimal(Multiplication.multiplyByTenPow( getUnscaledValue(), safeLongToInt(-newScale)), 0); }
private BigDecimal movePoint(long newScale) { if (isZero()) { return zeroScaledBy(Math.max(newScale, 0)); } /* * When: 'n'== Integer.MIN_VALUE isn't possible to call to * movePointRight(-n) since -Integer.MIN_VALUE == Integer.MIN_VALUE */ if(newScale >= 0) { if(bitLength < 64) { return valueOf(smallValue, safeLongToInt(newScale)); } return new BigDecimal(getUnscaledValue(), safeLongToInt(newScale)); } if(-newScale < MathUtils.LONG_POWERS_OF_TEN.length && bitLength + LONG_POWERS_OF_TEN_BIT_LENGTH[(int)-newScale] < 64 ) { return valueOf(smallValue*MathUtils.LONG_POWERS_OF_TEN[(int)-newScale],0); } return new BigDecimal(Multiplication.multiplyByTenPow( getUnscaledValue(), safeLongToInt(-newScale)), 0); }
private BigDecimal movePoint(long newScale) { if (isZero()) { return zeroScaledBy(Math.max(newScale, 0)); } /* * When: 'n'== Integer.MIN_VALUE isn't possible to call to * movePointRight(-n) since -Integer.MIN_VALUE == Integer.MIN_VALUE */ if(newScale >= 0) { if(bitLength < 64) { return valueOf(smallValue, safeLongToInt(newScale)); } return new BigDecimal(getUnscaledValue(), safeLongToInt(newScale)); } if(-newScale < MathUtils.LONG_POWERS_OF_TEN.length && bitLength + LONG_POWERS_OF_TEN_BIT_LENGTH[(int)-newScale] < 64 ) { return valueOf(smallValue*MathUtils.LONG_POWERS_OF_TEN[(int)-newScale],0); } return new BigDecimal(Multiplication.multiplyByTenPow( getUnscaledValue(), safeLongToInt(-newScale)), 0); }
/** * 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. * * @param multiplicand * value to be multiplied with {@code this}. * @return {@code this * multiplicand}. * @throws NullPointerException * if {@code multiplicand == null}. */ 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, safeLongToInt(newScale)); } return new BigDecimal(this.getUnscaledValue().multiply( multiplicand.getUnscaledValue()), safeLongToInt(newScale)); }