Java BigInteger.signum方法代码示例

import java.math.BigInteger; //导入方法依赖的package包/类
private static void checkValidity(ECField field, BigInteger c,
    String cName) {
    // can only perform check if field is ECFieldFp or ECFieldF2m.
    if (field instanceof ECFieldFp) {
        BigInteger p = ((ECFieldFp)field).getP();
        if (p.compareTo(c) != 1) {
            throw new IllegalArgumentException(cName + " is too large");
        } else if (c.signum() < 0) {
            throw new IllegalArgumentException(cName + " is negative");
        }
    } else if (field instanceof ECFieldF2m) {
        int m = ((ECFieldF2m)field).getM();
        if (c.bitLength() > m) {
            throw new IllegalArgumentException(cName + " is too large");
        }
    }
}
 

import java.math.BigInteger; //导入方法依赖的package包/类
/**
 * Multiplies this <code>ECPoint</code> by the given number.
 * @param k The multiplicator.
 * @return <code>k * this</code>.
 */
public ECPoint multiply(BigInteger k)
{
    if (k.signum() < 0)
    {
        throw new IllegalArgumentException("The multiplicator cannot be negative");
    }

    if (this.isInfinity())
    {
        return this;
    }

    if (k.signum() == 0)
    {
        return this.curve.getInfinity();
    }

    assertECMultiplier();
    return this.multiplier.multiply(this, k, preCompInfo);
}
 

import java.math.BigInteger; //导入方法依赖的package包/类
private static void checkFirstComponent(BigInteger first) throws IOException {
    if (first.signum() == -1 ||
            first.compareTo(BigInteger.valueOf(2)) == 1) {
        throw new IOException("ObjectIdentifier() -- " +
                "First oid component is invalid ");
    }
}
 

import java.math.BigInteger; //导入方法依赖的package包/类
/**
 * Generates values in a distribution equivalent to randomNonNegativeBigInteger
 * but omitting zero.
 */
static BigInteger randomPositiveBigInteger(int numBits) {
  BigInteger result;
  do {
    result = randomNonNegativeBigInteger(numBits);
  } while (result.signum() == 0);
  return result;
}
 

import java.math.BigInteger; //导入方法依赖的package包/类
/**
 * Format a BigInteger to produce a string.
 * @param number    The BigInteger to format
 * @param result    where the text is to be appended
 * @param delegate notified of locations of sub fields
 * @return The formatted number string
 * @exception        ArithmeticException if rounding is needed with rounding
 *                   mode being set to RoundingMode.UNNECESSARY
 * @see java.text.FieldPosition
 */
private StringBuffer format(BigInteger number, StringBuffer result,
                           FieldDelegate delegate, boolean formatLong) {
    if (multiplier != 1) {
        number = number.multiply(getBigIntegerMultiplier());
    }
    boolean isNegative = number.signum() == -1;
    if (isNegative) {
        number = number.negate();
    }

    synchronized(digitList) {
        int maxIntDigits, minIntDigits, maxFraDigits, minFraDigits, maximumDigits;
        if (formatLong) {
            maxIntDigits = super.getMaximumIntegerDigits();
            minIntDigits = super.getMinimumIntegerDigits();
            maxFraDigits = super.getMaximumFractionDigits();
            minFraDigits = super.getMinimumFractionDigits();
            maximumDigits = maxIntDigits + maxFraDigits;
        } else {
            maxIntDigits = getMaximumIntegerDigits();
            minIntDigits = getMinimumIntegerDigits();
            maxFraDigits = getMaximumFractionDigits();
            minFraDigits = getMinimumFractionDigits();
            maximumDigits = maxIntDigits + maxFraDigits;
            if (maximumDigits < 0) {
                maximumDigits = Integer.MAX_VALUE;
            }
        }

        digitList.set(isNegative, number,
                      useExponentialNotation ? maximumDigits : 0);

        return subformat(result, delegate, isNegative, true,
            maxIntDigits, minIntDigits, maxFraDigits, minFraDigits);
    }
}
 

import java.math.BigInteger; //导入方法依赖的package包/类
/**
 * Generate the private key component of the key pair using the
 * provided source of random bits. This method uses the random but
 * source passed to generate a seed and then calls the seed-based
 * generateX method.
 */
private BigInteger generateX(SecureRandom random, BigInteger q) {
    BigInteger x = null;
    byte[] temp = new byte[qlen];
    while (true) {
        random.nextBytes(temp);
        x = new BigInteger(1, temp).mod(q);
        if (x.signum() > 0 && (x.compareTo(q) < 0)) {
            return x;
        }
    }
}
 

import java.math.BigInteger; //导入方法依赖的package包/类
@GwtIncompatible // java.math.BigInteger
public void testIsPowerOfTwo() {
  for (int x : ALL_INTEGER_CANDIDATES) {
    // Checks for a single bit set.
    BigInteger bigX = BigInteger.valueOf(x);
    boolean expected = (bigX.signum() > 0) && (bigX.bitCount() == 1);
    assertEquals(expected, IntMath.isPowerOfTwo(x));
  }
}
 

import java.math.BigInteger; //导入方法依赖的package包/类
/**
 * Return the unsigned value of a BigInteger.
 **/
protected BigInteger toUnsigned (BigInteger b)
{
  if (b != null && b.signum () == -1)
    if (type ().equals ("short"))
      return b.add (twoPow16);
    else if (type ().equals ("long"))
      return b.add (twoPow32);
    else if (type ().equals ("long long"))
      return b.add (twoPow64);
  return b;
}
 

import java.math.BigInteger; //导入方法依赖的package包/类
static BigInteger pair(BigInteger first, BigInteger second) {
	BigInteger a = first.signum() >= 0 ? TWO.multiply(first) : TWO.negate().multiply(first).subtract(ONE);
	BigInteger b = second.signum() >= 0 ? TWO.multiply(second) : TWO.negate().multiply(second).subtract(ONE);
	if (a.compareTo(b) >= 0) {
		return a.multiply(a).add(a).add(b);
	} else {
		return b.multiply(b).add(a);
	}
}
 

import java.math.BigInteger; //导入方法依赖的package包/类
/**
 * <p>Makes sure that the given number is non-negative. If it is not,
 * throw {@link IllegalArgumentException}.</p>
 *
 * @param n Number to test.
 * @param f Field to test.
 */
protected static void testNonNegative(BigInteger n, DatatypeConstants.Field f) {
    if (n != null && n.signum() < 0) {
        throw new IllegalArgumentException(
            DatatypeMessageFormatter.formatMessage(null, "NegativeField", new Object[]{f.toString()})
        );
    }
}
 

import java.math.BigInteger; //导入方法依赖的package包/类
public void testIsPowerOfTwo() {
  for (BigInteger x : ALL_BIGINTEGER_CANDIDATES) {
    // Checks for a single bit set.
    boolean expected = x.signum() > 0 & x.and(x.subtract(ONE)).equals(ZERO);
    assertEquals(expected, BigIntegerMath.isPowerOfTwo(x));
  }
}
 

import java.math.BigInteger; //导入方法依赖的package包/类
/**
 * Returns {@code true} if {@code x} represents a power of two.
 */
public static boolean isPowerOfTwo(BigInteger x) {
  checkNotNull(x);
  return x.signum() > 0 && x.getLowestSetBit() == x.bitLength() - 1;
}
 

import java.math.BigInteger; //导入方法依赖的package包/类
static BigInteger checkPositive(@Nullable String role, BigInteger x) {
  if (x.signum() <= 0) {
    throw new IllegalArgumentException(role + " (" + x + ") must be > 0");
  }
  return x;
}
 

import java.math.BigInteger; //导入方法依赖的package包/类
/**
 *  Check an object for type CHAR and VARCHAR and truncate/pad based on
 *  the  size
 *
 * @param  obj   object to check
 * @param  type  the object type
 * @param  size  size to enforce
 * @param check  throw if too long
 * @return       the altered object if the right type, else the object
 *      passed in unaltered
 * @throws HsqlException if data too long
 */
static Object enforceSize(Object obj, int type, int size, int scale,
                          boolean check) throws HsqlException {

    if (obj == null) {
        return obj;
    }

    if (size == 0 && type != Types.TIMESTAMP) {
        return obj;
    }

    // todo: need to handle BINARY like this as well
    switch (type) {

        case Types.CHAR :
            return checkChar((String) obj, size, check);

        case Types.VARCHAR :
        case Types.VARCHAR_IGNORECASE :
            return checkVarchar((String) obj, size, check);

        case Types.NUMERIC :
        case Types.DECIMAL :
            BigDecimal dec = (BigDecimal) obj;

            dec = dec.setScale(scale, BigDecimal.ROUND_HALF_DOWN);

            BigInteger big  = JavaSystem.getUnscaledValue(dec);
            int        sign = big.signum() == -1 ? 1
                                                 : 0;

            if (big.toString().length() - sign > size) {
                throw Trace.error(Trace.STRING_DATA_TRUNCATION);
            }

            return dec;

        case Types.TIMESTAMP :
            if (size == 6) {
                return obj;
            }

            Timestamp ts       = (Timestamp) obj;
            int       nanos    = ts.getNanos();
            int       divisor  = tenPower[size];
            int       newNanos = (nanos / divisor) * divisor;

            ts.setNanos(newNanos);

            return ts;

        default :
            return obj;
    }
}
 

import java.math.BigInteger; //导入方法依赖的package包/类
static double bigToDouble(BigInteger x) {
  // This is an extremely fast implementation of BigInteger.doubleValue(). JDK patch pending.
  BigInteger absX = x.abs();
  int exponent = absX.bitLength() - 1;
  // exponent == floor(log2(abs(x)))
  if (exponent < Long.SIZE - 1) {
    return x.longValue();
  } else if (exponent > MAX_EXPONENT) {
    return x.signum() * POSITIVE_INFINITY;
  }

  /*
   * We need the top SIGNIFICAND_BITS + 1 bits, including the "implicit" one bit. To make rounding
   * easier, we pick out the top SIGNIFICAND_BITS + 2 bits, so we have one to help us round up or
   * down. twiceSignifFloor will contain the top SIGNIFICAND_BITS + 2 bits, and signifFloor the
   * top SIGNIFICAND_BITS + 1.
   *
   * It helps to consider the real number signif = absX * 2^(SIGNIFICAND_BITS - exponent).
   */
  int shift = exponent - SIGNIFICAND_BITS - 1;
  long twiceSignifFloor = absX.shiftRight(shift).longValue();
  long signifFloor = twiceSignifFloor >> 1;
  signifFloor &= SIGNIFICAND_MASK; // remove the implied bit

  /*
   * We round up if either the fractional part of signif is strictly greater than 0.5 (which is
   * true if the 0.5 bit is set and any lower bit is set), or if the fractional part of signif is
   * >= 0.5 and signifFloor is odd (which is true if both the 0.5 bit and the 1 bit are set).
   */
  boolean increment =
      (twiceSignifFloor & 1) != 0 && ((signifFloor & 1) != 0 || absX.getLowestSetBit() < shift);
  long signifRounded = increment ? signifFloor + 1 : signifFloor;
  long bits = (long) ((exponent + EXPONENT_BIAS)) << SIGNIFICAND_BITS;
  bits += signifRounded;
  /*
   * If signifRounded == 2^53, we'd need to set all of the significand bits to zero and add 1 to
   * the exponent. This is exactly the behavior we get from just adding signifRounded to bits
   * directly. If the exponent is MAX_DOUBLE_EXPONENT, we round up (correctly) to
   * Double.POSITIVE_INFINITY.
   */
  bits |= x.signum() & SIGN_MASK;
  return longBitsToDouble(bits);
}