org.bouncycastle.pqc.legacy.math.linearalgebra.BigIntUtils Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of bcprov-jdk15to18 Show documentation
Show all versions of bcprov-jdk15to18 Show documentation
The Bouncy Castle Crypto package is a Java implementation of cryptographic algorithms. This jar contains JCE provider and lightweight API for the Bouncy Castle Cryptography APIs for JDK 1.5 to JDK 1.8.
package org.bouncycastle.pqc.legacy.math.linearalgebra;
import java.math.BigInteger;
/**
* FIXME: is this really necessary?!
*/
public final class BigIntUtils
{
/**
* Default constructor (private).
*/
private BigIntUtils()
{
// empty
}
/**
* Checks if two BigInteger arrays contain the same entries
*
* @param a first BigInteger array
* @param b second BigInteger array
* @return true or false
*/
public static boolean equals(BigInteger[] a, BigInteger[] b)
{
int flag = 0;
if (a.length != b.length)
{
return false;
}
for (int i = 0; i < a.length; i++)
{
// avoid branches here!
// problem: compareTo on BigIntegers is not
// guaranteed constant-time!
flag |= a[i].compareTo(b[i]);
}
return flag == 0;
}
/**
* Fill the given BigInteger array with the given value.
*
* @param array the array
* @param value the value
*/
public static void fill(BigInteger[] array, BigInteger value)
{
for (int i = array.length - 1; i >= 0; i--)
{
array[i] = value;
}
}
/**
* Generates a subarray of a given BigInteger array.
*
* @param input -
* the input BigInteger array
* @param start -
* the start index
* @param end -
* the end index
* @return a subarray of input, ranging from start to
* end
*/
public static BigInteger[] subArray(BigInteger[] input, int start, int end)
{
BigInteger[] result = new BigInteger[end - start];
System.arraycopy(input, start, result, 0, end - start);
return result;
}
/**
* Converts a BigInteger array into an integer array
*
* @param input -
* the BigInteger array
* @return the integer array
*/
public static int[] toIntArray(BigInteger[] input)
{
int[] result = new int[input.length];
for (int i = 0; i < input.length; i++)
{
result[i] = input[i].intValue();
}
return result;
}
/**
* Converts a BigInteger array into an integer array, reducing all
* BigIntegers mod q.
*
* @param q -
* the modulus
* @param input -
* the BigInteger array
* @return the integer array
*/
public static int[] toIntArrayModQ(int q, BigInteger[] input)
{
BigInteger bq = BigInteger.valueOf(q);
int[] result = new int[input.length];
for (int i = 0; i < input.length; i++)
{
result[i] = input[i].mod(bq).intValue();
}
return result;
}
/**
* Return the value of big as a byte array. Although BigInteger
* has such a method, it uses an extra bit to indicate the sign of the
* number. For elliptic curve cryptography, the numbers usually are
* positive. Thus, this helper method returns a byte array of minimal
* length, ignoring the sign of the number.
*
* @param value the BigInteger value to be converted to a byte
* array
* @return the value big as byte array
*/
public static byte[] toMinimalByteArray(BigInteger value)
{
byte[] valBytes = value.toByteArray();
if ((valBytes.length == 1) || (value.bitLength() & 0x07) != 0)
{
return valBytes;
}
byte[] result = new byte[value.bitLength() >> 3];
System.arraycopy(valBytes, 1, result, 0, result.length);
return result;
}
}