Java Code Examples for java.math.BigInteger#gcd()

The following examples show how to use java.math.BigInteger#gcd() . These examples are extracted from open source projects. You can vote up the ones you like or vote down the ones you don't like, and go to the original project or source file by following the links above each example. You may check out the related API usage on the sidebar.
Example 1
```public static Number divide(BigInteger n, BigInteger d) {
if (d.equals(ZERO)) {
throw new ArithmeticException("Divide by zero");
}

BigInteger gcd = n.gcd(d);

if (gcd.equals(ZERO)) {
return 0;
}

n = n.divide(gcd);
d = d.divide(gcd);

if (d.equals(BigInteger.ONE)) {
return reduce(n);
}

if (d.equals(BigInteger.ONE.negate())) {
return reduce(n.negate());
}

return new Ratio((d.signum() < 0 ? n.negate() : n), (d.signum() < 0 ? d.negate() : d));
}
```
Example 2
```/**
* gcd: the first number is zero
*/
public void testGcdFirstZero() {
byte aBytes[] = {0};
byte bBytes[] = {15, 24, 123, 57, -15, 24, 123, 57, -15, 24, 123, 57};
int aSign = 1;
int bSign = 1;
byte rBytes[] = {15, 24, 123, 57, -15, 24, 123, 57, -15, 24, 123, 57};
BigInteger aNumber = new BigInteger(aSign, aBytes);
BigInteger bNumber = new BigInteger(bSign, bBytes);
BigInteger result = aNumber.gcd(bNumber);
byte resBytes[] = new byte[rBytes.length];
resBytes = result.toByteArray();
for(int i = 0; i < resBytes.length; i++) {
assertTrue(resBytes[i] == rBytes[i]);
}
assertEquals("incorrect sign", 1, result.signum());
}
```
Example 3
```/**
* Private constructor: Instances are created using factory methods.
*
* <p>This constructor should only be invoked when the fraction is known
* to be non-zero; otherwise use {@link #ZERO}. This avoids creating
* the zero representation {@code 0 / -1}.
*
* @param num Numerator, must not be {@code null}.
* @param den Denominator, must not be {@code null}.
* @throws ArithmeticException if the denominator is zero.
*/
private BigFraction(BigInteger num, BigInteger den) {
if (den.signum() == 0) {
throw new FractionException(FractionException.ERROR_ZERO_DENOMINATOR);
}

// reduce numerator and denominator by greatest common denominator
final BigInteger gcd = num.gcd(den);
if (BigInteger.ONE.compareTo(gcd) < 0) {
numerator = num.divide(gcd);
denominator = den.divide(gcd);
} else {
numerator = num;
denominator = den;
}
}
```
Example 4
```/**
* Original implementation.  Wrong.
*/
public static List<Trial> createList2(final BigInteger original,
final BigInteger divideby,
final BigInteger useModulus)
{
List<Trial> list =  new ArrayList<Trial>();

BigInteger gcd = original.gcd(divideby);
if ((gcd != null) &&
(gcd.compareTo(BigInteger.ONE) > 0))
{
BigInteger divO = original.divide(gcd);
BigInteger divD = divideby.divide(gcd);
}
return list;
}
```
Example 5
```/**
* Create a {@link BigFraction} given the numerator and denominator as
* {@code BigInteger}. The {@link BigFraction} is reduced to lowest terms.
*
* @param num the numerator, must not be {@code null}.
* @param den the denominator, must not be {@code null}..
* @throws ArithmeticException if the denominator is zero.
*/
public BigFraction(BigInteger num, BigInteger den) {
if (num == null) {
throw new NullArgumentException(LocalizedFormats.NUMERATOR);
}
if (den == null) {
throw new NullArgumentException(LocalizedFormats.DENOMINATOR);
}
if (BigInteger.ZERO.equals(den)) {
throw MathRuntimeException.createArithmeticException(LocalizedFormats.ZERO_DENOMINATOR);
}
if (BigInteger.ZERO.equals(num)) {
numerator   = BigInteger.ZERO;
denominator = BigInteger.ONE;
} else {

// reduce numerator and denominator by greatest common denominator
final BigInteger gcd = num.gcd(den);
if (BigInteger.ONE.compareTo(gcd) < 0) {
num = num.divide(gcd);
den = den.divide(gcd);
}

// move sign to numerator
if (BigInteger.ZERO.compareTo(den) > 0) {
num = num.negate();
den = den.negate();
}

// store the values in the final fields
numerator   = num;
denominator = den;

}
}
```
Example 6
```/**
* Create a {@link BigFraction} given the numerator and denominator as
* {@code BigInteger}. The {@link BigFraction} is reduced to lowest terms.
*
* @param num the numerator, must not be {@code null}.
* @param den the denominator, must not be {@code null}.
* @throws ZeroException if the denominator is zero.
* @throws NullArgumentException if either of the arguments is null
*/
public BigFraction(BigInteger num, BigInteger den) {
MathUtils.checkNotNull(num, LocalizedFormats.NUMERATOR);
MathUtils.checkNotNull(den, LocalizedFormats.DENOMINATOR);
if (BigInteger.ZERO.equals(den)) {
throw new ZeroException(LocalizedFormats.ZERO_DENOMINATOR);
}
if (BigInteger.ZERO.equals(num)) {
numerator   = BigInteger.ZERO;
denominator = BigInteger.ONE;
} else {

// reduce numerator and denominator by greatest common denominator
final BigInteger gcd = num.gcd(den);
if (BigInteger.ONE.compareTo(gcd) < 0) {
num = num.divide(gcd);
den = den.divide(gcd);
}

// move sign to numerator
if (BigInteger.ZERO.compareTo(den) > 0) {
num = num.negate();
den = den.negate();
}

// store the values in the final fields
numerator   = num;
denominator = den;

}
}
```
Example 7
```/**
* <p>
* Create a {@link BigFraction} given the numerator and denominator as
* <code>BigInteger</code>. The {@link BigFraction} is reduced to lowest terms.
* </p>
*
* @param num
*            the numerator, must not be <code>null</code>.
* @param den
*            the denominator, must not be <code>null</code>.
* @throws ArithmeticException
*             if the denominator is <code>zero</code>.
* @throws NullPointerException
*             if the numerator or the denominator is <code>zero</code>.
*/
public BigFraction(BigInteger num, BigInteger den) {
if (num == null) {
throw MathRuntimeException.createNullPointerException("numerator is null");
}
if (den == null) {
throw MathRuntimeException.createNullPointerException("denominator is null");
}
if (BigInteger.ZERO.equals(den)) {
throw MathRuntimeException.createArithmeticException("denominator must be different from 0");
}
if (BigInteger.ZERO.equals(num)) {
numerator   = BigInteger.ZERO;
denominator = BigInteger.ONE;
} else {

// reduce numerator and denominator by greatest common denominator
final BigInteger gcd = num.gcd(den);
if (BigInteger.ONE.compareTo(gcd) < 0) {
num = num.divide(gcd);
den = den.divide(gcd);
}

// move sign to numerator
if (BigInteger.ZERO.compareTo(den) > 0) {
num = num.negate();
den = den.negate();
}

// store the values in the final fields
numerator   = num;
denominator = den;

}
}
```
Example 8
```/**
* Computation of the least common multiple of a set of BigIntegers.
*
* @param numbers - the set of numbers
* @return the lcm(numbers)
*/
public static BigInteger leastCommonMultiple(BigInteger[] numbers)
{
int n = numbers.length;
BigInteger result = numbers[0];
for (int i = 1; i < n; i++)
{
BigInteger gcd = result.gcd(numbers[i]);
result = result.multiply(numbers[i]).divide(gcd);
}
return result;
}
```
Example 9
```private BigDecimal calculateBuyIncrement(Order order, DBSet db)
{
BigInteger multiplier = BigInteger.valueOf(100000000l);

//CALCULATE THE MINIMUM INCREMENT AT WHICH I CAN BUY USING GCD
BigInteger haveAmount = BigInteger.ONE.multiply(multiplier);
BigInteger priceAmount = order.getPrice().multiply(new BigDecimal(multiplier)).toBigInteger();
BigInteger gcd = haveAmount.gcd(priceAmount);
haveAmount = haveAmount.divide(gcd);
priceAmount = priceAmount.divide(gcd);

//CALCULATE GCD IN COMBINATION WITH DIVISIBILITY
if(this.getWantAsset(db).isDivisible())
{
haveAmount = haveAmount.multiply(multiplier);
}
if(this.getHaveAsset(db).isDivisible())
{
priceAmount = priceAmount.multiply(multiplier);
}
gcd = haveAmount.gcd(priceAmount);

//CALCULATE THE INCREMENT AT WHICH WE HAVE TO BUY
BigDecimal increment = new BigDecimal(haveAmount.divide(gcd));
if(this.getWantAsset(db).isDivisible())
{
increment = increment.divide(new BigDecimal(multiplier));
}

//RETURN
return increment;
}
```
Example 10
```/**
* Create a {@link BigFraction} given the numerator and denominator as
* {@code BigInteger}. The {@link BigFraction} is reduced to lowest terms.
*
* @param num the numerator, must not be {@code null}.
* @param den the denominator, must not be {@code null}.
* @throws ArithmeticException if the denominator is zero.
* @throws NullArgumentException if either of the arguments is null
*/
public BigFraction(BigInteger num, BigInteger den) {
if (num == null) {
throw new NullArgumentException(LocalizedFormats.NUMERATOR);
}
if (den == null) {
throw new NullArgumentException(LocalizedFormats.DENOMINATOR);
}
if (BigInteger.ZERO.equals(den)) {
throw MathRuntimeException.createArithmeticException(LocalizedFormats.ZERO_DENOMINATOR);
}
if (BigInteger.ZERO.equals(num)) {
numerator   = BigInteger.ZERO;
denominator = BigInteger.ONE;
} else {

// reduce numerator and denominator by greatest common denominator
final BigInteger gcd = num.gcd(den);
if (BigInteger.ONE.compareTo(gcd) < 0) {
num = num.divide(gcd);
den = den.divide(gcd);
}

// move sign to numerator
if (BigInteger.ZERO.compareTo(den) > 0) {
num = num.negate();
den = den.negate();
}

// store the values in the final fields
numerator   = num;
denominator = den;

}
}
```
Example 11
```/**
* Compute the gcd of two rationals (this and other). The gcd is the rational number, such that dividing this and
* other with the gcd will yield two co-prime integers.
*
* @param other
*            the second rational argument.
* @return the gcd of this and other.
*/
public IFraction gcd(IFraction other) {
if (other.isZero()) {
return this;
}
BigInteger tdenom = this.toBigDenominator();
BigInteger odenom = other.toBigDenominator();
BigInteger gcddenom = tdenom.gcd(odenom);
BigInteger denom = tdenom.divide(gcddenom).multiply(odenom);
BigInteger num = toBigNumerator().gcd(other.toBigNumerator());
return AbstractFractionSym.valueOf(num, denom);
}
```
Example 12
```/**
* <p>
* Create a {@link BigFraction} given the numerator and denominator as
* <code>BigInteger</code>. The {@link BigFraction} is reduced to lowest terms.
* </p>
*
* @param num
*            the numerator, must not be <code>null</code>.
* @param den
*            the denominator, must not be <code>null</code>.
* @throws ArithmeticException
*             if the denominator is <code>zero</code>.
* @throws NullPointerException
*             if the numerator or the denominator is <code>zero</code>.
*/
public BigFraction(BigInteger num, BigInteger den) {
if (num == null) {
throw MathRuntimeException.createNullPointerException("numerator is null");
}
if (den == null) {
throw MathRuntimeException.createNullPointerException("denominator is null");
}
if (BigInteger.ZERO.equals(den)) {
throw MathRuntimeException.createArithmeticException(FORBIDDEN_ZERO_DENOMINATOR);
}
if (BigInteger.ZERO.equals(num)) {
numerator   = BigInteger.ZERO;
denominator = BigInteger.ONE;
} else {

// reduce numerator and denominator by greatest common denominator
final BigInteger gcd = num.gcd(den);
if (BigInteger.ONE.compareTo(gcd) < 0) {
num = num.divide(gcd);
den = den.divide(gcd);
}

// move sign to numerator
if (BigInteger.ZERO.compareTo(den) > 0) {
num = num.negate();
den = den.negate();
}

// store the values in the final fields
numerator   = num;
denominator = den;

}
}
```
Example 13
```/**
* Create a {@link BigFraction} given the numerator and denominator as
* {@code BigInteger}. The {@link BigFraction} is reduced to lowest terms.
*
* @param num the numerator, must not be {@code null}.
* @param den the denominator, must not be {@code null}.
* @throws ZeroException if the denominator is zero.
* @throws NullArgumentException if either of the arguments is null
*/
public BigFraction(BigInteger num, BigInteger den) {
MathUtils.checkNotNull(num, LocalizedFormats.NUMERATOR);
MathUtils.checkNotNull(den, LocalizedFormats.DENOMINATOR);
if (BigInteger.ZERO.equals(den)) {
throw new ZeroException(LocalizedFormats.ZERO_DENOMINATOR);
}
if (BigInteger.ZERO.equals(num)) {
numerator   = BigInteger.ZERO;
denominator = BigInteger.ONE;
} else {

// reduce numerator and denominator by greatest common denominator
final BigInteger gcd = num.gcd(den);
if (BigInteger.ONE.compareTo(gcd) < 0) {
num = num.divide(gcd);
den = den.divide(gcd);
}

// move sign to numerator
if (BigInteger.ZERO.compareTo(den) > 0) {
num = num.negate();
den = den.negate();
}

// store the values in the final fields
numerator   = num;
denominator = den;

}
}
```
Example 14
```/**
* Create a {@link BigFraction} given the numerator and denominator as
* {@code BigInteger}. The {@link BigFraction} is reduced to lowest terms.
*
* @param num the numerator, must not be {@code null}.
* @param den the denominator, must not be {@code null}.
* @throws MathIllegalArgumentException if the denominator is zero.
* @throws NullArgumentException if either of the arguments is null
*/
public BigFraction(BigInteger num, BigInteger den) {
MathUtils.checkNotNull(num, LocalizedCoreFormats.NUMERATOR);
MathUtils.checkNotNull(den, LocalizedCoreFormats.DENOMINATOR);
if (den.signum() == 0) {
throw new MathIllegalArgumentException(LocalizedCoreFormats.ZERO_DENOMINATOR);
}
if (num.signum() == 0) {
numerator   = BigInteger.ZERO;
denominator = BigInteger.ONE;
} else {

// reduce numerator and denominator by greatest common denominator
final BigInteger gcd = num.gcd(den);
if (BigInteger.ONE.compareTo(gcd) < 0) {
num = num.divide(gcd);
den = den.divide(gcd);
}

// move sign to numerator
if (den.signum() == -1) {
num = num.negate();
den = den.negate();
}

// store the values in the final fields
numerator   = num;
denominator = den;

}
}
```
Example 15
```/**
* <p>
* Create a {@link BigFraction} given the numerator and denominator as
* <code>BigInteger</code>. The {@link BigFraction} is reduced to lowest terms.
* </p>
*
* @param num
*            the numerator, must not be <code>null</code>.
* @param den
*            the denominator, must not be <code>null</code>.
* @throws ArithmeticException
*             if the denominator is <code>zero</code>.
* @throws NullPointerException
*             if the numerator or the denominator is <code>zero</code>.
*/
public BigFraction(BigInteger num, BigInteger den) {
if (num == null) {
throw MathRuntimeException.createNullPointerException("numerator is null");
}
if (den == null) {
throw MathRuntimeException.createNullPointerException("denominator is null");
}
if (BigInteger.ZERO.equals(den)) {
throw MathRuntimeException.createArithmeticException(FORBIDDEN_ZERO_DENOMINATOR);
}
if (BigInteger.ZERO.equals(num)) {
numerator   = BigInteger.ZERO;
denominator = BigInteger.ONE;
} else {

// reduce numerator and denominator by greatest common denominator
final BigInteger gcd = num.gcd(den);
if (BigInteger.ONE.compareTo(gcd) < 0) {
num = num.divide(gcd);
den = den.divide(gcd);
}

// move sign to numerator
if (BigInteger.ZERO.compareTo(den) > 0) {
num = num.negate();
den = den.negate();
}

// store the values in the final fields
numerator   = num;
denominator = den;

}
}
```
Example 16
```/**
* Create a {@link BigFraction} given the numerator and denominator as
* {@code BigInteger}. The {@link BigFraction} is reduced to lowest terms.
*
* @param num the numerator, must not be {@code null}.
* @param den the denominator, must not be {@code null}.
* @throws ZeroException if the denominator is zero.
* @throws NullArgumentException if either of the arguments is null
*/
public BigFraction(BigInteger num, BigInteger den) {
MathUtils.checkNotNull(num, LocalizedFormats.NUMERATOR);
MathUtils.checkNotNull(den, LocalizedFormats.DENOMINATOR);
if (BigInteger.ZERO.equals(den)) {
throw new ZeroException(LocalizedFormats.ZERO_DENOMINATOR);
}
if (BigInteger.ZERO.equals(num)) {
numerator   = BigInteger.ZERO;
denominator = BigInteger.ONE;
} else {

// reduce numerator and denominator by greatest common denominator
final BigInteger gcd = num.gcd(den);
if (BigInteger.ONE.compareTo(gcd) < 0) {
num = num.divide(gcd);
den = den.divide(gcd);
}

// move sign to numerator
if (BigInteger.ZERO.compareTo(den) > 0) {
num = num.negate();
den = den.negate();
}

// store the values in the final fields
numerator   = num;
denominator = den;

}
}
```
Example 17
```/**
* Create a {@link BigFraction} given the numerator and denominator as
* {@code BigInteger}. The {@link BigFraction} is reduced to lowest terms.
*
* @param num the numerator, must not be {@code null}.
* @param den the denominator, must not be {@code null}.
* @throws ZeroException if the denominator is zero.
* @throws NullArgumentException if either of the arguments is null
*/
public BigFraction(BigInteger num, BigInteger den) {
MathUtils.checkNotNull(num, LocalizedFormats.NUMERATOR);
MathUtils.checkNotNull(den, LocalizedFormats.DENOMINATOR);
if (BigInteger.ZERO.equals(den)) {
throw new ZeroException(LocalizedFormats.ZERO_DENOMINATOR);
}
if (BigInteger.ZERO.equals(num)) {
numerator   = BigInteger.ZERO;
denominator = BigInteger.ONE;
} else {

// reduce numerator and denominator by greatest common denominator
final BigInteger gcd = num.gcd(den);
if (BigInteger.ONE.compareTo(gcd) < 0) {
num = num.divide(gcd);
den = den.divide(gcd);
}

// move sign to numerator
if (BigInteger.ZERO.compareTo(den) > 0) {
num = num.negate();
den = den.negate();
}

// store the values in the final fields
numerator   = num;
denominator = den;

}
}
```
Example 18
```/**
* <p>
* Create a {@link BigFraction} given the numerator and denominator as
* <code>BigInteger</code>. The {@link BigFraction} is reduced to lowest terms.
* </p>
*
* @param num
*            the numerator, must not be <code>null</code>.
* @param den
*            the denominator, must not be <code>null</code>.
* @throws ArithmeticException
*             if the denominator is <code>zero</code>.
* @throws NullPointerException
*             if the numerator or the denominator is <code>zero</code>.
*/
public BigFraction(BigInteger num, BigInteger den) {
if (num == null) {
throw MathRuntimeException.createNullPointerException("numerator is null");
}
if (den == null) {
throw MathRuntimeException.createNullPointerException("denominator is null");
}
if (BigInteger.ZERO.equals(den)) {
throw MathRuntimeException.createArithmeticException(FORBIDDEN_ZERO_DENOMINATOR);
}
if (BigInteger.ZERO.equals(num)) {
numerator   = BigInteger.ZERO;
denominator = BigInteger.ONE;
} else {

// reduce numerator and denominator by greatest common denominator
final BigInteger gcd = num.gcd(den);
if (BigInteger.ONE.compareTo(gcd) < 0) {
num = num.divide(gcd);
den = den.divide(gcd);
}

// move sign to numerator
if (BigInteger.ZERO.compareTo(den) > 0) {
num = num.negate();
den = den.negate();
}

// store the values in the final fields
numerator   = num;
denominator = den;

}
}
```
Example 19
```public static BigInteger gcd(BigInteger bigInteger, BigInteger val) {
```private BigInteger gcd(BigInteger a, BigInteger b) {