/// <summary> /// Computes the absolute value of the given <see cref="BigInteger"/> /// </summary> /// <returns> /// Returns an instance of <see cref="BigInteger"/> that represents the /// absolute value of this instance. /// </returns> public static BigInteger Abs(BigInteger value) { return(BigIntegerMath.Abs(value)); }
/// <summary> /// /// </summary> /// <param name="value"></param> /// <param name="n"></param> /// <remarks> /// <para> /// The result is equivalent to <c>value * 2^n</c> if n is greater /// than or equal to 0. /// The shift distance may be negative which means that <paramref name="value"/> is /// shifted right.The result then corresponds to <c>floor(value / 2 ^ (-n))</c>. /// </para> /// <para> /// <strong>Note:</strong> Usage of this method on negative values is not recommended /// as the current implementation is not efficient. /// </para> /// </remarks> /// <returns></returns> public static BigInteger ShiftLeft(BigInteger value, int n) { return(BigIntegerMath.ShiftLeft(value, n)); }
/** * Returns a new {@code BigInteger} whose value is greatest common divisor * of {@code this} and {@code val}. If {@code this==0} and {@code val==0} * then zero is returned, otherwise the result is positive. * * @param val * value with which the greatest common divisor is computed. * @return {@code gcd(this, val)}. * @throws NullPointerException * if {@code val == null}. */ public static BigInteger Gcd(BigInteger a, BigInteger b) { return(BigIntegerMath.Gcd(a, b)); }
/** * Returns a new {@code BigInteger} whose value is {@code this^exponent mod * m}. The modulus {@code m} must be positive. The result is guaranteed to * be in the interval {@code [0, m)} (0 inclusive, m exclusive). If the * exponent is negative, then {@code this.modInverse(m)^(-exponent) mod m)} * is computed. The inverse of this only exists if {@code this} is * relatively prime to m, otherwise an exception is thrown. * * @param exponent * the exponent. * @param m * the modulus. * @return {@code this^exponent mod val}. * @throws NullPointerException * if {@code m == null} or {@code exponent == null}. * @throws ArithmeticException * if {@code m < 0} or if {@code exponent<0} and this is not * relatively prime to {@code m}. */ public static BigInteger ModPow(BigInteger value, BigInteger exponent, BigInteger m) { return(BigIntegerMath.ModPow(value, exponent, m)); }
/** * Returns a new {@code BigInteger} whose value is {@code this ^ exp}. * * @param exp * exponent to which {@code this} is raised. * @return {@code this ^ exp}. * @throws ArithmeticException * if {@code exp < 0}. */ public static BigInteger Pow(BigInteger value, int exp) { return(BigIntegerMath.Pow(value, exp)); }
/** * Returns a new {@code BigInteger} whose value is {@code 1/this mod m}. The * modulus {@code m} must be positive. The result is guaranteed to be in the * interval {@code [0, m)} (0 inclusive, m exclusive). If {@code this} is * not relatively prime to m, then an exception is thrown. * * @param m * the modulus. * @return {@code 1/this mod m}. * @throws NullPointerException * if {@code m == null} * @throws ArithmeticException * if {@code m < 0 or} if {@code this} is not relatively prime * to {@code m} */ public static BigInteger ModInverse(BigInteger value, BigInteger m) { return(BigIntegerMath.ModInverse(value, m)); }
/** * Returns a {@code BigInteger} array which contains {@code this / divisor} * at index 0 and {@code this % divisor} at index 1. * * @param divisor * value by which {@code this} is divided. * @return {@code [this / divisor, this % divisor]}. * @throws NullPointerException * if {@code divisor == null}. * @throws ArithmeticException * if {@code divisor == 0}. * @see #divide * @see #remainder */ public static BigInteger DivideAndRemainder(BigInteger dividend, BigInteger divisor, out BigInteger remainder) { return(BigIntegerMath.DivideAndRemainder(dividend, divisor, out remainder)); }
/** * Returns a new {@code BigInteger} whose value is {@code this % divisor}. * Regarding signs this methods has the same behavior as the % operator on * int's, i.e. the sign of the remainder is the same as the sign of this. * * @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}. */ public static BigInteger Remainder(BigInteger dividend, BigInteger divisor) { return(BigIntegerMath.Remainder(dividend, divisor)); }
/** * Returns a new {@code BigInteger} whose value is {@code this / divisor}. * * @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}. */ public static BigInteger Divide(BigInteger dividend, BigInteger divisor) { return(BigIntegerMath.Divide(dividend, divisor)); }
/// <summary> /// Computes the negation of this <see cref="BigInteger"/>. /// </summary> /// <returns> /// Returns an instance of <see cref="BigInteger"/> that is the negated value /// of this instance. /// </returns> public static BigInteger Negate(BigInteger value) { return(BigIntegerMath.Negate(value)); }