1 files changed, 0 insertions, 138 deletions
diff --git a/core/src/main/java/org/bouncycastle/pqc/math/linearalgebra/BigIntUtils.java b/core/src/main/java/org/bouncycastle/pqc/math/linearalgebra/BigIntUtils.java
deleted file mode 100644
index b99ed41b..00000000
--- a/core/src/main/java/org/bouncycastle/pqc/math/linearalgebra/BigIntUtils.java
+++ /dev/null
@@ -1,138 +0,0 @@
-package org.bouncycastle.pqc.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 <tt>input</tt>, ranging from <tt>start</tt> to
-     *         <tt>end</tt>
-     */
-    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 <tt>big</tt> 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 <tt>BigInteger</tt> value to be converted to a byte
-     *              array
-     * @return the value <tt>big</tt> 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;
-    }
-
-}