BigInteger.abs C# (CSharp) Method

        public BigInteger abs()
        {
                if((this.data[maxLength - 1] & 0x80000000) != 0)
                        return (-this);
                else
                        return (new BigInteger(this));
        }

        /** @see BigInteger#doubleValue() */
        protected internal static double bigInteger2Double(BigInteger val)
        {
            // val.bitLength() < 64
            if ((val.numberLength < 2) ||
                ((val.numberLength == 2) && (val.digits[1] > 0)))
            {
                return(val.longValue());
            }
            // val.bitLength() >= 33 * 32 > 1024
            if (val.numberLength > 32)
            {
                return((val.sign > 0) ? java.lang.Double.POSITIVE_INFINITY
                        : java.lang.Double.NEGATIVE_INFINITY);
            }
            int  bitLen   = val.abs().bitLength();
            long exponent = bitLen - 1;
            int  delta    = bitLen - 54;
            // We need 54 top bits from this, the 53th bit is always 1 in lVal.
            long lVal = val.abs().shiftRight(delta).longValue();

            /*
             * Take 53 bits from lVal to mantissa. The least significant bit is
             * needed for rounding.
             */
            long mantissa = lVal & 0x1FFFFFFFFFFFFFL;

            if (exponent == 1023)
            {
                if (mantissa == 0X1FFFFFFFFFFFFFL)
                {
                    return((val.sign > 0) ? java.lang.Double.POSITIVE_INFINITY
                            : java.lang.Double.NEGATIVE_INFINITY);
                }
                if (mantissa == 0x1FFFFFFFFFFFFEL)
                {
                    return((val.sign > 0) ? java.lang.Double.MAX_VALUE : -java.lang.Double.MAX_VALUE);
                }
            }
            // Round the mantissa
            if (((mantissa & 1) == 1) &&
                (((mantissa & 2) == 2) || BitLevel.nonZeroDroppedBits(delta,
                                                                      val.digits)))
            {
                mantissa += 2;
            }
            mantissa >>= 1; // drop the rounding bit
            long resSign = (long)((val.sign < 0) ? 0x8000000000000000L : 0);

            exponent = ((1023 + exponent) << 52) & 0x7FF0000000000000L;
            long result = resSign | exponent | mantissa;

            return(java.lang.Double.longBitsToDouble(result));
        }