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

/**
 * Raise a BigInteger to a BigInteger power.
 *
 * @param k Number to raise.
 * @param e Exponent (must be positive or zero).
 * @return k<sup>e</sup>
 * @throws NotPositiveException if {@code e < 0}.
 */
public static BigInteger pow(final BigInteger k, BigInteger e) {
    if (e.compareTo(BigInteger.ZERO) < 0) {
        throw new NotPositiveException(LocalizedFormats.EXPONENT, e);
    }

    BigInteger result = BigInteger.ONE;
    BigInteger k2p    = k;
    while (!BigInteger.ZERO.equals(e)) {
        if (e.testBit(0)) {
            result = result.multiply(k2p);
        }
        k2p = k2p.multiply(k2p);
        e = e.shiftRight(1);
    }

    return result;
}
 

/**
 * Raise a BigInteger to a BigInteger power.
 * @param k number to raise
 * @param e exponent (must be positive or null)
 * @return k<sup>e</sup>
 * @exception IllegalArgumentException if e is negative
 */
public static BigInteger pow(final BigInteger k, BigInteger e)
    throws IllegalArgumentException {

    if (e.compareTo(BigInteger.ZERO) < 0) {
        throw MathRuntimeException.createIllegalArgumentException(
            "cannot raise an integral value to a negative power ({0}^{1})",
            k, e);
    }

    BigInteger result = BigInteger.ONE;
    BigInteger k2p    = k;
    while (!BigInteger.ZERO.equals(e)) {
        if (e.testBit(0)) {
            result = result.multiply(k2p);
        }
        k2p = k2p.multiply(k2p);
        e = e.shiftRight(1);
    }

    return result;

}
 

private void writeField(
    ByteArrayOutputStream out,
    BigInteger fieldValue)
{
    int byteCount = (fieldValue.bitLength() + 6) / 7;
    if (byteCount == 0)
    {
        out.write(0);
    }
    else
    {
        BigInteger tmpValue = fieldValue;
        byte[] tmp = new byte[byteCount];
        for (int i = byteCount - 1; i >= 0; i--)
        {
            tmp[i] = (byte)((tmpValue.intValue() & 0x7f) | 0x80);
            tmpValue = tmpValue.shiftRight(7);
        }
        tmp[byteCount - 1] &= 0x7f;
        out.write(tmp, 0, tmp.length);
    }
}
 

/**
 * Raise a BigInteger to a BigInteger power.
 * @param k number to raise
 * @param e exponent (must be positive or null)
 * @return k<sup>e</sup>
 * @exception IllegalArgumentException if e is negative
 */
public static BigInteger pow(final BigInteger k, BigInteger e)
    throws IllegalArgumentException {

    if (e.compareTo(BigInteger.ZERO) < 0) {
        throw MathRuntimeException.createIllegalArgumentException(
            LocalizedFormats.POWER_NEGATIVE_PARAMETERS,
            k, e);
    }

    BigInteger result = BigInteger.ONE;
    BigInteger k2p    = k;
    while (!BigInteger.ZERO.equals(e)) {
        if (e.testBit(0)) {
            result = result.multiply(k2p);
        }
        k2p = k2p.multiply(k2p);
        e = e.shiftRight(1);
    }

    return result;

}
 

public IntegerValue(BigInteger bigInteger) throws Exception {
    bigValue = bigInteger;

    if (bigInteger.compareTo(BigInteger.ZERO) < 0) {
        throw new Exception("IntegerValue constructor: Type inference is only allowed for positive constants");
    }

    // Count bits needed to represent integer
    int count = 0;
    while (bigInteger.compareTo(BigInteger.ZERO) != 0) {
        bigInteger = bigInteger.shiftRight(1);
        ++count;
    }

    int byteCount = count / 8;
    if (byteCount == 0 || byteCount * 8 != count) ++byteCount;

    type = TypeContainer.getIntegerType(true, byteCount*8);
}
 

/**
 * Raise a BigInteger to a BigInteger power.
 * @param k number to raise
 * @param e exponent (must be positive or null)
 * @return k<sup>e</sup>
 * @exception IllegalArgumentException if e is negative
 */
public static BigInteger pow(final BigInteger k, BigInteger e)
    throws IllegalArgumentException {

    if (e.compareTo(BigInteger.ZERO) < 0) {
        throw MathRuntimeException.createIllegalArgumentException(
            "cannot raise an integral value to a negative power ({0}^{1})",
            k, e);
    }

    BigInteger result = BigInteger.ONE;
    BigInteger k2p    = k;
    while (!BigInteger.ZERO.equals(e)) {
        if (e.testBit(0)) {
            result = result.multiply(k2p);
        }
        k2p = k2p.multiply(k2p);
        e = e.shiftRight(1);
    }

    return result;

}
 

private void writeField(
    ByteArrayOutputStream out,
    BigInteger fieldValue)
{
    int byteCount = (fieldValue.bitLength() + 6) / 7;
    if (byteCount == 0)
    {
        out.write(0);
    }
    else
    {
        BigInteger tmpValue = fieldValue;
        byte[] tmp = new byte[byteCount];
        for (int i = byteCount - 1; i >= 0; i--)
        {
            tmp[i] = (byte)((tmpValue.intValue() & 0x7f) | 0x80);
            tmpValue = tmpValue.shiftRight(7);
        }
        tmp[byteCount - 1] &= 0x7f;
        out.write(tmp, 0, tmp.length);
    }
}
 

/**
 * Raise a BigInteger to a BigInteger power.
 * @param k number to raise
 * @param e exponent (must be positive or null)
 * @return k<sup>e</sup>
 * @exception IllegalArgumentException if e is negative
 */
public static BigInteger pow(final BigInteger k, BigInteger e)
    throws IllegalArgumentException {

    if (e.compareTo(BigInteger.ZERO) < 0) {
        throw MathRuntimeException.createIllegalArgumentException(
            LocalizedFormats.POWER_NEGATIVE_PARAMETERS,
            k, e);
    }

    BigInteger result = BigInteger.ONE;
    BigInteger k2p    = k;
    while (!BigInteger.ZERO.equals(e)) {
        if (e.testBit(0)) {
            result = result.multiply(k2p);
        }
        k2p = k2p.multiply(k2p);
        e = e.shiftRight(1);
    }

    return result;

}
 

/**
 * Expands a 7-byte array into an 8-byte array that contains parity bits
 * The binary format of a cryptographic key is:
 *     (B1,B2,...,B7,P1,B8,...B14,P2,B15,...,B49,P7,B50,...,B56,P8)
 * where (B1,B2,...,B56) are the independent bits of a DES key and
 * (PI,P2,...,P8) are reserved for parity bits computed on the preceding
 * seven independent bits and set so that the parity of the octet is odd,
 * i.e., there is an odd number of "1" bits in the octet.
 */
private static byte[] addDesParity(byte[] input, int offset, int len) {
    if (len != 7)
        throw new IllegalArgumentException(
            "Invalid length of DES Key Value:" + len);

    byte[] raw = new byte[7];
    System.arraycopy(input, offset, raw, 0, len);

    byte[] result = new byte[8];
    BigInteger in = new BigInteger(raw);

    // Shift 7 bits each time into a byte
    for (int i=result.length-1; i>=0; i--) {
        result[i] = in.and(MASK).toByteArray()[0];
        result[i] <<= 1;         // make room for parity bit
        in = in.shiftRight(7);
    }
    setParityBit(result);
    return result;
}
 

/**
 * Generates a 15-word random seed. This method implements the BIP-39 algorithm with 160 bits of entropy.
 *
 * @return the seed as a String
 */
public static String generateSeed() {
    byte[] bytes = new byte[21];
    new SecureRandom().nextBytes(bytes);
    byte[] rhash = Hash.sha256(bytes, 0, 20);
    bytes[20] = rhash[0];
    BigInteger rand = new BigInteger(bytes);
    BigInteger mask = new BigInteger(new byte[]{0, 0, 7, -1}); // 11 lower bits
    StringBuilder sb = new StringBuilder();
    for (int i = 0; i < 15; i++) {
        sb.append(i > 0 ? ' ' : "")
                .append(SEED_WORDS[rand.and(mask).intValue()]);
        rand = rand.shiftRight(11);
    }
    return sb.toString();
}
 

/**
 * Return a {@link UInt384} containing the specified value.
 *
 * @param value the value to create a {@link UInt384} for
 * @return a {@link UInt384} containing the specified value
 * @throws IllegalArgumentException if the value is negative or too large to be represented as a UInt384
 */
public static UInt384 valueOf(BigInteger value) {
  checkArgument(value.signum() >= 0, "Argument must be positive");
  checkArgument(value.bitLength() <= 384, "Argument is too large to represent a UInt384");
  if (value.compareTo(BI_MAX_CONSTANT) <= 0) {
    return CONSTANTS[value.intValue()];
  }
  int[] ints = new int[INTS_SIZE];
  for (int i = INTS_SIZE - 1; i >= 0; --i) {
    ints[i] = value.intValue();
    value = value.shiftRight(32);
  }
  return new UInt384(ints);
}
 

private BigInteger rot(BigInteger x, int n) {
    n = n % w;

    BigInteger leftShift = getShiftLeft64(x, n);
    BigInteger rightShift = x.shiftRight(w - n);

    return leftShift.or(rightShift);
}
 

BigInteger montgomeryMultiply(BigInteger a, BigInteger b, BigInteger N,
        int len, BigInteger n_prime)
        throws Throwable {
    BigInteger T = a.multiply(b);
    BigInteger R = BigInteger.ONE.shiftLeft(len*32);
    BigInteger mask = R.subtract(BigInteger.ONE);
    BigInteger m = (T.and(mask)).multiply(n_prime);
    m = m.and(mask); // i.e. m.mod(R)
    T = T.add(m.multiply(N));
    T = T.shiftRight(len*32); // i.e. T.divide(R)
    if (T.compareTo(N) > 0) {
        T = T.subtract(N);
    }
    return T;
}
 

protected BigInteger calculateE(BigInteger n, byte[] message)
{
    int log2n = n.bitLength();
    int messageBitLength = message.length * 8;

    BigInteger e = new BigInteger(1, message);
    if (log2n < messageBitLength)
    {
        e = e.shiftRight(messageBitLength - log2n);
    }
    return e;
}
 

/**
 * shiftRight a negative number;
 * shift distance is multiple of 32;
 * shifted bits are zeroes. 
 */
public void testShiftRightNegZeroesMul32() {
    byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 0, 0, 0, 0, 0, 0, 0, 0};
    int aSign = -1;
    int number = 64;
    byte rBytes[] = {-2, 127, -57, -101, 1, 75, -90, -46, -91};
    BigInteger aNumber = new BigInteger(aSign, aBytes);
    BigInteger result = aNumber.shiftRight(number);
    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());
}
 

private static BigInteger calculateE(BigInteger n, byte[] message) {
   if (n.bitLength() > message.length * 8) {
      return new BigInteger(1, message);
   } else {
      int messageBitLength = message.length * 8;
      BigInteger trunc = new BigInteger(1, message);

      if (messageBitLength - n.bitLength() > 0) {
         trunc = trunc.shiftRight(messageBitLength - n.bitLength());
      }

      return trunc;
   }
}
 

public static BigInteger shiftRight(BigInteger p, BigInteger p2, NullPointer nullPointer) {
    if (p == null || p2 == null) {
        nullPointer.setNullValue(true);
        return BigInteger.ZERO;
    }
    nullPointer.setNullValue(false);
    int shift = p2.intValue();
    return shift < Long.SIZE * 8 ? p.shiftRight(shift) : BigInteger.ZERO;
}
 

@Override
public BigInteger evaluateBinary(int sizeout, int sizein, BigInteger in1, BigInteger in2) {

	if (in1.signum() < 0 || in2.signum() < 0) {
		throw new AssertException("Expected unsigned in values");
	}
	BigInteger maxShift = BigInteger.valueOf(sizein * 8);
	if (in2.compareTo(maxShift) >= 0) {
		return BigInteger.ZERO;
	}
	return in1.shiftRight(in2.intValue());
}
 

@Callable
public static BigInteger shiftRight(BigInteger testValue) {
    return testValue.shiftRight(5);
}
 

/**
 * Computes the <code>&tau;</code>-adic NAF (non-adjacent form) of an
 * element <code>&lambda;</code> of <code><b>Z</b>[&tau;]</code>.
 * @param mu The parameter <code>&mu;</code> of the elliptic curve.
 * @param lambda The element <code>&lambda;</code> of
 * <code><b>Z</b>[&tau;]</code>.
 * @return The <code>&tau;</code>-adic NAF of <code>&lambda;</code>.
 */
public static byte[] tauAdicNaf(byte mu, ZTauElement lambda)
{
    if (!((mu == 1) || (mu == -1)))
    {
        throw new IllegalArgumentException("mu must be 1 or -1");
    }
    
    BigInteger norm = norm(mu, lambda);

    // Ceiling of log2 of the norm 
    int log2Norm = norm.bitLength();

    // If length(TNAF) > 30, then length(TNAF) < log2Norm + 3.52
    int maxLength = log2Norm > 30 ? log2Norm + 4 : 34;

    // The array holding the TNAF
    byte[] u = new byte[maxLength];
    int i = 0;

    // The actual length of the TNAF
    int length = 0;

    BigInteger r0 = lambda.u;
    BigInteger r1 = lambda.v;

    while(!((r0.equals(ECConstants.ZERO)) && (r1.equals(ECConstants.ZERO))))
    {
        // If r0 is odd
        if (r0.testBit(0))
        {
            u[i] = (byte) ECConstants.TWO.subtract((r0.subtract(r1.shiftLeft(1))).mod(ECConstants.FOUR)).intValue();

            // r0 = r0 - u[i]
            if (u[i] == 1)
            {
                r0 = r0.clearBit(0);
            }
            else
            {
                // u[i] == -1
                r0 = r0.add(ECConstants.ONE);
            }
            length = i;
        }
        else
        {
            u[i] = 0;
        }

        BigInteger t = r0;
        BigInteger s = r0.shiftRight(1);
        if (mu == 1)
        {
            r0 = r1.add(s);
        }
        else
        {
            // mu == -1
            r0 = r1.subtract(s);
        }

        r1 = t.shiftRight(1).negate();
        i++;
    }

    length++;

    // Reduce the TNAF array to its actual length
    byte[] tnaf = new byte[length];
    System.arraycopy(u, 0, tnaf, 0, length);
    return tnaf;
}