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