Initial check in of big integer library, v2010.04.30
[pdfium.git] / third_party / bigint / BigUnsigned.hh
1 #ifndef BIGUNSIGNED_H
2 #define BIGUNSIGNED_H
3
4 #include "NumberlikeArray.hh"
5
6 /* A BigUnsigned object represents a nonnegative integer of size limited only by
7  * available memory.  BigUnsigneds support most mathematical operators and can
8  * be converted to and from most primitive integer types.
9  *
10  * The number is stored as a NumberlikeArray of unsigned longs as if it were
11  * written in base 256^sizeof(unsigned long).  The least significant block is
12  * first, and the length is such that the most significant block is nonzero. */
13 class BigUnsigned : protected NumberlikeArray<unsigned long> {
14
15 public:
16         // Enumeration for the result of a comparison.
17         enum CmpRes { less = -1, equal = 0, greater = 1 };
18
19         // BigUnsigneds are built with a Blk type of unsigned long.
20         typedef unsigned long Blk;
21
22         typedef NumberlikeArray<Blk>::Index Index;
23         NumberlikeArray<Blk>::N;
24
25 protected:
26         // Creates a BigUnsigned with a capacity; for internal use.
27         BigUnsigned(int, Index c) : NumberlikeArray<Blk>(0, c) {}
28
29         // Decreases len to eliminate any leading zero blocks.
30         void zapLeadingZeros() { 
31                 while (len > 0 && blk[len - 1] == 0)
32                         len--;
33         }
34
35 public:
36         // Constructs zero.
37         BigUnsigned() : NumberlikeArray<Blk>() {}
38
39         // Copy constructor
40         BigUnsigned(const BigUnsigned &x) : NumberlikeArray<Blk>(x) {}
41
42         // Assignment operator
43         void operator=(const BigUnsigned &x) {
44                 NumberlikeArray<Blk>::operator =(x);
45         }
46
47         // Constructor that copies from a given array of blocks.
48         BigUnsigned(const Blk *b, Index blen) : NumberlikeArray<Blk>(b, blen) {
49                 // Eliminate any leading zeros we may have been passed.
50                 zapLeadingZeros();
51         }
52
53         // Destructor.  NumberlikeArray does the delete for us.
54         ~BigUnsigned() {}
55         
56         // Constructors from primitive integer types
57         BigUnsigned(unsigned long  x);
58         BigUnsigned(         long  x);
59         BigUnsigned(unsigned int   x);
60         BigUnsigned(         int   x);
61         BigUnsigned(unsigned short x);
62         BigUnsigned(         short x);
63 protected:
64         // Helpers
65         template <class X> void initFromPrimitive      (X x);
66         template <class X> void initFromSignedPrimitive(X x);
67 public:
68
69         /* Converters to primitive integer types
70          * The implicit conversion operators caused trouble, so these are now
71          * named. */
72         unsigned long  toUnsignedLong () const;
73         long           toLong         () const;
74         unsigned int   toUnsignedInt  () const;
75         int            toInt          () const;
76         unsigned short toUnsignedShort() const;
77         short          toShort        () const;
78 protected:
79         // Helpers
80         template <class X> X convertToSignedPrimitive() const;
81         template <class X> X convertToPrimitive      () const;
82 public:
83
84         // BIT/BLOCK ACCESSORS
85
86         // Expose these from NumberlikeArray directly.
87         NumberlikeArray<Blk>::getCapacity;
88         NumberlikeArray<Blk>::getLength;
89
90         /* Returns the requested block, or 0 if it is beyond the length (as if
91          * the number had 0s infinitely to the left). */
92         Blk getBlock(Index i) const { return i >= len ? 0 : blk[i]; }
93         /* Sets the requested block.  The number grows or shrinks as necessary. */
94         void setBlock(Index i, Blk newBlock);
95
96         // The number is zero if and only if the canonical length is zero.
97         bool isZero() const { return NumberlikeArray<Blk>::isEmpty(); }
98
99         /* Returns the length of the number in bits, i.e., zero if the number
100          * is zero and otherwise one more than the largest value of bi for
101          * which getBit(bi) returns true. */
102         Index bitLength() const;
103         /* Get the state of bit bi, which has value 2^bi.  Bits beyond the
104          * number's length are considered to be 0. */
105         bool getBit(Index bi) const {
106                 return (getBlock(bi / N) & (Blk(1) << (bi % N))) != 0;
107         }
108         /* Sets the state of bit bi to newBit.  The number grows or shrinks as
109          * necessary. */
110         void setBit(Index bi, bool newBit);
111
112         // COMPARISONS
113
114         // Compares this to x like Perl's <=>
115         CmpRes compareTo(const BigUnsigned &x) const;
116
117         // Ordinary comparison operators
118         bool operator ==(const BigUnsigned &x) const {
119                 return NumberlikeArray<Blk>::operator ==(x);
120         }
121         bool operator !=(const BigUnsigned &x) const {
122                 return NumberlikeArray<Blk>::operator !=(x);
123         }
124         bool operator < (const BigUnsigned &x) const { return compareTo(x) == less   ; }
125         bool operator <=(const BigUnsigned &x) const { return compareTo(x) != greater; }
126         bool operator >=(const BigUnsigned &x) const { return compareTo(x) != less   ; }
127         bool operator > (const BigUnsigned &x) const { return compareTo(x) == greater; }
128
129         /*
130          * BigUnsigned and BigInteger both provide three kinds of operators.
131          * Here ``big-integer'' refers to BigInteger or BigUnsigned.
132          *
133          * (1) Overloaded ``return-by-value'' operators:
134          *     +, -, *, /, %, unary -, &, |, ^, <<, >>.
135          * Big-integer code using these operators looks identical to code using
136          * the primitive integer types.  These operators take one or two
137          * big-integer inputs and return a big-integer result, which can then
138          * be assigned to a BigInteger variable or used in an expression.
139          * Example:
140          *     BigInteger a(1), b = 1;
141          *     BigInteger c = a + b;
142          *
143          * (2) Overloaded assignment operators:
144          *     +=, -=, *=, /=, %=, flipSign, &=, |=, ^=, <<=, >>=, ++, --.
145          * Again, these are used on big integers just like on ints.  They take
146          * one writable big integer that both provides an operand and receives a
147          * result.  Most also take a second read-only operand.
148          * Example:
149          *     BigInteger a(1), b(1);
150          *     a += b;
151          *
152          * (3) Copy-less operations: `add', `subtract', etc.
153          * These named methods take operands as arguments and store the result
154          * in the receiver (*this), avoiding unnecessary copies and allocations.
155          * `divideWithRemainder' is special: it both takes the dividend from and
156          * stores the remainder into the receiver, and it takes a separate
157          * object in which to store the quotient.  NOTE: If you are wondering
158          * why these don't return a value, you probably mean to use the
159          * overloaded return-by-value operators instead.
160          * 
161          * Examples:
162          *     BigInteger a(43), b(7), c, d;
163          *
164          *     c = a + b;   // Now c == 50.
165          *     c.add(a, b); // Same effect but without the two copies.
166          *
167          *     c.divideWithRemainder(b, d);
168          *     // 50 / 7; now d == 7 (quotient) and c == 1 (remainder).
169          *
170          *     // ``Aliased'' calls now do the right thing using a temporary
171          *     // copy, but see note on `divideWithRemainder'.
172          *     a.add(a, b); 
173          */
174
175         // COPY-LESS OPERATIONS
176
177         // These 8: Arguments are read-only operands, result is saved in *this.
178         void add(const BigUnsigned &a, const BigUnsigned &b);
179         void subtract(const BigUnsigned &a, const BigUnsigned &b);
180         void multiply(const BigUnsigned &a, const BigUnsigned &b);
181         void bitAnd(const BigUnsigned &a, const BigUnsigned &b);
182         void bitOr(const BigUnsigned &a, const BigUnsigned &b);
183         void bitXor(const BigUnsigned &a, const BigUnsigned &b);
184         /* Negative shift amounts translate to opposite-direction shifts,
185          * except for -2^(8*sizeof(int)-1) which is unimplemented. */
186         void bitShiftLeft(const BigUnsigned &a, int b);
187         void bitShiftRight(const BigUnsigned &a, int b);
188
189         /* `a.divideWithRemainder(b, q)' is like `q = a / b, a %= b'.
190          * / and % use semantics similar to Knuth's, which differ from the
191          * primitive integer semantics under division by zero.  See the
192          * implementation in BigUnsigned.cc for details.
193          * `a.divideWithRemainder(b, a)' throws an exception: it doesn't make
194          * sense to write quotient and remainder into the same variable. */
195         void divideWithRemainder(const BigUnsigned &b, BigUnsigned &q);
196
197         /* `divide' and `modulo' are no longer offered.  Use
198          * `divideWithRemainder' instead. */
199
200         // OVERLOADED RETURN-BY-VALUE OPERATORS
201         BigUnsigned operator +(const BigUnsigned &x) const;
202         BigUnsigned operator -(const BigUnsigned &x) const;
203         BigUnsigned operator *(const BigUnsigned &x) const;
204         BigUnsigned operator /(const BigUnsigned &x) const;
205         BigUnsigned operator %(const BigUnsigned &x) const;
206         /* OK, maybe unary minus could succeed in one case, but it really
207          * shouldn't be used, so it isn't provided. */
208         BigUnsigned operator &(const BigUnsigned &x) const;
209         BigUnsigned operator |(const BigUnsigned &x) const;
210         BigUnsigned operator ^(const BigUnsigned &x) const;
211         BigUnsigned operator <<(int b) const;
212         BigUnsigned operator >>(int b) const;
213
214         // OVERLOADED ASSIGNMENT OPERATORS
215         void operator +=(const BigUnsigned &x);
216         void operator -=(const BigUnsigned &x);
217         void operator *=(const BigUnsigned &x);
218         void operator /=(const BigUnsigned &x);
219         void operator %=(const BigUnsigned &x);
220         void operator &=(const BigUnsigned &x);
221         void operator |=(const BigUnsigned &x);
222         void operator ^=(const BigUnsigned &x);
223         void operator <<=(int b);
224         void operator >>=(int b);
225
226         /* INCREMENT/DECREMENT OPERATORS
227          * To discourage messy coding, these do not return *this, so prefix
228          * and postfix behave the same. */
229         void operator ++(   );
230         void operator ++(int);
231         void operator --(   );
232         void operator --(int);
233
234         // Helper function that needs access to BigUnsigned internals
235         friend Blk getShiftedBlock(const BigUnsigned &num, Index x,
236                         unsigned int y);
237
238         // See BigInteger.cc.
239         template <class X>
240         friend X convertBigUnsignedToPrimitiveAccess(const BigUnsigned &a);
241 };
242
243 /* Implementing the return-by-value and assignment operators in terms of the
244  * copy-less operations.  The copy-less operations are responsible for making
245  * any necessary temporary copies to work around aliasing. */
246
247 inline BigUnsigned BigUnsigned::operator +(const BigUnsigned &x) const {
248         BigUnsigned ans;
249         ans.add(*this, x);
250         return ans;
251 }
252 inline BigUnsigned BigUnsigned::operator -(const BigUnsigned &x) const {
253         BigUnsigned ans;
254         ans.subtract(*this, x);
255         return ans;
256 }
257 inline BigUnsigned BigUnsigned::operator *(const BigUnsigned &x) const {
258         BigUnsigned ans;
259         ans.multiply(*this, x);
260         return ans;
261 }
262 inline BigUnsigned BigUnsigned::operator /(const BigUnsigned &x) const {
263         if (x.isZero()) throw "BigUnsigned::operator /: division by zero";
264         BigUnsigned q, r;
265         r = *this;
266         r.divideWithRemainder(x, q);
267         return q;
268 }
269 inline BigUnsigned BigUnsigned::operator %(const BigUnsigned &x) const {
270         if (x.isZero()) throw "BigUnsigned::operator %: division by zero";
271         BigUnsigned q, r;
272         r = *this;
273         r.divideWithRemainder(x, q);
274         return r;
275 }
276 inline BigUnsigned BigUnsigned::operator &(const BigUnsigned &x) const {
277         BigUnsigned ans;
278         ans.bitAnd(*this, x);
279         return ans;
280 }
281 inline BigUnsigned BigUnsigned::operator |(const BigUnsigned &x) const {
282         BigUnsigned ans;
283         ans.bitOr(*this, x);
284         return ans;
285 }
286 inline BigUnsigned BigUnsigned::operator ^(const BigUnsigned &x) const {
287         BigUnsigned ans;
288         ans.bitXor(*this, x);
289         return ans;
290 }
291 inline BigUnsigned BigUnsigned::operator <<(int b) const {
292         BigUnsigned ans;
293         ans.bitShiftLeft(*this, b);
294         return ans;
295 }
296 inline BigUnsigned BigUnsigned::operator >>(int b) const {
297         BigUnsigned ans;
298         ans.bitShiftRight(*this, b);
299         return ans;
300 }
301
302 inline void BigUnsigned::operator +=(const BigUnsigned &x) {
303         add(*this, x);
304 }
305 inline void BigUnsigned::operator -=(const BigUnsigned &x) {
306         subtract(*this, x);
307 }
308 inline void BigUnsigned::operator *=(const BigUnsigned &x) {
309         multiply(*this, x);
310 }
311 inline void BigUnsigned::operator /=(const BigUnsigned &x) {
312         if (x.isZero()) throw "BigUnsigned::operator /=: division by zero";
313         /* The following technique is slightly faster than copying *this first
314          * when x is large. */
315         BigUnsigned q;
316         divideWithRemainder(x, q);
317         // *this contains the remainder, but we overwrite it with the quotient.
318         *this = q;
319 }
320 inline void BigUnsigned::operator %=(const BigUnsigned &x) {
321         if (x.isZero()) throw "BigUnsigned::operator %=: division by zero";
322         BigUnsigned q;
323         // Mods *this by x.  Don't care about quotient left in q.
324         divideWithRemainder(x, q);
325 }
326 inline void BigUnsigned::operator &=(const BigUnsigned &x) {
327         bitAnd(*this, x);
328 }
329 inline void BigUnsigned::operator |=(const BigUnsigned &x) {
330         bitOr(*this, x);
331 }
332 inline void BigUnsigned::operator ^=(const BigUnsigned &x) {
333         bitXor(*this, x);
334 }
335 inline void BigUnsigned::operator <<=(int b) {
336         bitShiftLeft(*this, b);
337 }
338 inline void BigUnsigned::operator >>=(int b) {
339         bitShiftRight(*this, b);
340 }
341
342 /* Templates for conversions of BigUnsigned to and from primitive integers.
343  * BigInteger.cc needs to instantiate convertToPrimitive, and the uses in
344  * BigUnsigned.cc didn't do the trick; I think g++ inlined convertToPrimitive
345  * instead of generating linkable instantiations.  So for consistency, I put
346  * all the templates here. */
347
348 // CONSTRUCTION FROM PRIMITIVE INTEGERS
349
350 /* Initialize this BigUnsigned from the given primitive integer.  The same
351  * pattern works for all primitive integer types, so I put it into a template to
352  * reduce code duplication.  (Don't worry: this is protected and we instantiate
353  * it only with primitive integer types.)  Type X could be signed, but x is
354  * known to be nonnegative. */
355 template <class X>
356 void BigUnsigned::initFromPrimitive(X x) {
357         if (x == 0)
358                 ; // NumberlikeArray already initialized us to zero.
359         else {
360                 // Create a single block.  blk is NULL; no need to delete it.
361                 cap = 1;
362                 blk = new Blk[1];
363                 len = 1;
364                 blk[0] = Blk(x);
365         }
366 }
367
368 /* Ditto, but first check that x is nonnegative.  I could have put the check in
369  * initFromPrimitive and let the compiler optimize it out for unsigned-type
370  * instantiations, but I wanted to avoid the warning stupidly issued by g++ for
371  * a condition that is constant in *any* instantiation, even if not in all. */
372 template <class X>
373 void BigUnsigned::initFromSignedPrimitive(X x) {
374         if (x < 0)
375                 throw "BigUnsigned constructor: "
376                         "Cannot construct a BigUnsigned from a negative number";
377         else
378                 initFromPrimitive(x);
379 }
380
381 // CONVERSION TO PRIMITIVE INTEGERS
382
383 /* Template with the same idea as initFromPrimitive.  This might be slightly
384  * slower than the previous version with the masks, but it's much shorter and
385  * clearer, which is the library's stated goal. */
386 template <class X>
387 X BigUnsigned::convertToPrimitive() const {
388         if (len == 0)
389                 // The number is zero; return zero.
390                 return 0;
391         else if (len == 1) {
392                 // The single block might fit in an X.  Try the conversion.
393                 X x = X(blk[0]);
394                 // Make sure the result accurately represents the block.
395                 if (Blk(x) == blk[0])
396                         // Successful conversion.
397                         return x;
398                 // Otherwise fall through.
399         }
400         throw "BigUnsigned::to<Primitive>: "
401                 "Value is too big to fit in the requested type";
402 }
403
404 /* Wrap the above in an x >= 0 test to make sure we got a nonnegative result,
405  * not a negative one that happened to convert back into the correct nonnegative
406  * one.  (E.g., catch incorrect conversion of 2^31 to the long -2^31.)  Again,
407  * separated to avoid a g++ warning. */
408 template <class X>
409 X BigUnsigned::convertToSignedPrimitive() const {
410         X x = convertToPrimitive<X>();
411         if (x >= 0)
412                 return x;
413         else
414                 throw "BigUnsigned::to(Primitive): "
415                         "Value is too big to fit in the requested type";
416 }
417
418 #endif