├── README.md
├── BigInteger.h
├── BigIntegerSingleFile.cpp
└── BigInteger.cpp


/README.md:
--------------------------------------------------------------------------------
 1 | BigInteger
 2 | ==========
 3 | 
 4 | An Implementation of BigInteger library in C++
 5 | 
 6 | This Project contains two versions of the library:
 7 | 
 8 | 1. Library split into .h and .cpp file. 
 9 |    Detailed Description of library functions present in .h file.
10 |    For use in projects when no boundation on number of file or size.
11 | 
12 |    Files: BigInteger.h, BigInteger.cpp
13 | 
14 | 
15 | 2. Entire Library in single file.
16 |    I removed the comments and put the code in Java indentation style
17 |    to decrease size and space.
18 |    For use in Programming Contests or places when one single file code
19 |    is required.
20 | 
21 |    File: BigIntegerSingleFile.cpp
22 | 
23 | 


--------------------------------------------------------------------------------
/BigInteger.h:
--------------------------------------------------------------------------------
 1 | #include <string>
 2 | #define MAX 10000 // for strings
 3 | 
 4 | using namespace std;
 5 | //-------------------------------------------------------------
 6 | class BigInteger
 7 | {
 8 | private:
 9 | 	string number;
10 | 	bool sign;
11 | public:
12 | 	BigInteger(); // empty constructor initializes zero
13 | 	BigInteger(string s); // "string" constructor
14 | 	BigInteger(string s, bool sin); // "string" constructor
15 | 	BigInteger(int n); // "int" constructor
16 | 	void setNumber(string s);
17 | 	const string& getNumber(); // retrieves the number
18 | 	void setSign(bool s);
19 | 	const bool& getSign();
20 | 	BigInteger absolute(); // returns the absolute value
21 | 	void operator = (BigInteger b);
22 | 	bool operator == (BigInteger b);
23 | 	bool operator != (BigInteger b);
24 | 	bool operator > (BigInteger b);
25 | 	bool operator < (BigInteger b);
26 | 	bool operator >= (BigInteger b);
27 | 	bool operator <= (BigInteger b);
28 | 	BigInteger& operator ++(); // prefix
29 | 	BigInteger  operator ++(int); // postfix
30 | 	BigInteger& operator --(); // prefix
31 | 	BigInteger  operator --(int); // postfix
32 | 	BigInteger operator + (BigInteger b);
33 | 	BigInteger operator - (BigInteger b);
34 | 	BigInteger operator * (BigInteger b);
35 | 	BigInteger operator / (BigInteger b);
36 | 	BigInteger operator % (BigInteger b);
37 | 	BigInteger& operator += (BigInteger b);
38 | 	BigInteger& operator -= (BigInteger b);
39 | 	BigInteger& operator *= (BigInteger b);
40 | 	BigInteger& operator /= (BigInteger b);
41 | 	BigInteger& operator %= (BigInteger b);
42 | 	BigInteger& operator [] (int n);
43 | 	BigInteger operator -(); // unary minus sign
44 | 	operator string(); // for conversion from BigInteger to string
45 | private:
46 | 	bool equals(BigInteger n1, BigInteger n2);
47 | 	bool less(BigInteger n1, BigInteger n2);
48 | 	bool greater(BigInteger n1, BigInteger n2);
49 | 	string add(string number1, string number2);
50 | 	string subtract(string number1, string number2);
51 | 	string multiply(string n1, string n2);
52 | 	pair<string, long long> divide(string n, long long den);
53 | 	string toString(long long n);
54 | 	long long toInt(string s);
55 | };
56 | 
57 | 


--------------------------------------------------------------------------------
/BigIntegerSingleFile.cpp:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * @author panks
  3 |  * Big Integer library in C++, single file implementation.
  4 |  */
  5 | #include <iostream>
  6 | #include <string>
  7 | #include <sstream>
  8 | #include <cmath>
  9 | #define MAX 10000 // for strings
 10 | 
 11 | using namespace std;
 12 | class BigInteger {
 13 | private:
 14 |     string number;
 15 |     bool sign;
 16 | public:
 17 |     BigInteger(); // empty constructor initializes zero
 18 |     BigInteger(string s); // "string" constructor
 19 |     BigInteger(string s, bool sin); // "string" constructor
 20 |     BigInteger(int n); // "int" constructor
 21 |     void setNumber(string s);
 22 |     const string& getNumber(); // retrieves the number
 23 |     void setSign(bool s);
 24 |     const bool& getSign();
 25 |     BigInteger absolute(); // returns the absolute value
 26 |     void operator = (BigInteger b);
 27 |     bool operator == (BigInteger b);
 28 |     bool operator != (BigInteger b);
 29 |     bool operator > (BigInteger b);
 30 |     bool operator < (BigInteger b);
 31 |     bool operator >= (BigInteger b);
 32 |     bool operator <= (BigInteger b);
 33 |     BigInteger& operator ++(); // prefix
 34 |     BigInteger  operator ++(int); // postfix
 35 |     BigInteger& operator --(); // prefix
 36 |     BigInteger  operator --(int); // postfix
 37 |     BigInteger operator + (BigInteger b);
 38 |     BigInteger operator - (BigInteger b);
 39 |     BigInteger operator * (BigInteger b);
 40 |     BigInteger operator / (BigInteger b);
 41 |     BigInteger operator % (BigInteger b);
 42 |     BigInteger& operator += (BigInteger b);
 43 |     BigInteger& operator -= (BigInteger b);
 44 |     BigInteger& operator *= (BigInteger b);
 45 |     BigInteger& operator /= (BigInteger b);
 46 |     BigInteger& operator %= (BigInteger b);
 47 |     BigInteger& operator [] (int n);
 48 |     BigInteger operator -(); // unary minus sign
 49 |     operator string(); // for conversion from BigInteger to string
 50 | private:
 51 |     bool equals(BigInteger n1, BigInteger n2);
 52 |     bool less(BigInteger n1, BigInteger n2);
 53 |     bool greater(BigInteger n1, BigInteger n2);
 54 |     string add(string number1, string number2);
 55 |     string subtract(string number1, string number2);
 56 |     string multiply(string n1, string n2);
 57 |     pair<string, long long> divide(string n, long long den);
 58 |     string toString(long long n);
 59 |     long long toInt(string s);
 60 | };
 61 | 
 62 | int main() {
 63 |     //Your Code Here
 64 |     return 0;
 65 | }
 66 | 
 67 | //------------------------------------------------------------------------------
 68 | 
 69 | BigInteger::BigInteger() { // empty constructor initializes zero
 70 |     number = "0";
 71 |     sign = false;
 72 | }
 73 | 
 74 | BigInteger::BigInteger(string s) { // "string" constructor
 75 |     if( isdigit(s[0]) ) { // if not signed
 76 |         setNumber(s);
 77 |         sign = false; // +ve
 78 |     } else {
 79 |         setNumber( s.substr(1) );
 80 |         sign = (s[0] == '-');
 81 |     }
 82 | }
 83 | 
 84 | BigInteger::BigInteger(string s, bool sin) { // "string" constructor
 85 |     setNumber( s );
 86 |     setSign( sin );
 87 | }
 88 | 
 89 | BigInteger::BigInteger(int n) { // "int" constructor
 90 |     stringstream ss;
 91 |     string s;
 92 |     ss << n;
 93 |     ss >> s;
 94 | 
 95 | 
 96 |     if( isdigit(s[0]) ) { // if not signed
 97 |         setNumber( s );
 98 |         setSign( false ); // +ve
 99 |     } else {
100 |         setNumber( s.substr(1) );
101 |         setSign( s[0] == '-' );
102 |     }
103 | }
104 | 
105 | void BigInteger::setNumber(string s) {
106 |     number = s;
107 | }
108 | 
109 | const string& BigInteger::getNumber() { // retrieves the number
110 |     return number;
111 | }
112 | 
113 | void BigInteger::setSign(bool s) {
114 |     sign = s;
115 | }
116 | 
117 | const bool& BigInteger::getSign() {
118 |     return sign;
119 | }
120 | 
121 | BigInteger BigInteger::absolute() {
122 |     return BigInteger( getNumber() ); // +ve by default
123 | }
124 | 
125 | void BigInteger::operator = (BigInteger b) {
126 |     setNumber( b.getNumber() );
127 |     setSign( b.getSign() );
128 | }
129 | 
130 | bool BigInteger::operator == (BigInteger b) {
131 |     return equals((*this) , b);
132 | }
133 | 
134 | bool BigInteger::operator != (BigInteger b) {
135 |     return ! equals((*this) , b);
136 | }
137 | 
138 | bool BigInteger::operator > (BigInteger b) {
139 |     return greater((*this) , b);
140 | }
141 | 
142 | bool BigInteger::operator < (BigInteger b) {
143 |     return less((*this) , b);
144 | }
145 | 
146 | bool BigInteger::operator >= (BigInteger b) {
147 |     return equals((*this) , b)
148 |            || greater((*this), b);
149 | }
150 | 
151 | bool BigInteger::operator <= (BigInteger b) {
152 |     return equals((*this) , b)
153 |            || less((*this) , b);
154 | }
155 | 
156 | BigInteger& BigInteger::operator ++() { // prefix
157 |     (*this) = (*this) + 1;
158 |     return (*this);
159 | }
160 | 
161 | BigInteger BigInteger::operator ++(int) { // postfix
162 |     BigInteger before = (*this);
163 | 
164 |     (*this) = (*this) + 1;
165 | 
166 |     return before;
167 | }
168 | 
169 | BigInteger& BigInteger::operator --() { // prefix
170 |     (*this) = (*this) - 1;
171 |     return (*this);
172 | 
173 | }
174 | 
175 | BigInteger BigInteger::operator --(int) { // postfix
176 |     BigInteger before = (*this);
177 | 
178 |     (*this) = (*this) - 1;
179 | 
180 |     return before;
181 | }
182 | 
183 | BigInteger BigInteger::operator + (BigInteger b) {
184 |     BigInteger addition;
185 |     if( getSign() == b.getSign() ) { // both +ve or -ve
186 |         addition.setNumber( add(getNumber(), b.getNumber() ) );
187 |         addition.setSign( getSign() );
188 |     } else { // sign different
189 |         if( absolute() > b.absolute() ) {
190 |             addition.setNumber( subtract(getNumber(), b.getNumber() ) );
191 |             addition.setSign( getSign() );
192 |         } else {
193 |             addition.setNumber( subtract(b.getNumber(), getNumber() ) );
194 |             addition.setSign( b.getSign() );
195 |         }
196 |     }
197 |     if(addition.getNumber() == "0") // avoid (-0) problem
198 |         addition.setSign(false);
199 | 
200 |     return addition;
201 | }
202 | 
203 | BigInteger BigInteger::operator - (BigInteger b) {
204 |     b.setSign( ! b.getSign() ); // x - y = x + (-y)
205 |     return (*this) + b;
206 | }
207 | 
208 | BigInteger BigInteger::operator * (BigInteger b) {
209 |     BigInteger mul;
210 | 
211 |     mul.setNumber( multiply(getNumber(), b.getNumber() ) );
212 |     mul.setSign( getSign() != b.getSign() );
213 | 
214 |     if(mul.getNumber() == "0") // avoid (-0) problem
215 |         mul.setSign(false);
216 | 
217 |     return mul;
218 | }
219 | 
220 | // Warning: Denomerator must be within "long long" size not "BigInteger"
221 | BigInteger BigInteger::operator / (BigInteger b) {
222 |     long long den = toInt( b.getNumber() );
223 |     BigInteger div;
224 | 
225 |     div.setNumber( divide(getNumber(), den).first );
226 |     div.setSign( getSign() != b.getSign() );
227 | 
228 |     if(div.getNumber() == "0") // avoid (-0) problem
229 |         div.setSign(false);
230 | 
231 |     return div;
232 | }
233 | 
234 | // Warning: Denomerator must be within "long long" size not "BigInteger"
235 | BigInteger BigInteger::operator % (BigInteger b) {
236 |     long long den = toInt( b.getNumber() );
237 | 
238 |     BigInteger rem;
239 |     long long rem_int = divide(number, den).second;
240 |     rem.setNumber( toString(rem_int) );
241 |     rem.setSign( getSign() != b.getSign() );
242 | 
243 |     if(rem.getNumber() == "0") // avoid (-0) problem
244 |         rem.setSign(false);
245 | 
246 |     return rem;
247 | }
248 | 
249 | BigInteger& BigInteger::operator += (BigInteger b) {
250 |     (*this) = (*this) + b;
251 |     return (*this);
252 | }
253 | 
254 | BigInteger& BigInteger::operator -= (BigInteger b) {
255 |     (*this) = (*this) - b;
256 |     return (*this);
257 | }
258 | 
259 | BigInteger& BigInteger::operator *= (BigInteger b) {
260 |     (*this) = (*this) * b;
261 |     return (*this);
262 | }
263 | 
264 | BigInteger& BigInteger::operator /= (BigInteger b) {
265 |     (*this) = (*this) / b;
266 |     return (*this);
267 | }
268 | 
269 | BigInteger& BigInteger::operator %= (BigInteger b) {
270 |     (*this) = (*this) % b;
271 |     return (*this);
272 | }
273 | 
274 | BigInteger& BigInteger::operator [] (int n) {
275 |     return *(this + (n*sizeof(BigInteger)));
276 | }
277 | 
278 | BigInteger BigInteger::operator -() { // unary minus sign
279 |     return (*this) * -1;
280 | }
281 | 
282 | BigInteger::operator string() { // for conversion from BigInteger to string
283 |     string signedString = ( getSign() ) ? "-" : ""; // if +ve, don't print + sign
284 |     signedString += number;
285 |     return signedString;
286 | }
287 | 
288 | bool BigInteger::equals(BigInteger n1, BigInteger n2) {
289 |     return n1.getNumber() == n2.getNumber()
290 |            && n1.getSign() == n2.getSign();
291 | }
292 | 
293 | bool BigInteger::less(BigInteger n1, BigInteger n2) {
294 |     bool sign1 = n1.getSign();
295 |     bool sign2 = n2.getSign();
296 | 
297 |     if(sign1 && ! sign2) // if n1 is -ve and n2 is +ve
298 |         return true;
299 | 
300 |     else if(! sign1 && sign2)
301 |         return false;
302 | 
303 |     else if(! sign1) { // both +ve
304 |         if(n1.getNumber().length() < n2.getNumber().length() )
305 |             return true;
306 |         if(n1.getNumber().length() > n2.getNumber().length() )
307 |             return false;
308 |         return n1.getNumber() < n2.getNumber();
309 |     } else { // both -ve
310 |         if(n1.getNumber().length() > n2.getNumber().length())
311 |             return true;
312 |         if(n1.getNumber().length() < n2.getNumber().length())
313 |             return false;
314 |         return n1.getNumber().compare( n2.getNumber() ) > 0; // greater with -ve sign is LESS
315 |     }
316 | }
317 | 
318 | bool BigInteger::greater(BigInteger n1, BigInteger n2) {
319 |     return ! equals(n1, n2) && ! less(n1, n2);
320 | }
321 | 
322 | string BigInteger::add(string number1, string number2) {
323 |     string add = (number1.length() > number2.length()) ?  number1 : number2;
324 |     char carry = '0';
325 |     int differenceInLength = abs( (int) (number1.size() - number2.size()) );
326 | 
327 |     if(number1.size() > number2.size())
328 |         number2.insert(0, differenceInLength, '0'); // put zeros from left
329 | 
330 |     else// if(number1.size() < number2.size())
331 |         number1.insert(0, differenceInLength, '0');
332 | 
333 |     for(int i=number1.size()-1; i>=0; --i) {
334 |         add[i] = ((carry-'0')+(number1[i]-'0')+(number2[i]-'0')) + '0';
335 | 
336 |         if(i != 0) {
337 |             if(add[i] > '9') {
338 |                 add[i] -= 10;
339 |                 carry = '1';
340 |             } else
341 |                 carry = '0';
342 |         }
343 |     }
344 |     if(add[0] > '9') {
345 |         add[0]-= 10;
346 |         add.insert(0,1,'1');
347 |     }
348 |     return add;
349 | }
350 | 
351 | string BigInteger::subtract(string number1, string number2) {
352 |     string sub = (number1.length()>number2.length())? number1 : number2;
353 |     int differenceInLength = abs( (int)(number1.size() - number2.size()) );
354 | 
355 |     if(number1.size() > number2.size())
356 |         number2.insert(0, differenceInLength, '0');
357 | 
358 |     else
359 |         number1.insert(0, differenceInLength, '0');
360 | 
361 |     for(int i=number1.length()-1; i>=0; --i) {
362 |         if(number1[i] < number2[i]) {
363 |             number1[i] += 10;
364 |             number1[i-1]--;
365 |         }
366 |         sub[i] = ((number1[i]-'0')-(number2[i]-'0')) + '0';
367 |     }
368 | 
369 |     while(sub[0]=='0' && sub.length()!=1) // erase leading zeros
370 |         sub.erase(0,1);
371 | 
372 |     return sub;
373 | }
374 | 
375 | string BigInteger::multiply(string n1, string n2) {
376 |     if(n1.length() > n2.length())
377 |         n1.swap(n2);
378 | 
379 |     string res = "0";
380 |     for(int i=n1.length()-1; i>=0; --i) {
381 |         string temp = n2;
382 |         int currentDigit = n1[i]-'0';
383 |         int carry = 0;
384 | 
385 |         for(int j=temp.length()-1; j>=0; --j) {
386 |             temp[j] = ((temp[j]-'0') * currentDigit) + carry;
387 | 
388 |             if(temp[j] > 9) {
389 |                 carry = (temp[j]/10);
390 |                 temp[j] -= (carry*10);
391 |             } else
392 |                 carry = 0;
393 | 
394 |             temp[j] += '0'; // back to string mood
395 |         }
396 | 
397 |         if(carry > 0)
398 |             temp.insert(0, 1, (carry+'0'));
399 | 
400 |         temp.append((n1.length()-i-1), '0'); // as like mult by 10, 100, 1000, 10000 and so on
401 | 
402 |         res = add(res, temp); // O(n)
403 |     }
404 | 
405 |     while(res[0] == '0' && res.length()!=1) // erase leading zeros
406 |         res.erase(0,1);
407 | 
408 |     return res;
409 | }
410 | 
411 | pair<string, long long> BigInteger::divide(string n, long long den) {
412 |     long long rem = 0;
413 |     string result;
414 |     result.resize(MAX);
415 | 
416 |     for(int indx=0, len = n.length(); indx<len; ++indx) {
417 |         rem = (rem * 10) + (n[indx] - '0');
418 |         result[indx] = rem / den + '0';
419 |         rem %= den;
420 |     }
421 |     result.resize( n.length() );
422 | 
423 |     while( result[0] == '0' && result.length() != 1)
424 |         result.erase(0,1);
425 | 
426 |     if(result.length() == 0)
427 |         result = "0";
428 | 
429 |     return make_pair(result, rem);
430 | }
431 | 
432 | string BigInteger::toString(long long n) {
433 |     stringstream ss;
434 |     string temp;
435 | 
436 |     ss << n;
437 |     ss >> temp;
438 | 
439 |     return temp;
440 | }
441 | 
442 | long long BigInteger::toInt(string s) {
443 |     long long sum = 0;
444 | 
445 |     for(int i=0; i<s.length(); i++)
446 |         sum = (sum*10) + (s[i] - '0');
447 | 
448 |     return sum;
449 | }
450 | 
451 | 


--------------------------------------------------------------------------------
/BigInteger.cpp:
--------------------------------------------------------------------------------
  1 | #ifndef BIGINTEGER_H
  2 | #define BIGINTEGER_H
  3 | 
  4 | #include <iostream>
  5 | #include <string>
  6 | #include <sstream>
  7 | #include <cmath>
  8 | #include "BigInteger.h"
  9 | #define MAX 10000 // for strings
 10 | 
 11 | BigInteger::BigInteger() // empty constructor initializes zero
 12 | {
 13 | 	number = "0";
 14 | 	sign = false;
 15 | }
 16 | //-------------------------------------------------------------
 17 | BigInteger::BigInteger(string s) // "string" constructor
 18 | {
 19 | 	if( isdigit(s[0]) ) // if not signed
 20 | 	{
 21 | 		setNumber(s);
 22 | 		sign = false; // +ve
 23 | 	}
 24 | 	else
 25 | 	{
 26 | 		setNumber( s.substr(1) );
 27 | 		sign = (s[0] == '-');
 28 | 	}
 29 | }
 30 | //-------------------------------------------------------------
 31 | BigInteger::BigInteger(string s, bool sin) // "string" constructor
 32 | {
 33 | 	setNumber( s );
 34 | 	setSign( sin );
 35 | }
 36 | //-------------------------------------------------------------
 37 | BigInteger::BigInteger(int n) // "int" constructor
 38 | {
 39 | 	stringstream ss;
 40 | 	string s;
 41 | 	ss << n;
 42 | 	ss >> s;
 43 | 
 44 | 
 45 | 	if( isdigit(s[0]) ) // if not signed
 46 | 	{
 47 | 		setNumber( s );
 48 | 		setSign( false ); // +ve
 49 | 	}
 50 | 	else
 51 | 	{
 52 | 		setNumber( s.substr(1) );
 53 | 		setSign( s[0] == '-' );
 54 | 	}
 55 | }
 56 | //-------------------------------------------------------------
 57 | void BigInteger::setNumber(string s)
 58 | {
 59 | 	number = s;
 60 | }
 61 | //-------------------------------------------------------------
 62 | const string& BigInteger::getNumber() // retrieves the number
 63 | {
 64 | 	return number;
 65 | }
 66 | //-------------------------------------------------------------
 67 | void BigInteger::setSign(bool s)
 68 | {
 69 | 	sign = s;
 70 | }
 71 | //-------------------------------------------------------------
 72 | const bool& BigInteger::getSign()
 73 | {
 74 | 	return sign;
 75 | }
 76 | //-------------------------------------------------------------
 77 | // returns the absolute value
 78 | BigInteger BigInteger::absolute()
 79 | {
 80 | 	return BigInteger( getNumber() ); // +ve by default
 81 | }
 82 | //-------------------------------------------------------------
 83 | void BigInteger::operator = (BigInteger b)
 84 | {
 85 | 	setNumber( b.getNumber() );
 86 | 	setSign( b.getSign() );
 87 | }
 88 | //-------------------------------------------------------------
 89 | bool BigInteger::operator == (BigInteger b)
 90 | {
 91 | 	return equals((*this) , b);
 92 | }
 93 | //-------------------------------------------------------------
 94 | bool BigInteger::operator != (BigInteger b)
 95 | {
 96 | 	return ! equals((*this) , b);
 97 | }
 98 | //-------------------------------------------------------------
 99 | bool BigInteger::operator > (BigInteger b)
100 | {
101 | 	return greater((*this) , b);
102 | }
103 | //-------------------------------------------------------------
104 | bool BigInteger::operator < (BigInteger b)
105 | {
106 | 	return less((*this) , b);
107 | }
108 | //-------------------------------------------------------------
109 | bool BigInteger::operator >= (BigInteger b)
110 | {
111 | 	return equals((*this) , b)
112 | 		|| greater((*this), b);
113 | }
114 | //-------------------------------------------------------------
115 | bool BigInteger::operator <= (BigInteger b)
116 | {
117 | 	return equals((*this) , b) 
118 | 		|| less((*this) , b);
119 | }
120 | //-------------------------------------------------------------
121 | // increments the value, then returns its value
122 | BigInteger& BigInteger::operator ++() // prefix
123 | {
124 | 	(*this) = (*this) + 1;
125 | 	return (*this);
126 | }
127 | //-------------------------------------------------------------
128 | // returns the value, then increments its value
129 | BigInteger BigInteger::operator ++(int) // postfix
130 | {
131 | 	BigInteger before = (*this);
132 | 
133 | 	(*this) = (*this) + 1;
134 | 
135 | 	return before;
136 | }
137 | //-------------------------------------------------------------
138 | // decrements the value, then return it
139 | BigInteger& BigInteger::operator --() // prefix
140 | {
141 | 	(*this) = (*this) - 1;
142 | 	return (*this);
143 | 
144 | }
145 | //-------------------------------------------------------------
146 | // return the value, then decrements it
147 | BigInteger BigInteger::operator --(int) // postfix
148 | {	
149 | 	BigInteger before = (*this);
150 | 
151 | 	(*this) = (*this) - 1;
152 | 
153 | 	return before;
154 | }
155 | //-------------------------------------------------------------
156 | BigInteger BigInteger::operator + (BigInteger b)
157 | {
158 | 	BigInteger addition;
159 | 	if( getSign() == b.getSign() ) // both +ve or -ve
160 | 	{
161 | 		addition.setNumber( add(getNumber(), b.getNumber() ) );
162 | 		addition.setSign( getSign() );
163 | 	}
164 | 	else // sign different
165 | 	{
166 | 		if( absolute() > b.absolute() )
167 | 		{
168 | 			addition.setNumber( subtract(getNumber(), b.getNumber() ) );
169 | 			addition.setSign( getSign() );
170 | 		}
171 | 		else
172 | 		{
173 | 			addition.setNumber( subtract(b.getNumber(), getNumber() ) );
174 | 			addition.setSign( b.getSign() );
175 | 		}
176 | 	}
177 | 	if(addition.getNumber() == "0") // avoid (-0) problem
178 | 		addition.setSign(false);
179 | 
180 | 	return addition;
181 | }
182 | //-------------------------------------------------------------
183 | BigInteger BigInteger::operator - (BigInteger b)
184 | {
185 | 	b.setSign( ! b.getSign() ); // x - y = x + (-y)
186 | 	return (*this) + b;
187 | }
188 | //-------------------------------------------------------------
189 | BigInteger BigInteger::operator * (BigInteger b)
190 | {
191 | 	BigInteger mul;
192 | 
193 | 	mul.setNumber( multiply(getNumber(), b.getNumber() ) );
194 | 	mul.setSign( getSign() != b.getSign() );
195 | 
196 | 	if(mul.getNumber() == "0") // avoid (-0) problem
197 | 		mul.setSign(false);
198 | 
199 | 	return mul;
200 | }
201 | //-------------------------------------------------------------
202 | // Warning: Denomerator must be within "long long" size not "BigInteger"
203 | BigInteger BigInteger::operator / (BigInteger b)
204 | {
205 | 	long long den = toInt( b.getNumber() );
206 | 	BigInteger div;
207 | 
208 | 	div.setNumber( divide(getNumber(), den).first );
209 | 	div.setSign( getSign() != b.getSign() );
210 | 
211 | 	if(div.getNumber() == "0") // avoid (-0) problem
212 | 		div.setSign(false);
213 | 
214 | 	return div;
215 | }
216 | //-------------------------------------------------------------
217 | // Warning: Denomerator must be within "long long" size not "BigInteger"
218 | BigInteger BigInteger::operator % (BigInteger b)
219 | {
220 | 	long long den = toInt( b.getNumber() );
221 | 
222 | 	BigInteger rem;
223 | 	long long rem_int = divide(number, den).second;
224 | 	rem.setNumber( toString(rem_int) );
225 | 	rem.setSign( getSign() != b.getSign() );
226 | 
227 | 	if(rem.getNumber() == "0") // avoid (-0) problem
228 | 		rem.setSign(false);
229 | 
230 | 	return rem;
231 | }
232 | //-------------------------------------------------------------
233 | BigInteger& BigInteger::operator += (BigInteger b)
234 | {
235 | 	(*this) = (*this) + b;
236 | 	return (*this);
237 | }
238 | //-------------------------------------------------------------
239 | BigInteger& BigInteger::operator -= (BigInteger b)
240 | {
241 | 	(*this) = (*this) - b;
242 | 	return (*this);
243 | }
244 | //-------------------------------------------------------------
245 | BigInteger& BigInteger::operator *= (BigInteger b)
246 | {
247 | 	(*this) = (*this) * b;
248 | 	return (*this);
249 | }
250 | //-------------------------------------------------------------
251 | BigInteger& BigInteger::operator /= (BigInteger b)
252 | {
253 | 	(*this) = (*this) / b;
254 | 	return (*this);
255 | }
256 | //-------------------------------------------------------------
257 | BigInteger& BigInteger::operator %= (BigInteger b)
258 | {
259 | 	(*this) = (*this) % b;
260 | 	return (*this);
261 | }
262 | //-------------------------------------------------------------
263 | BigInteger& BigInteger::operator [] (int n)
264 | {
265 | 	return *(this + (n*sizeof(BigInteger)));
266 | }
267 | //-------------------------------------------------------------
268 | BigInteger BigInteger::operator -() // unary minus sign
269 | {
270 | 	return (*this) * -1;
271 | }
272 | //-------------------------------------------------------------
273 | BigInteger::operator string() // for conversion from BigInteger to string
274 | {
275 | 	string signedString = ( getSign() ) ? "-" : ""; // if +ve, don't print + sign
276 | 	signedString += number;
277 | 	return signedString;
278 | }
279 | //-------------------------------------------------------------
280 | 
281 | bool BigInteger::equals(BigInteger n1, BigInteger n2)
282 | {
283 | 	return n1.getNumber() == n2.getNumber()
284 | 		&& n1.getSign() == n2.getSign();
285 | }
286 | 
287 | //-------------------------------------------------------------
288 | bool BigInteger::less(BigInteger n1, BigInteger n2)
289 | {
290 | 	bool sign1 = n1.getSign();
291 | 	bool sign2 = n2.getSign();
292 | 
293 | 	if(sign1 && ! sign2) // if n1 is -ve and n2 is +ve
294 | 		return true;
295 | 
296 | 	else if(! sign1 && sign2)
297 | 		return false;
298 | 
299 | 	else if(! sign1) // both +ve
300 | 	{
301 | 		if(n1.getNumber().length() < n2.getNumber().length() )
302 | 			return true;
303 | 		if(n1.getNumber().length() > n2.getNumber().length() )
304 | 			return false;
305 | 		return n1.getNumber() < n2.getNumber();
306 | 	}
307 | 	else // both -ve
308 | 	{
309 | 		if(n1.getNumber().length() > n2.getNumber().length())
310 | 			return true;
311 | 		if(n1.getNumber().length() < n2.getNumber().length())
312 | 			return false;
313 | 		return n1.getNumber().compare( n2.getNumber() ) > 0; // greater with -ve sign is LESS
314 | 	}
315 | }
316 | //-------------------------------------------------------------
317 | bool BigInteger::greater(BigInteger n1, BigInteger n2)
318 | {
319 | 	return ! equals(n1, n2) && ! less(n1, n2);
320 | }
321 | 
322 | //-------------------------------------------------------------
323 | // adds two strings and returns their sum in as a string
324 | string BigInteger::add(string number1, string number2)
325 | {
326 | 	string add = (number1.length() > number2.length()) ?  number1 : number2;
327 | 	char carry = '0';
328 | 	int differenceInLength = abs( (int) (number1.size() - number2.size()) );
329 | 
330 | 	if(number1.size() > number2.size())
331 | 		number2.insert(0, differenceInLength, '0'); // put zeros from left
332 | 
333 | 	else// if(number1.size() < number2.size())
334 | 		number1.insert(0, differenceInLength, '0');
335 | 
336 | 	for(int i=number1.size()-1; i>=0; --i)
337 | 	{
338 | 		add[i] = ((carry-'0')+(number1[i]-'0')+(number2[i]-'0')) + '0';
339 | 
340 | 		if(i != 0)
341 | 		{	
342 | 			if(add[i] > '9')
343 | 			{
344 | 				add[i] -= 10;
345 | 				carry = '1';
346 | 			}
347 | 			else
348 | 				carry = '0';
349 | 		}
350 | 	}
351 | 	if(add[0] > '9')
352 | 	{
353 | 		add[0]-= 10;
354 | 		add.insert(0,1,'1');
355 | 	}
356 | 	return add;
357 | }
358 | 
359 | //-------------------------------------------------------------
360 | // subtracts two strings and returns their sum in as a string
361 | string BigInteger::subtract(string number1, string number2)
362 | {
363 | 	string sub = (number1.length()>number2.length())? number1 : number2;
364 | 	int differenceInLength = abs( (int)(number1.size() - number2.size()) );
365 | 
366 | 	if(number1.size() > number2.size())	
367 | 		number2.insert(0, differenceInLength, '0');
368 | 
369 | 	else
370 | 		number1.insert(0, differenceInLength, '0');
371 | 
372 | 	for(int i=number1.length()-1; i>=0; --i)
373 | 	{
374 | 		if(number1[i] < number2[i])
375 | 		{
376 | 			number1[i] += 10;
377 | 			number1[i-1]--;
378 | 		}
379 | 		sub[i] = ((number1[i]-'0')-(number2[i]-'0')) + '0';
380 | 	}
381 | 
382 | 	while(sub[0]=='0' && sub.length()!=1) // erase leading zeros
383 | 		sub.erase(0,1);
384 | 
385 | 	return sub;
386 | }
387 | 
388 | //-------------------------------------------------------------
389 | // multiplies two strings and returns their sum in as a string
390 | string BigInteger::multiply(string n1, string n2)
391 | {
392 | 	if(n1.length() > n2.length()) 
393 | 		n1.swap(n2);
394 | 
395 | 	string res = "0";
396 | 	for(int i=n1.length()-1; i>=0; --i)
397 | 	{
398 | 		string temp = n2;
399 | 		int currentDigit = n1[i]-'0';
400 | 		int carry = 0;
401 | 
402 | 		for(int j=temp.length()-1; j>=0; --j)
403 | 		{
404 | 			temp[j] = ((temp[j]-'0') * currentDigit) + carry;
405 | 
406 | 			if(temp[j] > 9)
407 | 			{
408 | 				carry = (temp[j]/10);
409 | 				temp[j] -= (carry*10);
410 | 			}
411 | 			else
412 | 				carry = 0;
413 | 
414 | 			temp[j] += '0'; // back to string mood
415 | 		}
416 | 
417 | 		if(carry > 0)
418 | 			temp.insert(0, 1, (carry+'0'));
419 | 		
420 | 		temp.append((n1.length()-i-1), '0'); // as like mult by 10, 100, 1000, 10000 and so on
421 | 
422 | 		res = add(res, temp); // O(n)
423 | 	}
424 | 
425 | 	while(res[0] == '0' && res.length()!=1) // erase leading zeros
426 | 		res.erase(0,1);
427 | 
428 | 	return res;
429 | }
430 | 
431 | //-------------------------------------------------------------
432 | // divides string on long long, returns pair(qutiont, remainder)
433 | pair<string, long long> BigInteger::divide(string n, long long den)
434 | {
435 | 	long long rem = 0;
436 | 	string result; result.resize(MAX);
437 | 	
438 | 	for(int indx=0, len = n.length(); indx<len; ++indx)
439 | 	{
440 | 		rem = (rem * 10) + (n[indx] - '0');
441 | 		result[indx] = rem / den + '0';
442 | 		rem %= den;
443 | 	}
444 | 	result.resize( n.length() );
445 | 
446 | 	while( result[0] == '0' && result.length() != 1)
447 | 		result.erase(0,1);
448 | 
449 | 	if(result.length() == 0)
450 | 		result = "0";
451 | 
452 | 	return make_pair(result, rem);
453 | }
454 | 
455 | //-------------------------------------------------------------
456 | // converts long long to string
457 | string BigInteger::toString(long long n)
458 | {
459 | 	stringstream ss;
460 | 	string temp;
461 | 
462 | 	ss << n;
463 | 	ss >> temp;
464 | 
465 | 	return temp;
466 | }
467 | 
468 | //-------------------------------------------------------------
469 | // converts string to long long
470 | long long BigInteger::toInt(string s)
471 | {
472 | 	long long sum = 0;
473 | 
474 | 	for(int i=0; i<s.length(); i++)
475 | 		sum = (sum*10) + (s[i] - '0');
476 | 
477 | 	return sum;
478 | }
479 | 
480 | #endif
481 | 


--------------------------------------------------------------------------------