Old snapshot `bigint-2006.02.26'; see the ChangeLog file.

[bigint/bigint.git] / BigUnsigned.cc

/*
* Matt McCutchen's Big Integer Library
* http://hashproduct.metaesthetics.net/bigint/
*/

#include "BigUnsigned.hh"

// The "management" routines that used to be here are now in NumberlikeArray.hh.

/*
* The steps for construction of a BigUnsigned
* from an integral value x are as follows:
* 1. If x is zero, create an empty BigUnsigned and stop.
* 2. If x is negative, throw an exception.
* 3. Allocate a one-block number array.
* 4. If x is of a signed type, convert x to the unsigned
*    type of the same length.
* 5. Expand x to a Blk, and store it in the number array.
*
* Since 2005.01.06, NumberlikeArray uses `NULL' rather
* than a real array if one of zero length is needed.
* These constructors implicitly call NumberlikeArray's
* default constructor, which sets `blk = NULL, cap = len = 0'.
* So if the input number is zero, they can just return.
* See remarks in `NumberlikeArray.hh'.
*/

BigUnsigned::BigUnsigned(unsigned long x) {
	if (x == 0)
		; // NumberlikeArray already did all the work
	else {
		cap = 1;
		blk = new Blk[1];
		len = 1;
		blk[0] = Blk(x);
	}
}

BigUnsigned::BigUnsigned(long x) {
	if (x == 0)
		;
	else if (x > 0) {
		cap = 1;
		blk = new Blk[1];
		len = 1;
		blk[0] = Blk(x);
	} else
	throw "BigUnsigned::BigUnsigned(long): Cannot construct a BigUnsigned from a negative number";
}

BigUnsigned::BigUnsigned(unsigned int x) {
	if (x == 0)
		;
	else {
		cap = 1;
		blk = new Blk[1];
		len = 1;
		blk[0] = Blk(x);
	}
}

BigUnsigned::BigUnsigned(int x) {
	if (x == 0)
		;
	else if (x > 0) {
		cap = 1;
		blk = new Blk[1];
		len = 1;
		blk[0] = Blk(x);
	} else
	throw "BigUnsigned::BigUnsigned(int): Cannot construct a BigUnsigned from a negative number";
}

BigUnsigned::BigUnsigned(unsigned short x) {
	if (x == 0)
		;
	else {
		cap = 1;
		blk = new Blk[1];
		len = 1;
		blk[0] = Blk(x);
	}
}

BigUnsigned::BigUnsigned(short x) {
	if (x == 0)
		;
	else if (x > 0) {
		cap = 1;
		blk = new Blk[1];
		len = 1;
		blk[0] = Blk(x);
	} else
	throw "BigUnsigned::BigUnsigned(short): Cannot construct a BigUnsigned from a negative number";
}

// CONVERTERS
/*
* The steps for conversion of a BigUnsigned to an
* integral type are as follows:
* 1. If the BigUnsigned is zero, return zero.
* 2. If it is more than one block long or its lowest
*    block has bits set out of the range of the target
*    type, throw an exception.
* 3. Otherwise, convert the lowest block to the
*    target type and return it.
*/

namespace {
	// These masks are used to test whether a Blk has bits
	// set out of the range of a smaller integral type.  Note
	// that this range is not considered to include the sign bit.
	const BigUnsigned::Blk  lMask = ~0 >> 1;
	const BigUnsigned::Blk uiMask = (unsigned int)(~0);
	const BigUnsigned::Blk  iMask = uiMask >> 1;
	const BigUnsigned::Blk usMask = (unsigned short)(~0);
	const BigUnsigned::Blk  sMask = usMask >> 1;
}

BigUnsigned::operator unsigned long() const {
	if (len == 0)
		return 0;
	else if (len == 1)
		return (unsigned long) blk[0];
	else
		throw "BigUnsigned::operator unsigned long: Value is too big for an unsigned long";
}

BigUnsigned::operator long() const {
	if (len == 0)
		return 0;
	else if (len == 1 && (blk[0] & lMask) == blk[0])
		return (long) blk[0];
	else
		throw "BigUnsigned::operator long: Value is too big for a long";
}

BigUnsigned::operator unsigned int() const {
	if (len == 0)
		return 0;
	else if (len == 1 && (blk[0] & uiMask) == blk[0])
		return (unsigned int) blk[0];
	else
		throw "BigUnsigned::operator unsigned int: Value is too big for an unsigned int";
}

BigUnsigned::operator int() const {
	if (len == 0)
		return 0;
	else if (len == 1 && (blk[0] & iMask) == blk[0])
		return (int) blk[0];
	else
		throw "BigUnsigned::operator int: Value is too big for an int";
}

BigUnsigned::operator unsigned short() const {
	if (len == 0)
		return 0;
	else if (len == 1 && (blk[0] & usMask) == blk[0])
		return (unsigned short) blk[0];
	else
		throw "BigUnsigned::operator unsigned short: Value is too big for an unsigned short";
}

BigUnsigned::operator short() const {
	if (len == 0)
		return 0;
	else if (len == 1 && (blk[0] & sMask) == blk[0])
		return (short) blk[0];
	else
		throw "BigUnsigned::operator short: Value is too big for a short";
}

// COMPARISON
BigUnsigned::CmpRes BigUnsigned::compareTo(const BigUnsigned &x) const {
	// A bigger length implies a bigger number.
	if (len < x.len)
		return less;
	else if (len > x.len)
		return greater;
	else {
		// Compare blocks one by one from left to right.
		Index i = len;
		while (i > 0) {
			i--;
			if (blk[i] == x.blk[i])
				continue;
			else if (blk[i] > x.blk[i])
				return greater;
			else
				return less;
		}
		// If no blocks differed, the numbers are equal.
		return equal;
	}
}

// PUT-HERE OPERATIONS

/*
* Below are implementations of the four basic arithmetic operations
* for `BigUnsigned's.  Their purpose is to use a mechanism that can
* calculate the sum, difference, product, and quotient/remainder of
* two individual blocks in order to calculate the sum, difference,
* product, and quotient/remainder of two multi-block BigUnsigned
* numbers.
*
* As alluded to in the comment before class `BigUnsigned',
* these algorithms bear a remarkable similarity (in purpose, if
* not in implementation) to the way humans operate on big numbers.
* The built-in `+', `-', `*', `/' and `%' operators are analogous
* to elementary-school ``math facts'' and ``times tables''; the
* four routines below are analogous to ``long division'' and its
* relatives.  (Only a computer can ``memorize'' a times table with
* 18446744073709551616 entries!  (For 32-bit blocks.))
*
* The discovery of these four algorithms, called the ``classical
* algorithms'', marked the beginning of the study of computer science.
* See Section 4.3.1 of Knuth's ``The Art of Computer Programming''.
*/

// Addition
void BigUnsigned::add(const BigUnsigned &a, const BigUnsigned &b) {
	// Block unsafe calls
	if (this == &a || this == &b)
		throw "BigUnsigned::add: One of the arguments is the invoked object";
	// If one argument is zero, copy the other.
	if (a.len == 0) {
		operator =(b);
		return;
	} else if (b.len == 0) {
		operator =(a);
		return;
	}
	// Some variables...
	// Carries in and out of an addition stage
	bool carryIn, carryOut;
	Blk temp;
	Index i;
	// a2 points to the longer input, b2 points to the shorter
	const BigUnsigned *a2, *b2;
	if (a.len >= b.len) {
		a2 = &a;
		b2 = &b;
	} else {
		a2 = &b;
		b2 = &a;
	}
	// Set prelimiary length and make room in this BigUnsigned
	len = a2->len + 1;
	allocate(len);
	// For each block index that is present in both inputs...
	for (i = 0, carryIn = false; i < b2->len; i++) {
		// Add input blocks
		temp = a2->blk[i] + b2->blk[i];
		// If a rollover occurred, the result is less than either input.
		// This test is used many times in the BigUnsigned code.
		carryOut = (temp < a2->blk[i]);
		// If a carry was input, handle it
		if (carryIn) {
			temp++;
			carryOut |= (temp == 0);
		}
		blk[i] = temp; // Save the addition result
		carryIn = carryOut; // Pass the carry along
	}
	// If there is a carry left over, increase blocks until
	// one does not roll over.
	for (; i < a2->len && carryIn; i++) {
		temp = a2->blk[i] + 1;
		carryIn = (temp == 0);
		blk[i] = temp;
	}
	// If the carry was resolved but the larger number
	// still has blocks, copy them over.
	for (; i < a2->len; i++)
		blk[i] = a2->blk[i];
	// Set the extra block if there's still a carry, decrease length otherwise
	if (carryIn)
		blk[i] = 1;
	else
		len--;
}

// Subtraction
void BigUnsigned::subtract(const BigUnsigned &a, const BigUnsigned &b) {
	// Block unsafe calls
	if (this == &a || this == &b)
		throw "BigUnsigned::subtract: One of the arguments is the invoked object";
	// If b is zero, copy a.  If a is shorter than b, the result is negative.
	if (b.len == 0) {
		operator =(a);
		return;
	} else if (a.len < b.len)
	throw "BigUnsigned::subtract: Negative result in unsigned calculation";
	// Some variables...
	bool borrowIn, borrowOut;
	Blk temp;
	Index i;
	// Set preliminary length and make room
	len = a.len;
	allocate(len);
	// For each block index that is present in both inputs...
	for (i = 0, borrowIn = false; i < b.len; i++) {
		temp = a.blk[i] - b.blk[i];
		// If a reverse rollover occurred, the result is greater than the block from a.
		borrowOut = (temp > a.blk[i]);
		// Handle an incoming borrow
		if (borrowIn) {
			borrowOut |= (temp == 0);
			temp--;
		}
		blk[i] = temp; // Save the subtraction result
		borrowIn = borrowOut; // Pass the borrow along
	}
	// If there is a borrow left over, decrease blocks until
	// one does not reverse rollover.
	for (; i < a.len && borrowIn; i++) {
		borrowIn = (a.blk[i] == 0);
		blk[i] = a.blk[i] - 1;
	}
	// If there's still a borrow, the result is negative.
	// Throw an exception, but zero out this object first just in case.
	if (borrowIn) {
		len = 0;
		throw "BigUnsigned::subtract: Negative result in unsigned calculation";
	} else // Copy over the rest of the blocks
	for (; i < a.len; i++)
		blk[i] = a.blk[i];
	// Zap leading zeros
	zapLeadingZeros();
}

/*
* About the multiplication and division algorithms:
*
* I searched unsucessfully for fast built-in operations like the `b_0'
* and `c_0' Knuth describes in Section 4.3.1 of ``The Art of Computer
* Programming'' (replace `place' by `Blk'):
*
*    ``b_0[:] multiplication of a one-place integer by another one-place
*      integer, giving a two-place answer;
*
*    ``c_0[:] division of a two-place integer by a one-place integer,
*      provided that the quotient is a one-place integer, and yielding
*      also a one-place remainder.''
*
* I also missed his note that ``[b]y adjusting the word size, if
* necessary, nearly all computers will have these three operations
* available'', so I gave up on trying to use algorithms similar to his.
* A future version of the library might include such algorithms; I
* would welcome contributions from others for this.
*
* I eventually decided to use bit-shifting algorithms.  To multiply `a'
* and `b', we zero out the result.  Then, for each `1' bit in `a', we
* shift `b' left the appropriate amount and add it to the result.
* Similarly, to divide `a' by `b', we shift `b' left varying amounts,
* repeatedly trying to subtract it from `a'.  When we succeed, we note
* the fact by setting a bit in the quotient.  While these algorithms
* have the same O(n^2) time complexity as Knuth's, the ``constant factor''
* is likely to be larger.
*
* Because I used these algorithms, which require single-block addition
* and subtraction rather than single-block multiplication and division,
* the innermost loops of all four routines are very similar.  Study one
* of them and all will become clear.
*/

/*
* This is a little inline function used by both the multiplication
* routine and the division routine.
*
* `getShiftedBlock' returns the `x'th block of `num << y'.
* `y' may be anything from 0 to N - 1, and `x' may be anything from
* 0 to `num.len'.
*
* Two things contribute to this block:
*
* (1) The `N - y' low bits of `num.blk[x]', shifted `y' bits left.
*
* (2) The `y' high bits of `num.blk[x-1]', shifted `N - y' bits right.
*
* But we must be careful if `x == 0' or `x == num.len', in
* which case we should use 0 instead of (2) or (1), respectively.
*
* If `y == 0', then (2) contributes 0, as it should.  However,
* in some computer environments, for a reason I cannot understand,
* `a >> b' means `a >> (b % N)'.  This means `num.blk[x-1] >> (N - y)'
* will return `num.blk[x-1]' instead of the desired 0 when `y == 0';
* the test `y == 0' handles this case specially.
*/
inline BigUnsigned::Blk getShiftedBlock(const BigUnsigned &num,
	BigUnsigned::Index x, unsigned int y) {
	BigUnsigned::Blk part1 = (x == 0 || y == 0) ? 0 : (num.blk[x - 1] >> (BigUnsigned::N - y));
	BigUnsigned::Blk part2 = (x == num.len) ? 0 : (num.blk[x] << y);
	return part1 | part2;
}

// Multiplication
void BigUnsigned::multiply(const BigUnsigned &a, const BigUnsigned &b) {
	// Block unsafe calls
	if (this == &a || this == &b)
		throw "BigUnsigned::multiply: One of the arguments is the invoked object";
	// If either a or b is zero, set to zero.
	if (a.len == 0 || b.len == 0) {
		len = 0;
		return;
	}
	/*
	* Overall method:
	*
	* Set this = 0.
	* For each 1-bit of `a' (say the `i2'th bit of block `i'):
	*    Add `b << (i blocks and i2 bits)' to *this.
	*/
	// Variables for the calculation
	Index i, j, k;
	unsigned int i2;
	Blk temp;
	bool carryIn, carryOut;
	// Set preliminary length and make room
	len = a.len + b.len;
	allocate(len);
	// Zero out this object
	for (i = 0; i < len; i++)
		blk[i] = 0;
	// For each block of the first number...
	for (i = 0; i < a.len; i++) {
		// For each 1-bit of that block...
		for (i2 = 0; i2 < N; i2++) {
			if ((a.blk[i] & (1 << i2)) == 0)
				continue;
			/*
			* Add b to this, shifted left i blocks and i2 bits.
			* j is the index in b, and k = i + j is the index in this.
			*
			* `getShiftedBlock', a short inline function defined above,
			* is now used for the bit handling.  It replaces the more
			* complex `bHigh' code, in which each run of the loop dealt
			* immediately with the low bits and saved the high bits to
			* be picked up next time.  The last run of the loop used to
			* leave leftover high bits, which were handled separately.
			* Instead, this loop runs an additional time with j == b.len.
			* These changes were made on 2005.01.11.
			*/
			for (j = 0, k = i, carryIn = false; j <= b.len; j++, k++) {
				/*
				* The body of this loop is very similar to the body of the first loop
				* in `add', except that this loop does a `+=' instead of a `+'.
				*/
				temp = blk[k] + getShiftedBlock(b, j, i2);
				carryOut = (temp < blk[k]);
				if (carryIn) {
					temp++;
					carryOut |= (temp == 0);
				}
				blk[k] = temp;
				carryIn = carryOut;
			}
			// No more extra iteration to deal with `bHigh'.
			// Roll-over a carry as necessary.
			for (; carryIn; k++) {
				blk[k]++;
				carryIn = (blk[k] == 0);
			}
		}
	}
	// Zap possible leading zero
	if (blk[len - 1] == 0)
		len--;
}

/*
* DIVISION WITH REMAINDER
* The functionality of divide, modulo, and %= is included in this one monstrous call,
* which deserves some explanation.
*
* The division *this / b is performed.
* Afterwards, q has the quotient, and *this has the remainder.
* Thus, a call is like q = *this / b, *this %= b.
*
* This seemingly bizarre pattern of inputs and outputs has a justification.  The
* ``put-here operations'' are supposed to be fast.  Therefore, they accept inputs
* and provide outputs in the most convenient places so that no value ever needs
* to be copied in its entirety.  That way, the client can perform exactly the
* copying it needs depending on where the inputs are and where it wants the output.
*/
void BigUnsigned::divideWithRemainder(const BigUnsigned &b, BigUnsigned &q) {
	// Block unsafe calls
	if (this == &b || &q == &b || this == &q)
		throw "BigUnsigned::divideWithRemainder: Some two objects involved are the same";
	
	/*
	* Note that the mathematical definition of mod (I'm trusting Knuth) is somewhat
	* different from the way the normal C++ % operator behaves in the case of division by 0.
	* This function does it Knuth's way.
	*
	* We let a / 0 == 0 (it doesn't matter) and a % 0 == a, no exceptions thrown.
	* This allows us to preserve both Knuth's demand that a mod 0 == a
	* and the useful property that (a / b) * b + (a % b) == a.
	*/
	if (b.len == 0) {
		q.len = 0;
		return;
	}
	
	/*
	* If *this.len < b.len, then *this < b, and we can be sure that b doesn't go into
	* *this at all.  The quotient is 0 and *this is already the remainder (so leave it alone).
	*/
	if (len < b.len) {
		q.len = 0;
		return;
	}
	
	/*
	* At this point we know *this > b > 0.  (Whew!)
	*/
	
	/*
	* Overall method:
	*
	* For each appropriate i and i2, decreasing:
	*    Try to subtract (b << (i blocks and i2 bits)) from *this.
	*        (`work2' holds the result of this subtraction.)
	*    If the result is nonnegative:
	*        Turn on bit i2 of block i of the quotient q.
	*        Save the result of the subtraction back into *this.
	*    Otherwise:
	*        Bit i2 of block i remains off, and *this is unchanged.
	* 
	* Eventually q will contain the entire quotient, and *this will
	* be left with the remainder.
	*
	* We use work2 to temporarily store the result of a subtraction.
	* work2[x] corresponds to blk[x], not blk[x+i], since 2005.01.11.
	* If the subtraction is successful, we copy work2 back to blk.
	* (There's no `work1'.  In a previous version, when division was
	* coded for a read-only dividend, `work1' played the role of
	* the here-modifiable `*this' and got the remainder.)
	*
	* We never touch the i lowest blocks of either blk or work2 because
	* they are unaffected by the subtraction: we are subtracting
	* (b << (i blocks and i2 bits)), which ends in at least `i' zero blocks.
	*/
	// Variables for the calculation
	Index i, j, k;
	unsigned int i2;
	Blk temp;
	bool borrowIn, borrowOut;
	
	/*
	* Make sure we have an extra zero block just past the value.
	*
	* When we attempt a subtraction, we might shift `b' so
	* its first block begins a few bits left of the dividend,
	* and then we'll try to compare these extra bits with
	* a nonexistent block to the left of the dividend.  The
	* extra zero block ensures sensible behavior; we need
	* an extra block in `work2' for exactly the same reason.
	*
	* See below `divideWithRemainder' for the interesting and
	* amusing story of this section of code.
	*/
	Index origLen = len; // Save real length.
	len++; // Increase the length.
	allocateAndCopy(len); // Get the space.
	blk[origLen] = 0; // Zero the extra block.
	
	// work2 holds part of the result of a subtraction; see above.
	Blk *work2 = new Blk[len];
	
	// Set preliminary length for quotient and make room
	q.len = origLen - b.len + 1;
	q.allocate(q.len);
	// Zero out the quotient
	for (i = 0; i < q.len; i++)
		q.blk[i] = 0;
	
	// For each possible left-shift of b in blocks...
	i = q.len;
	while (i > 0) {
		i--;
		// For each possible left-shift of b in bits...
		// (Remember, N is the number of bits in a Blk.)
		q.blk[i] = 0;
		i2 = N;
		while (i2 > 0) {
			i2--;
			/*
			* Subtract b, shifted left i blocks and i2 bits, from *this,
			* and store the answer in work2.  In the for loop, `k == i + j'.
			*
			* Compare this to the middle section of `multiply'.  They
			* are in many ways analogous.  See especially the discussion
			* of `getShiftedBlock'.
			*/
			for (j = 0, k = i, borrowIn = false; j <= b.len; j++, k++) {
				temp = blk[k] - getShiftedBlock(b, j, i2);
				borrowOut = (temp > blk[k]);
				if (borrowIn) {
					borrowOut |= (temp == 0);
					temp--;
				}
				// Since 2005.01.11, indices of `work2' directly match those of `blk', so use `k'.
				work2[k] = temp; 
				borrowIn = borrowOut;
			}
			// No more extra iteration to deal with `bHigh'.
			// Roll-over a borrow as necessary.
			for (; k < origLen && borrowIn; k++) {
				borrowIn = (blk[k] == 0);
				work2[k] = blk[k] - 1;
			}
			/*
			* If the subtraction was performed successfully (!borrowIn),
			* set bit i2 in block i of the quotient.
			*
			* Then, copy the portion of work2 filled by the subtraction
			* back to *this.  This portion starts with block i and ends--
			* where?  Not necessarily at block `i + b.len'!  Well, we
			* increased k every time we saved a block into work2, so
			* the region of work2 we copy is just [i, k).
			*/
			if (!borrowIn) {
				q.blk[i] |= (1 << i2);
				while (k > i) {
					k--;
					blk[k] = work2[k];
				}
			} 
		}
	}
	// Zap possible leading zero in quotient
	if (q.blk[q.len - 1] == 0)
		q.len--;
	// Zap any/all leading zeros in remainder
	zapLeadingZeros();
	// Deallocate temporary array.
	// (Thanks to Brad Spencer for noticing my accidental omission of this!)
	delete [] work2;
	
}
/*
* The out-of-bounds accesses story:
* 
* On 2005.01.06 or 2005.01.07 (depending on your time zone),
* Milan Tomic reported out-of-bounds memory accesses in
* the Big Integer Library.  To investigate the problem, I
* added code to bounds-check every access to the `blk' array
* of a `NumberlikeArray'.
*
* This gave me warnings that fell into two categories of false
* positives.  The bounds checker was based on length, not
* capacity, and in two places I had accessed memory that I knew
* was inside the capacity but that wasn't inside the length:
* 
* (1) The extra zero block at the left of `*this'.  Earlier
* versions said `allocateAndCopy(len + 1); blk[len] = 0;'
* but did not increment `len'.
*
* (2) The entire digit array in the conversion constructor
* ``BigUnsignedInABase(BigUnsigned)''.  It was allocated with
* a conservatively high capacity, but the length wasn't set
* until the end of the constructor.
*
* To simplify matters, I changed both sections of code so that
* all accesses occurred within the length.  The messages went
* away, and I told Milan that I couldn't reproduce the problem,
* sending a development snapshot of the bounds-checked code.
*
* Then, on 2005.01.09-10, he told me his debugger still found
* problems, specifically at the line `delete [] work2'.
* It was `work2', not `blk', that was causing the problems;
* this possibility had not occurred to me at all.  In fact,
* the problem was that `work2' needed an extra block just
* like `*this'.  Go ahead and laugh at me for finding (1)
* without seeing what was actually causing the trouble.  :-)
*
* The 2005.01.11 version fixes this problem.  I hope this is
* the last of my memory-related bloopers.  So this is what
* starts happening to your C++ code if you use Java too much!
*/

// Bitwise and
void BigUnsigned::bitAnd(const BigUnsigned &a, const BigUnsigned &b) {
	// Block unsafe calls
	if (this == &a || this == &b)
		throw "BigUnsigned::bitAnd: One of the arguments is the invoked object";
	len = (a.len >= b.len) ? b.len : a.len;
	allocate(len);
	Index i;
	for (i = 0; i < len; i++)
		blk[i] = a.blk[i] & b.blk[i];
	zapLeadingZeros();
}

// Bitwise or
void BigUnsigned::bitOr(const BigUnsigned &a, const BigUnsigned &b) {
	// Block unsafe calls
	if (this == &a || this == &b)
		throw "BigUnsigned::bitOr: One of the arguments is the invoked object";
	Index i;
	const BigUnsigned *a2, *b2;
	if (a.len >= b.len) {
		a2 = &a;
		b2 = &b;
	} else {
		a2 = &b;
		b2 = &a;
	}
	allocate(a2->len);
	for (i = 0; i < b2->len; i++)
		blk[i] = a2->blk[i] | b2->blk[i];
	for (; i < a2->len; i++)
		blk[i] = a2->blk[i];
	len = a2->len;
}

// Bitwise xor
void BigUnsigned::bitXor(const BigUnsigned &a, const BigUnsigned &b) {
	// Block unsafe calls
	if (this == &a || this == &b)
		throw "BigUnsigned::bitXor: One of the arguments is the invoked object";
	Index i;
	const BigUnsigned *a2, *b2;
	if (a.len >= b.len) {
		a2 = &a;
		b2 = &b;
	} else {
		a2 = &b;
		b2 = &a;
	}
	allocate(b2->len);
	for (i = 0; i < b2->len; i++)
		blk[i] = a2->blk[i] ^ b2->blk[i];
	for (; i < a2->len; i++)
		blk[i] = a2->blk[i];
	len = a2->len;
	zapLeadingZeros();
}

// INCREMENT/DECREMENT OPERATORS

// Prefix increment
void BigUnsigned::operator ++() {
	Index i;
	bool carry = true;
	for (i = 0; i < len && carry; i++) {
		blk[i]++;
		carry = (blk[i] == 0);
	}
	if (carry) {
		// Matt fixed a bug 2004.12.24: next 2 lines used to say allocateAndCopy(len + 1)
		len++;
		allocateAndCopy(len);
		blk[i] = 1;
	}
}

// Postfix increment: same as prefix
void BigUnsigned::operator ++(int) {
	operator ++();
}

// Prefix decrement
void BigUnsigned::operator --() {
	if (len == 0)
		throw "BigUnsigned::operator --(): Cannot decrement an unsigned zero";
	Index i;
	bool borrow = true;
	for (i = 0; borrow; i++) {
		borrow = (blk[i] == 0);
		blk[i]--;
	}
	// Zap possible leading zero (there can only be one)
	if (blk[len - 1] == 0)
		len--;
}

// Postfix decrement: same as prefix
void BigUnsigned::operator --(int) {
	operator --();
}