- * BigUnsigned and BigInteger both provide three kinds of operators.
- * Here ``big-integer'' refers to BigInteger or BigUnsigned.
- *
- * (1) Overloaded ``return-by-value'' operators:
- * +, -, *, /, %, unary -.
- * Big-integer code using these operators looks identical to
- * code using the primitive integer types. These operators take
- * one or two big-integer inputs and return a big-integer result,
- * which can then be assigned to a BigInteger variable or used
- * in an expression. Example:
- * BigInteger a(1), b = 1;
- * BigInteger c = a + b;
- *
- * (2) Overloaded assignment operators:
- * +=, -=, *=, /=, %=, &=, |=, ^=, ++, --, flipSign.
- * Again, these are used on big integers just like on ints.
- * They take one writable big integer that both provides an
- * operand and receives a result. The first eight also take
- * a second read-only operand. Example:
- * BigInteger a(1), b(1);
- * a += b;
- *
- * (3) ``Put-here'' operations: `add', `subtract', etc.
- * Using a return-by-value or assignment operator generally involves
- * copy constructions and/or assignments. The ``put-here'' operations
- * require none, but they are more of a hassle to use. Most take two
- * read-only operands and save the result in the calling object `*this',
- * whose previous value is ignored. `divideWithRemainder' is an exception.
- * <<< NOTE >>>: Put-here operations do not return a value: they don't need to!!
- * Examples:
- * BigInteger a(43), b(7), c, d;
- * c = a + b; // Now c == 50.
- * c.add(a, b); // Same effect but without the two bulk-copies.
- * c.divideWithRemainder(b, d); // 50 / 7; now d == 7 (quotient) and c == 1 (remainder).
- * a.add(a, b); // ``Aliased'' calls now do the right thing using a
- * // temporary copy, but see note on divideWithRemainder.
- */
-
- // PUT-HERE OPERATIONS
- public:
- /* These 3: Two read-only operands as arguments. Result left in *this. */
- void add(const BigUnsigned &a, const BigUnsigned &b); // Addition
- void subtract(const BigUnsigned &a, const BigUnsigned &b); // Subtraction
- void multiply(const BigUnsigned &a, const BigUnsigned &b); // Multiplication
- /* Divisive stuff
- * `a.divideWithRemainder(b, q)' is like `q = a / b, a %= b'.
- * Semantics similar to Donald E. Knuth's are used for / and %,
- * and these differ from the semantics of primitive-type
- * / and % under division by zero.
- * Look in `BigUnsigned.cc' for details.
- * `a.divideWithRemainder(b, a)' causes an exception: it doesn't make
- * sense to write quotient and remainder into the same variable.
- */
+ * BigUnsigned and BigInteger both provide three kinds of operators.
+ * Here ``big-integer'' refers to BigInteger or BigUnsigned.
+ *
+ * (1) Overloaded ``return-by-value'' operators:
+ * +, -, *, /, %, unary -, &, |, ^, <<, >>.
+ * Big-integer code using these operators looks identical to code using
+ * the primitive integer types. These operators take one or two
+ * big-integer inputs and return a big-integer result, which can then
+ * be assigned to a BigInteger variable or used in an expression.
+ * Example:
+ * BigInteger a(1), b = 1;
+ * BigInteger c = a + b;
+ *
+ * (2) Overloaded assignment operators:
+ * +=, -=, *=, /=, %=, flipSign, &=, |=, ^=, <<=, >>=, ++, --.
+ * Again, these are used on big integers just like on ints. They take
+ * one writable big integer that both provides an operand and receives a
+ * result. Most also take a second read-only operand.
+ * Example:
+ * BigInteger a(1), b(1);
+ * a += b;
+ *
+ * (3) Copy-less operations: `add', `subtract', etc.
+ * These named methods take operands as arguments and store the result
+ * in the receiver (*this), avoiding unnecessary copies and allocations.
+ * `divideWithRemainder' is special: it both takes the dividend from and
+ * stores the remainder into the receiver, and it takes a separate
+ * object in which to store the quotient. NOTE: If you are wondering
+ * why these don't return a value, you probably mean to use the
+ * overloaded return-by-value operators instead.
+ *
+ * Examples:
+ * BigInteger a(43), b(7), c, d;
+ *
+ * c = a + b; // Now c == 50.
+ * c.add(a, b); // Same effect but without the two copies.
+ *
+ * c.divideWithRemainder(b, d);
+ * // 50 / 7; now d == 7 (quotient) and c == 1 (remainder).
+ *
+ * // ``Aliased'' calls now do the right thing using a temporary
+ * // copy, but see note on `divideWithRemainder'.
+ * a.add(a, b);
+ */
+
+ // COPY-LESS OPERATIONS
+
+ // These 8: Arguments are read-only operands, result is saved in *this.
+ void add(const BigUnsigned &a, const BigUnsigned &b);
+ void subtract(const BigUnsigned &a, const BigUnsigned &b);
+ void multiply(const BigUnsigned &a, const BigUnsigned &b);
+ void bitAnd(const BigUnsigned &a, const BigUnsigned &b);
+ void bitOr(const BigUnsigned &a, const BigUnsigned &b);
+ void bitXor(const BigUnsigned &a, const BigUnsigned &b);
+ /* Negative shift amounts translate to opposite-direction shifts,
+ * except for -2^(8*sizeof(int)-1) which is unimplemented. */
+ void bitShiftLeft(const BigUnsigned &a, int b);
+ void bitShiftRight(const BigUnsigned &a, int b);
+
+ /* `a.divideWithRemainder(b, q)' is like `q = a / b, a %= b'.
+ * / and % use semantics similar to Knuth's, which differ from the
+ * primitive integer semantics under division by zero. See the
+ * implementation in BigUnsigned.cc for details.
+ * `a.divideWithRemainder(b, a)' throws an exception: it doesn't make
+ * sense to write quotient and remainder into the same variable. */