X-Git-Url: https://mattmccutchen.net/bigint/bigint.git/blobdiff_plain/5ff40cf5d6e822051da902b041ae7ae8f545123e..706f6a7ec4a59f98108a6f3fd8f34fcbfd81f596:/BigUnsignedInABase.hh

diff --git a/BigUnsignedInABase.hh b/BigUnsignedInABase.hh
index 3712907..6925151 100644
--- a/BigUnsignedInABase.hh
+++ b/BigUnsignedInABase.hh
@@ -1,54 +1,50 @@
-/*
-* Matt McCutchen's Big Integer Library
-*/
-
-#ifndef BIGUNSIGNEDINABASE
-#define BIGUNSIGNEDINABASE
+#ifndef BIGUNSIGNEDINABASE_H
+#define BIGUNSIGNEDINABASE_H
 
 #include "NumberlikeArray.hh"
 #include "BigUnsigned.hh"
 #include <string>
 
 /*
-* A BigUnsignedInABase object represents a nonnegative
-* integer of size limited only by available memory,
-* represented in a user-specified base that can fit in
-* an `unsigned short' (most can, and this saves memory).
-*
-* BigUnsignedInABase is intended as an intermediary class
-* with little functionality of its own.  BigUnsignedInABase
-* objects can be constructed from, and converted to,
-* BigUnsigneds (requiring multiplication, mods, etc.) and
-* `std::string's (by switching digit values for appropriate
-* characters).
-*
-* BigUnsignedInABase is similar to BigUnsigned.  Note the following:
-*
-* (1) They represent the number in exactly the same way, except
-* that BigUnsignedInABase uses ``digits'' (or Digit) where BigUnsigned uses
-* ``blocks'' (or Blk).
-*
-* (2) Both use the management features of NumberlikeArray.  (In fact,
-* my desire to add a BigUnsignedInABase class without duplicating a
-* lot of code led me to introduce NumberlikeArray.)
-*
-* (3) The only arithmetic operation supported by BigUnsignedInABase
-* is an equality test.  Use BigUnsigned for arithmetic.
-*/
+ * A BigUnsignedInABase object represents a nonnegative
+ * integer of size limited only by available memory,
+ * represented in a user-specified base that can fit in
+ * an `unsigned short' (most can, and this saves memory).
+ *
+ * BigUnsignedInABase is intended as an intermediary class
+ * with little functionality of its own.  BigUnsignedInABase
+ * objects can be constructed from, and converted to,
+ * BigUnsigneds (requiring multiplication, mods, etc.) and
+ * `std::string's (by switching digit values for appropriate
+ * characters).
+ *
+ * BigUnsignedInABase is similar to BigUnsigned.  Note the following:
+ *
+ * (1) They represent the number in exactly the same way, except
+ * that BigUnsignedInABase uses ``digits'' (or Digit) where BigUnsigned uses
+ * ``blocks'' (or Blk).
+ *
+ * (2) Both use the management features of NumberlikeArray.  (In fact,
+ * my desire to add a BigUnsignedInABase class without duplicating a
+ * lot of code led me to introduce NumberlikeArray.)
+ *
+ * (3) The only arithmetic operation supported by BigUnsignedInABase
+ * is an equality test.  Use BigUnsigned for arithmetic.
+ */
 
 class BigUnsignedInABase : protected NumberlikeArray<unsigned short> {
 
 	// TYPES
-	public:
+public:
 	typedef unsigned short Digit; // The digit type that BigUnsignedInABases are built from
 	typedef Digit Base;
 
 	// FIELDS
-	protected:
+protected:
 	Base base; // The base of this BigUnsignedInABase
 
 	// MANAGEMENT
-	protected:
+protected:
 	// These members generally defer to those in NumberlikeArray, possibly with slight changes.
 	// It might be nice if one could request that constructors be inherited in C++.
 
@@ -62,7 +58,7 @@ class BigUnsignedInABase : protected NumberlikeArray<unsigned short> {
 	//void allocate(Index c); // (NlA) Ensures the number array has at least the indicated capacity, maybe discarding contents
 	//void allocateAndCopy(Index c); // (NlA) Ensures the number array has at least the indicated capacity, preserving its contents
 
-	public:
+public:
 	BigUnsignedInABase() : NumberlikeArray<Digit>(), base(2) {} // Default constructor (value is 0 in base 2)
 	BigUnsignedInABase(const BigUnsignedInABase &x) : NumberlikeArray<Digit>(x), base(x.base) {} // Copy constructor
 
@@ -80,27 +76,27 @@ class BigUnsignedInABase : protected NumberlikeArray<unsigned short> {
 	operator BigUnsigned() const;
 
 	/* LINKS TO STRINGS
-	*
-	* These use the symbols ``0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ'' to represent
-	* digits of 0 through 35.  When parsing strings, lowercase is also accepted.
-	*
-	* All string representations are big-endian (big-place-value digits first).
-	* (Computer scientists have adopted zero-based counting; why can't they
-	* tolerate little-endian numbers?  It makes a lot of sense!)
-	*
-	* No string representation has a ``base indicator'' like ``0x''.
-	*
-	* An exception is made for zero: it is converted to ``0'' and not the empty string.
-	*
-	* If you want different conventions, write your
-	* own routines to go between BigUnsignedInABase and strings.  It's not hard.
-	*/
+	 *
+	 * These use the symbols ``0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ'' to represent
+	 * digits of 0 through 35.  When parsing strings, lowercase is also accepted.
+	 *
+	 * All string representations are big-endian (big-place-value digits first).
+	 * (Computer scientists have adopted zero-based counting; why can't they
+	 * tolerate little-endian numbers?  It makes a lot of sense!)
+	 *
+	 * No string representation has a ``base indicator'' like ``0x''.
+	 *
+	 * An exception is made for zero: it is converted to ``0'' and not the empty string.
+	 *
+	 * If you want different conventions, write your
+	 * own routines to go between BigUnsignedInABase and strings.  It's not hard.
+	 */
 	operator std::string() const;
 	BigUnsignedInABase(const std::string &s, Base base);
 
 	// PICKING APART
 	// These accessors can be used to get the pieces of the number
-	public:
+public:
 	Base getBase() const { return base; }
 	NumberlikeArray<Digit>::getCapacity; // (NlA)
 	NumberlikeArray<Digit>::getLength; // (NlA)
@@ -111,7 +107,7 @@ class BigUnsignedInABase : protected NumberlikeArray<unsigned short> {
 	bool isZero() const { return NumberlikeArray<Digit>::isEmpty(); } // Often convenient for loops
 
 	// EQUALITY TEST
-	public:
+public:
 	// Equality test
 	bool operator ==(const BigUnsignedInABase &x) const {
 		return base == x.base && NumberlikeArray<Digit>::operator ==(x);