/** * 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. * * @param divisor * value by which {@code this} is divided. * @param mc * math context which determines the maximal precision of the * result. * @return {@code [this.divideToIntegralValue(divisor), * this.remainder(divisor)]}. * @throws NullPointerException * if {@code divisor == null}. * @throws ArithmeticException * if {@code divisor == 0}. * @see #divideToIntegralValue * @see #remainder */ public static BigDecimal DivideAndRemainder(BigDecimal a, BigDecimal b, MathContext context, out BigDecimal remainder) { return(BigDecimalMath.DivideAndRemainder(a, b, context, out remainder)); }
/** * Returns a new {@code BigDecimal} instance with the specified scale. * <p> * 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. * <p> * 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. * * @param newScale * scale of the result returned. * @param roundingMode * rounding mode to be used to round the result. * @return a new {@code BigDecimal} instance with the specified scale. * @throws NullPointerException * if {@code roundingMode == null}. * @throws ArithmeticException * if {@code roundingMode == ROUND_UNNECESSARY} and rounding is * necessary according to the given scale. */ public static BigDecimal Scale(BigDecimal number, int newScale, RoundingMode roundingMode) { if (!Enum.IsDefined(typeof(RoundingMode), roundingMode)) { throw new ArgumentException(); } return(BigDecimalMath.Scale(number, newScale, roundingMode)); }
/// <summary> /// Adds a value to the current instance of <see cref="BigDecimal"/>, /// rounding the result according to the provided context. /// </summary> /// <param name="augend">The value to be added to this instance.</param> /// <param name="mc">The rounding mode and precision for the result of /// this operation.</param> /// <returns> /// Returns a new <see cref="BigDecimal"/> whose value is <c>this + <paramref name="augend"/></c>. /// </returns> /// <exception cref="ArgumentNullException"> /// If the given <paramref name="augend"/> or <paramref name="mc"/> is <c>null</c>. /// </exception> public static BigDecimal Add(BigDecimal value, BigDecimal augend, MathContext mc) { return(BigDecimalMath.Add(value, augend, mc)); }
/** * 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. * <p> * 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. * <p> * Note, that {@code movePointRight(0)} returns a result which is * mathematically equivalent, but which has scale >= 0. * * @param n * number of placed the decimal point has to be moved. * @return {@code this * 10^n}. */ public static BigDecimal MovePointRight(BigDecimal number, int n) { return(BigDecimalMath.MovePoint(number, number.Scale - (long)n)); }
/** * Returns a new {@code BigDecimal} whose value is {@code this ^ n}. The * result is rounded according to the passed context {@code mc}. * <p> * Implementation Note: The implementation is based on the ANSI standard * X3.274-1996 algorithm. * * @param n * exponent to which {@code this} is raised. * @param mc * rounding mode and precision for the result of this operation. * @return {@code this ^ n}. * @throws ArithmeticException * if {@code n < 0} or {@code n > 999999999}. */ public static BigDecimal Pow(BigDecimal number, int exp, MathContext context) { return(BigDecimalMath.Pow(number, exp, context)); }
/** * 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}. * <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. * * @param n * exponent to which {@code this} is raised. * @return {@code this ^ n}. * @throws ArithmeticException * if {@code n < 0} or {@code n > 999999999}. */ public static BigDecimal Pow(BigDecimal number, int exp) { return(BigDecimalMath.Pow(number, exp)); }
/** * 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 static BigDecimal Multiply(BigDecimal value, BigDecimal multiplicand) { return(BigDecimalMath.Multiply(value, multiplicand)); }
/** * 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. * * @param divisor * value by which {@code this} is divided. * @param mc * math context which determines the maximal precision of the * result. * @return integral part of {@code this / divisor}. * @throws NullPointerException * if {@code divisor == null} or {@code mc == null}. * @throws ArithmeticException * if {@code divisor == 0}. * @throws ArithmeticException * if {@code mc.getPrecision() > 0} and the result requires more * digits to be represented. */ public static BigDecimal DivideToIntegral(BigDecimal a, BigDecimal b, MathContext context) { return(BigDecimalMath.DivideToIntegralValue(a, b, context)); }
/** * 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)}. * * @param divisor * value by which {@code this} is divided. * @param mc * rounding mode and precision for the result of this operation. * @return {@code this / divisor}. * @throws NullPointerException * if {@code divisor == null} or {@code mc == null}. * @throws ArithmeticException * if {@code divisor == 0}. * @throws ArithmeticException * if {@code mc.getRoundingMode() == UNNECESSARY} and rounding * is necessary according {@code mc.getPrecision()}. */ public static BigDecimal Divide(BigDecimal a, BigDecimal b, MathContext context) { return(BigDecimalMath.Divide(a, b, context)); }
/** * 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}. * * @param divisor * value by which {@code this} is divided. * @return integral part of {@code this / divisor}. * @throws NullPointerException * if {@code divisor == null}. * @throws ArithmeticException * if {@code divisor == 0}. */ public static BigDecimal DivideToIntegral(BigDecimal a, BigDecimal b) { return(BigDecimalMath.DivideToIntegralValue(a, b)); }
/** * 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. * * @param divisor * value by which {@code this} is divided. * @param scale * the scale of the result returned. * @param roundingMode * rounding mode to be used to round the result. * @return {@code this / divisor} rounded according to the given rounding * mode. * @throws NullPointerException * if {@code divisor == null} or {@code roundingMode == null}. * @throws ArithmeticException * if {@code divisor == 0}. * @throws ArithmeticException * if {@code roundingMode == RoundingMode.UNNECESSAR}Y and * rounding is necessary according to the given scale and given * precision. */ public static BigDecimal Divide(BigDecimal a, BigDecimal b, int scale, RoundingMode roundingMode) { return(BigDecimalMath.Divide(a, b, scale, roundingMode)); }
/** * 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}. * * @param divisor * value by which {@code this} is divided. * @return {@code this / divisor}. * @throws NullPointerException * if {@code divisor == null}. * @throws ArithmeticException * if {@code divisor == 0}. * @throws ArithmeticException * if the result cannot be represented exactly. */ public static BigDecimal Divide(BigDecimal a, BigDecimal b) { return(BigDecimalMath.Divide(a, b)); }
/// <summary> /// Subtracts the given value from this instance of <see cref="BigDecimal"/>. /// </summary> /// <remarks> /// <para> /// This overload rounds the result of the operation to the <paramref name="mc">context</paramref> /// provided as argument. /// </para> /// </remarks> /// <param name="subtrahend">The value to be subtracted from this <see cref="BigDecimal"/>.</param> /// <param name="mc">The context used to round the result of this operation.</param> /// <returns> /// Returns an instance of <see cref="BigDecimal"/> that is the result of the /// subtraction of the given <paramref name="subtrahend"/> from this instance. /// </returns> /// <exception cref="ArgumentNullException"> /// If either of the given <paramref name="subtrahend"/> or <paramref name="mc"/> are <c>null</c>. /// </exception> public static BigDecimal Subtract(BigDecimal value, BigDecimal subtrahend, MathContext mc) { return(BigDecimalMath.Subtract(value, subtrahend, mc)); }
/// <summary> /// Subtracts the given value from this instance of <see cref="BigDecimal"/>. /// </summary> /// <remarks> /// </remarks> /// <param name="subtrahend">The value to be subtracted from this <see cref="BigDecimal"/>.</param> /// <returns> /// Returns an instance of <see cref="BigDecimal"/> that is the result of the /// subtraction of the given <paramref name="subtrahend"/> from this instance. /// </returns> /// <exception cref="ArgumentNullException"> /// If the given <paramref name="subtrahend"/> is <c>null</c>. /// </exception> public static BigDecimal Subtract(BigDecimal value, BigDecimal subtrahend) { return(BigDecimalMath.Subtract(value, subtrahend)); }
/// <summary> /// Adds a value to the current instance of <see cref="BigDecimal"/>. /// The scale of the result is the maximum of the scales of the two arguments. /// </summary> /// <param name="augend">The value to be added to this instance.</param> /// <returns> /// Returns a new {@code BigDecimal} whose value is <c>this + <paramref name="augend"/></c>. /// </returns> /// <exception cref="ArgumentNullException"> /// If the given <paramref name="augend"/> is <c>null</c>. /// </exception> public static BigDecimal Add(BigDecimal value, BigDecimal augend) { return(BigDecimalMath.Add(value, augend)); }