/*

 * Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package java.math;

/**

 * A class used to represent multiprecision integers that makes efficient

 * use of allocated space by allowing a number to occupy only part of

 * an array so that the arrays do not have to be reallocated as often.

 * When performing an operation with many iterations the array used to

 * hold a number is only reallocated when necessary and does not have to

 * be the same size as the number it represents. A mutable number allows

 * calculations to occur on the same number without having to create

 * a new number for every step of the calculation as occurs with

 * BigIntegers.

 *

 * @see     BigInteger

 * @author  Michael McCloskey

 * @author  Timothy Buktu

 * @since   1.3

 */

import static java.math.BigDecimal.INFLATED;

import static java.math.BigInteger.LONG_MASK;

import java.util.Arrays;

class MutableBigInteger {

    /**

     * Holds the magnitude of this MutableBigInteger in big endian order.

     * The magnitude may start at an offset into the value array, and it may

     * end before the length of the value array.

     */

    int[] value;

    /**

     * The number of ints of the value array that are currently used

     * to hold the magnitude of this MutableBigInteger. The magnitude starts

     * at an offset and offset + intLen may be less than value.length.

     */

    int intLen;

    /**

     * The offset into the value array where the magnitude of this

     * MutableBigInteger begins.

     */

    int offset = 0;

    // Constants

    /**

     * MutableBigInteger with one element value array with the value 1. Used by

     * BigDecimal divideAndRound to increment the quotient. Use this constant

     * only when the method is not going to modify this object.

     */

    static final MutableBigInteger ONE = new MutableBigInteger(1);

    /**

     * The minimum {@code intLen} for cancelling powers of two before

     * dividing.

     * If the number of ints is less than this threshold,

     * {@code divideKnuth} does not eliminate common powers of two from

     * the dividend and divisor.

     */

    static final int KNUTH_POW2_THRESH_LEN = 6;

    /**

     * The minimum number of trailing zero ints for cancelling powers of two

     * before dividing.

     * If the dividend and divisor don't share at least this many zero ints

     * at the end, {@code divideKnuth} does not eliminate common powers

     * of two from the dividend and divisor.

     */

    static final int KNUTH_POW2_THRESH_ZEROS = 3;

    // Constructors

    /**

     * The default constructor. An empty MutableBigInteger is created with

     * a one word capacity.

     */

    MutableBigInteger() {

        value = new int[1];

        intLen = 0;

    }

    /**

     * Construct a new MutableBigInteger with a magnitude specified by

     * the int val.

     */

    MutableBigInteger(int val) {

        value = new int[1];

        intLen = 1;

        value[0] = val;

    }

    /**

     * Construct a new MutableBigInteger with the specified value array

     * up to the length of the array supplied.

     */

    MutableBigInteger(int[] val) {

        value = val;

        intLen = val.length;

    }

    /**

     * Construct a new MutableBigInteger with a magnitude equal to the

     * specified BigInteger.

     */

    MutableBigInteger(BigInteger b) {

        intLen = b.mag.length;

        value = Arrays.copyOf(b.mag, intLen);

    }

    /**

     * Construct a new MutableBigInteger with a magnitude equal to the

     * specified MutableBigInteger.

     */

    MutableBigInteger(MutableBigInteger val) {

        intLen = val.intLen;

        value = Arrays.copyOfRange(val.value, val.offset, val.offset + intLen);

    }

    /**

     * Makes this number an {@code n}-int number all of whose bits are ones.

     * Used by Burnikel-Ziegler division.

     * @param n number of ints in the {@code value} array

     * @return a number equal to {@code ((1<<(32*n)))-1}

     */

    private void ones(int n) {

        if (n > value.length)

            value = new int[n];

        Arrays.fill(value, -1);

        offset = 0;

        intLen = n;

    }

    /**

     * Internal helper method to return the magnitude array. The caller is not

     * supposed to modify the returned array.

     */

    private int[] getMagnitudeArray() {

        if (offset > 0 || value.length != intLen)

            return Arrays.copyOfRange(value, offset, offset + intLen);

        return value;

    }

    /**

     * Convert this MutableBigInteger to a long value. The caller has to make

     * sure this MutableBigInteger can be fit into long.

     */

    private long toLong() {

        assert (intLen <= 2) : "this MutableBigInteger exceeds the range of long";

        if (intLen == 0)

            return 0;

        long d = value[offset] & LONG_MASK;

        return (intLen == 2) ? d << 32 | (value[offset + 1] & LONG_MASK) : d;

    }

    /**

     * Convert this MutableBigInteger to a BigInteger object.

     */

    BigInteger toBigInteger(int sign) {

        if (intLen == 0 || sign == 0)

            return BigInteger.ZERO;

        return new BigInteger(getMagnitudeArray(), sign);

    }

    /**

     * Converts this number to a nonnegative {@code BigInteger}.

     */

    BigInteger toBigInteger() {

        normalize();

        return toBigInteger(isZero() ? 0 : 1);

    }

    /**

     * Convert this MutableBigInteger to BigDecimal object with the specified sign

     * and scale.

     */

    BigDecimal toBigDecimal(int sign, int scale) {

        if (intLen == 0 || sign == 0)

            return BigDecimal.zeroValueOf(scale);

        int[] mag = getMagnitudeArray();

        int len = mag.length;

        int d = mag[0];

        // If this MutableBigInteger can't be fit into long, we need to

        // make a BigInteger object for the resultant BigDecimal object.

        if (len > 2 || (d < 0 && len == 2))

            return new BigDecimal(new BigInteger(mag, sign), INFLATED, scale, 0);

        long v = (len == 2) ?

            ((mag[1] & LONG_MASK) | (d & LONG_MASK) << 32) :

            d & LONG_MASK;

        return BigDecimal.valueOf(sign == -1 ? -v : v, scale);

    }

    /**

     * This is for internal use in converting from a MutableBigInteger

     * object into a long value given a specified sign.

     * returns INFLATED if value is not fit into long

     */

    long toCompactValue(int sign) {

        if (intLen == 0 || sign == 0)

            return 0L;

        int[] mag = getMagnitudeArray();

        int len = mag.length;

        int d = mag[0];

        // If this MutableBigInteger can not be fitted into long, we need to

        // make a BigInteger object for the resultant BigDecimal object.

        if (len > 2 || (d < 0 && len == 2))

            return INFLATED;

        long v = (len == 2) ?

            ((mag[1] & LONG_MASK) | (d & LONG_MASK) << 32) :

            d & LONG_MASK;

        return sign == -1 ? -v : v;

    }

    /**

     * Clear out a MutableBigInteger for reuse.

     */

    void clear() {

        offset = intLen = 0;

        for (int index=0, n=value.length; index < n; index++)

            value[index] = 0;

    }

    /**

     * Set a MutableBigInteger to zero, removing its offset.

     */

    void reset() {

        offset = intLen = 0;

    }

    /**

     * Compare the magnitude of two MutableBigIntegers. Returns -1, 0 or 1

     * as this MutableBigInteger is numerically less than, equal to, or

     * greater than <tt>b</tt>.

     */

    final int compare(MutableBigInteger b) {

        int blen = b.intLen;

        if (intLen < blen)

            return -1;

        if (intLen > blen)

           return 1;

        // Add Integer.MIN_VALUE to make the comparison act as unsigned integer

        // comparison.

        int[] bval = b.value;

        for (int i = offset, j = b.offset; i < intLen + offset; i++, j++) {

            int b1 = value[i] + 0x80000000;

            int b2 = bval[j]  + 0x80000000;

            if (b1 < b2)

                return -1;

            if (b1 > b2)

                return 1;

        }

        return 0;

    }

    /**

     * Returns a value equal to what {@code b.leftShift(32*ints); return compare(b);}

     * would return, but doesn't change the value of {@code b}.

     */

    private int compareShifted(MutableBigInteger b, int ints) {

        int blen = b.intLen;

        int alen = intLen - ints;

        if (alen < blen)

            return -1;

        if (alen > blen)

           return 1;

        // Add Integer.MIN_VALUE to make the comparison act as unsigned integer

        // comparison.

        int[] bval = b.value;

        for (int i = offset, j = b.offset; i < alen + offset; i++, j++) {

            int b1 = value[i] + 0x80000000;

            int b2 = bval[j]  + 0x80000000;

            if (b1 < b2)

                return -1;

            if (b1 > b2)

                return 1;

        }

        return 0;

    }

    /**

     * Compare this against half of a MutableBigInteger object (Needed for

     * remainder tests).

     * Assumes no leading unnecessary zeros, which holds for results

     * from divide().

     */

    final int compareHalf(MutableBigInteger b) {

        int blen = b.intLen;

        int len = intLen;

        if (len <= 0)

            return blen <= 0 ? 0 : -1;

        if (len > blen)

            return 1;

        if (len < blen - 1)

            return -1;

        int[] bval = b.value;

        int bstart = 0;

        int carry = 0;

        // Only 2 cases left:len == blen or len == blen - 1

        if (len != blen) { // len == blen - 1

            if (bval[bstart] == 1) {

                ++bstart;

                carry = 0x80000000;

            } else

                return -1;

        }

        // compare values with right-shifted values of b,

        // carrying shifted-out bits across words

        int[] val = value;

        for (int i = offset, j = bstart; i < len + offset;) {

            int bv = bval[j++];

            long hb = ((bv >>> 1) + carry) & LONG_MASK;

            long v = val[i++] & LONG_MASK;

            if (v != hb)

                return v < hb ? -1 : 1;

            carry = (bv & 1) << 31; // carray will be either 0x80000000 or 0

        }

        return carry == 0 ? 0 : -1;

    }

    /**

     * Return the index of the lowest set bit in this MutableBigInteger. If the

     * magnitude of this MutableBigInteger is zero, -1 is returned.

     */

    private final int getLowestSetBit() {

        if (intLen == 0)

            return -1;

        int j, b;

        for (j=intLen-1; (j > 0) && (value[j+offset] == 0); j--)

            ;

        b = value[j+offset];

        if (b == 0)

            return -1;

        return ((intLen-1-j)<<5) + Integer.numberOfTrailingZeros(b);

    }

    /**

     * Return the int in use in this MutableBigInteger at the specified

     * index. This method is not used because it is not inlined on all

     * platforms.

     */

    private final int getInt(int index) {

        return value[offset+index];

    }

    /**

     * Return a long which is equal to the unsigned value of the int in

     * use in this MutableBigInteger at the specified index. This method is

     * not used because it is not inlined on all platforms.

     */

    private final long getLong(int index) {

        return value[offset+index] & LONG_MASK;

    }

    /**

     * Ensure that the MutableBigInteger is in normal form, specifically

     * making sure that there are no leading zeros, and that if the

     * magnitude is zero, then intLen is zero.

     */

    final void normalize() {

        if (intLen == 0) {

            offset = 0;

            return;

        }

        int index = offset;

        if (value[index] != 0)

            return;

        int indexBound = index+intLen;

        do {

            index++;

        } while(index < indexBound && value[index] == 0);

        int numZeros = index - offset;

        intLen -= numZeros;

        offset = (intLen == 0 ?  0 : offset+numZeros);

    }

    /**

     * If this MutableBigInteger cannot hold len words, increase the size

     * of the value array to len words.

     */

    private final void ensureCapacity(int len) {

        if (value.length < len) {

            value = new int[len];

            offset = 0;

            intLen = len;

        }

    }

    /**

     * Convert this MutableBigInteger into an int array with no leading

     * zeros, of a length that is equal to this MutableBigInteger's intLen.

     */

    int[] toIntArray() {

        int[] result = new int[intLen];

        for(int i=0; i < intLen; i++)

            result[i] = value[offset+i];

        return result;

    }

    /**

     * Sets the int at index+offset in this MutableBigInteger to val.

     * This does not get inlined on all platforms so it is not used

     * as often as originally intended.

     */

    void setInt(int index, int val) {

        value[offset + index] = val;

    }

    /**

     * Sets this MutableBigInteger's value array to the specified array.

     * The intLen is set to the specified length.

     */

    void setValue(int[] val, int length) {

        value = val;

        intLen = length;

        offset = 0;

    }

    /**

     * Sets this MutableBigInteger's value array to a copy of the specified

     * array. The intLen is set to the length of the new array.

     */

    void copyValue(MutableBigInteger src) {

        int len = src.intLen;

        if (value.length < len)

            value = new int[len];

        System.arraycopy(src.value, src.offset, value, 0, len);

        intLen = len;

        offset = 0;

    }

    /**

     * Sets this MutableBigInteger's value array to a copy of the specified

     * array. The intLen is set to the length of the specified array.

     */

    void copyValue(int[] val) {

        int len = val.length;

        if (value.length < len)

            value = new int[len];

        System.arraycopy(val, 0, value, 0, len);

        intLen = len;

        offset = 0;

    }

    /**

     * Returns true iff this MutableBigInteger has a value of one.

     */

    boolean isOne() {

        return (intLen == 1) && (value[offset] == 1);

    }

    /**

     * Returns true iff this MutableBigInteger has a value of zero.

     */

    boolean isZero() {

        return (intLen == 0);

    }

    /**

     * Returns true iff this MutableBigInteger is even.

     */

    boolean isEven() {

        return (intLen == 0) || ((value[offset + intLen - 1] & 1) == 0);

    }

    /**

     * Returns true iff this MutableBigInteger is odd.

     */

    boolean isOdd() {

        return isZero() ? false : ((value[offset + intLen - 1] & 1) == 1);

    }

    /**

     * Returns true iff this MutableBigInteger is in normal form. A

     * MutableBigInteger is in normal form if it has no leading zeros

     * after the offset, and intLen + offset <= value.length.

     */

    boolean isNormal() {

        if (intLen + offset > value.length)

            return false;

        if (intLen == 0)