Java BigInteger.abs方法代码示例

import java.math.BigInteger; //导入方法依赖的package包/类
public ETFWriter writeSmallBig(BigInteger num) {
    if (num.equals(BigInteger.ZERO)) {
        writeToBuffer(SMALL_BIG_EXT, (byte) 0, (byte) 0);
    } else {
        byte signum = num.signum() == -1 ? (byte) 1 : (byte) 0;
        num = num.abs();
        int n = (int) Math.ceil(num.bitLength()/8)+1; //Equivalent to Math.ceil(log256(num)) + 1
        byte[] bytes = new byte[n];
        writeToBuffer(SMALL_BIG_EXT, (byte) (n & 0xFF), signum);
        n -= 1;
        while (n >= 0) {
            BigInteger[] res = num.divideAndRemainder(BigInteger.valueOf(256).pow(n));
            bytes[n] = res[0].byteValue(); //Quotient
            num = res[1]; //Remainder
            n--;
        }
        writeToBuffer(bytes);
    }
    return this;
}
 

import java.math.BigInteger; //导入方法依赖的package包/类
public ETFWriter writeLargeBig(BigInteger num) {
    if (num.equals(BigInteger.ZERO)) {
        writeToBuffer(LARGE_BIG_EXT, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0);
    } else {
        byte signum = num.signum() == -1 ? (byte) 1 : (byte) 0;
        num = num.abs();
        int n = (int) Math.ceil(num.bitLength()/8)+1; //Equivalent to Math.ceil(log256(num)) + 1
        byte[] bytes = new byte[n];
        writeToBuffer(LARGE_BIG_EXT, (byte) ((n >>> 24) & 0xFF), (byte) ((n >>> 16) & 0xFF),
                (byte) ((n >>> 8) & 0xFF), (byte) (n & 0xFF), signum);
        n -= 1;
        while (n >= 0) {
            BigInteger[] res = num.divideAndRemainder(BigInteger.valueOf(256).pow(n));
            bytes[n] = res[0].byteValue(); //Quotient
            num = res[1]; //Remainder
            n--;
        }
        writeToBuffer(bytes);
    }
    return this;
}
 

import java.math.BigInteger; //导入方法依赖的package包/类
public MessagePacker packBigNumber(BigInteger bn) throws IOException {
    byte sign = 0;
    if (bn.compareTo(new BigInteger("0")) < 0) {
        sign = '-';
        bn = bn.abs();
    } else {
        sign = '+';
    }
    byte[] data = Arrays.prepend(bn.toByteArray(), sign);
    this.packExtensionTypeHeader((byte) 0, data.length);
    this.addPayload(data);
    return this;
}
 

import java.math.BigInteger; //导入方法依赖的package包/类
public static void main()throws IOException
{
    BufferedReader dr=new BufferedReader(new InputStreamReader(System.in));
    
    System.out.println("enter the number");
    String n=dr.readLine();
    
    BigInteger a=new BigInteger(n);
    BigInteger b=a.abs();
    
    System.out.println("absolute value is "+b);
}
 

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);
}
 

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);
}
 

import java.math.BigInteger; //导入方法依赖的package包/类
@Override
public BigInteger abs(BigInteger arg) {
    return arg.abs();
}
 

import java.math.BigInteger; //导入方法依赖的package包/类
@Override
public BigInteger intOp() {
    BigInteger bi = args.get(0).valInt();
    return bi.abs();
}
 

import java.math.BigInteger; //导入方法依赖的package包/类
public static BigInteger abs(BigInteger a) { return a.abs(); }