X-Git-Url: https://mattmccutchen.net/bigint/bigint.git/blobdiff_plain/05780f4b578d6ae054be0b19b8498d32a4f16c60..00c6448a6c5fc7a68427ca1dc3f5f523563e1041:/BigInteger.hh

diff --git a/BigInteger.hh b/BigInteger.hh
index e206718..7319168 100644
--- a/BigInteger.hh
+++ b/BigInteger.hh
@@ -1,6 +1,5 @@
 /*
 * Matt McCutchen's Big Integer Library
-* http://mysite.verizon.net/mccutchen/bigint/
 */
 
 #ifndef BIGINTEGER
@@ -15,8 +14,9 @@
 * and many math operations are defined on BigIntegers.
 *
 * The number is stored as a series of blocks in a
-* dynamically allocated array.  It is as if the numbers
-* were written digit by digit in base 256 ^ sizeof(unsigned long).
+* dynamically allocated array.  It is as if the number
+* were written digit by digit in base 2 ^ N, **where N is the
+* number of bits in an unsigned long.**
 *
 * This class is derived from BigUnsigned, which represents
 * a large nonnegative integer.  BigUnsigned should be studied
@@ -92,7 +92,7 @@ class BigInteger : public BigUnsigned {
 	// PUT-HERE OPERATIONS
 	/* These store the result of the operation on the arguments into this.
 	* a.add(b, c) is equivalent to, but faster than, a = b + c.
-	* Calls like a.operation(a, b) are unsafe and not allowed. */
+	* See explanation of "put-here operations" in BigUnsigned.cc . */
 	public:
 	void add     (const BigInteger &a, const BigInteger &b); // Addition
 	void subtract(const BigInteger &a, const BigInteger &b); // Subtraction
@@ -103,17 +103,17 @@ class BigInteger : public BigUnsigned {
 	* and these usually differ from the semantics of primitive-type
 	* / and % when negatives and/or zeroes are involved.
 	* Look in `BigInteger.cc' for details.
+	* `a.divideWithRemainder(b, a)' causes an exception: it doesn't make
+	* sense to write quotient and remainder into the same variable.
 	*/
 	void divideWithRemainder(const BigInteger &b, BigInteger &q);
 	void divide(const BigInteger &a, const BigInteger &b) {
-		// Division, deprecated and provided for compatibility
 		BigInteger a2(a);
 		a2.divideWithRemainder(b, *this);
 		// quotient now in *this
 		// don't care about remainder left in a2
 	}
 	void modulo(const BigInteger &a, const BigInteger &b) {
-		// Modular reduction, deprecated and provided for compatibility
 		*this = a;
 		BigInteger q;
 		divideWithRemainder(b, q);
@@ -196,20 +196,21 @@ inline BigInteger BigInteger::operator -() const {
 	return ans;
 }
 
-// ASSIGNMENT OPERATORS
-// These create a copy of this, then invoke the appropriate
-// put-here operation on this, passing the copy and x.
+/*
+ * ASSIGNMENT OPERATORS
+ * 
+ * Now the responsibility for making a temporary copy if necessary
+ * belongs to the put-here operations.  See Assignment Operators in
+ * BigUnsigned.hh.
+ */
 inline void BigInteger::operator +=(const BigInteger &x) {
-	BigInteger thisCopy(*this);
-	add(thisCopy, x);
+	add(*this, x);
 }
 inline void BigInteger::operator -=(const BigInteger &x) {
-	BigInteger thisCopy(*this);
-	subtract(thisCopy, x);
+	subtract(*this, x);
 }
 inline void BigInteger::operator *=(const BigInteger &x) {
-	BigInteger thisCopy(*this);
-	multiply(thisCopy, x);
+	multiply(*this, x);
 }
 inline void BigInteger::operator /=(const BigInteger &x) {
 	// Updated for divideWithRemainder