bigint

Big Integer Library for C++

1 Million digits? 1 Billion? 1 Trillion? No Worries. This Library can handle any Integer of any Length.

bigint is a C++ library which can handle Very very Big Integers. It can calculate factorial of 1000000... it can go any big. It may be useful in Competitive Coding and Scientific Calculations which deals with very very large Integers. It can also be used in Decryption process. It has many inbuilt functions which can be very useful.

---

How to use it?

Download bigint header and include in your C++ program.

#include "bigint.h"     // with proper file path 

---

Declaring and Intializing Variables.

Declartion is done like making object of bigint class. Intialization can be done by passing String or Integer or Long type at Object creation.

bigint a("56654250564056135415631554531554513813");     // big integer initialization with String
bigint b("60820564691661355463515465564664568");        // big integer initialization with String
bigint d(956486133);                                    // big integer intialization with Integer

---

Addition

Addition can be done as it is done with general integer types of variables.

• (Note : variable's value and declaration will be followed as it goes.)

bigint c = a + b;                         // Addition, with both operand as bigint
cout << c << std::endl;     // Output : 56715071128747796771095069997119178381

c = a + 56242;                            // Addition, with one operand as bigint and other as integer
cout << c << std::endl;     // Output : 56654250564056135415631554531554570055

c = 52 + 98;                              // Addition, with both operand as integers.
cout << c << std::endl;     // Ouput : 150

c = c + a + b;                            // Addition, with multiple operands
cout << c << std::endl;     // Output : 56715071128747796771095069997119178531

---

Subtraction

Subtraction can be done as it is done with general integer types variables.

c = a - b;                                 // Subtraction, with both operand as bigint
cout << c << std::endl;     // Ouput : 56593429999364474060168039065989849245

c = a - 56242;                            // Subtraction, with one operand as bigint and other as integer
cout << c << std::endl;     // Output : 56654250564056135415631554531554457571

c = 52 - 98;                              // Subtraction, with both operand as integers.
cout << c << std::endl;     // Output : -46

c = c - a - b;                            // Subtraction, with multiple operands
cout << c << std::endl;     // Output : -56715071128747796771095069997119178427

---

Multiplication

Multiplication can be done as it is done with general integer types variables.

c = a * b;                                 // Multiplication, with both operand as bigint
cout << c << std::endl;     // Output : 3445743511488768021543787806860750328299778111849236444610289955667677784

c = a * 56242;                            // Multiplication, with one operand as bigint and other as integer
cout << c << std::endl;     // Output : 3186348360223645168045949889963688965870746

c = 52 * 98;                              // Multiplication, with both operand as integers.
cout << c << std::endl;     // Output : 5096

c = c * a * b;                            // Multiplication, with multiple operands
cout << c << std::endl;     // Output : 17559508934546761837787142663762383673015669257983708921734037614082485987264

---

Division

Division can be done as it is done with general integer types variables.

c = a / b;                                 // Divison, with both operand as bigint
cout << c << std::endl;     // Output : 931

c = a / 56242;                            // Divison, with one operand as bigint and other as integer
cout << c << std::endl;     // Output : 1007329941397107773827949833426167

c = 98 / 56;                              // Divison, with both operand as integers.
cout << c << std::endl;     // Output : 1

c = a / b / c;                            // Divison, with multiple operands
cout << c << std::endl;     // Output : 931

---

Mod

Mod can be done as it is done with general integer types variables.

c = a % b;                                 // mod, with both operand as bigint
cout << c << std::endl;     // Output : 56654250564056135415631554531554513813

c = a % 56242;                            // mod, with one operand as bigint and other as integer
cout << c << std::endl;     // Output : 29399

c = 98 % 56;                              // mod, with both operand as integers.
cout << c << std::endl;        // output : 42

c = a % b % c;                            // mod, with multiple operands
cout << c << std::endl;     // Output : 41

---

Conditional Statements

Conditionals can be used as it is done with general integer types variables. Supports : > , < , >= , <= , == , !=

if(a > b) {
    cout << "a is greater than b" << std::endl;     // It executes
} else {
    cout << "a is smaller than b" << std::endl;     // It does not executes
}

if(a != b) {
    cout << "a is not equal to b" << std::endl;     // It executes
} else {
    cout << "a is equal to b" << std::endl;         // It does not executes
}

---

In-built Functions

to_bigint(string) or to_bigint(int) or to_bigint(long) - to bigint function

It takes one argument as string or int or long or long long and converts and return bigint of that particular argument provided.

b = to_bigint("56");

---

big_abs(bigint) - absolute function

It takes bigint as argument and return type is also bigint.

cout << big_abs(b) << std::endl;    // Output : 60820564691661355463515465564664568
b = to_bigint("-60820564691661355463515465564664568");
cout << big_abs(b) << std::endl;        // Output : 60820564691661355463515465564664568
b = big_abs(b);
cout << b << std::endl;             // Output : 60820564691661355463515465564664568

---

big_max(bigint, bigint) - maximum function

It takes two bigint as arguments and return type is also bigint, returns the maximum of both bigints.

cout << big_max(a, b) << std::endl;          // returns maximum of both bigints
// Output : 56654250564056135415631554531554513813

---

big_min(bigint, bigint) - minimum function

It takes two bigint as arguments and return type is also bigint, returns the minimum of both bigints.

cout << big_min(a, b) << std::endl;          // returns minimum of both bigints
// Output : 60820564691661355463515465564664568

---

big_pow(bigint, bigint) - power function

It takes two bigint as arguments and return type is also bigint, returns the first bigint argument to the power second bigint argument.

b = to_bigint("2");
cout << big_pow(a, b) << std::endl;            // return a to the power b bigint
// Output : 3209704106974854937901411896655926267350648828646359016173511958974807798969
b = to_bigint("60820564691661355463515465564664568");

---

big_sqrt(bigint) - square root function

It takes one bigint as arguments and return type is also bigint(floor value), returns the square root of the bigint.

cout << big_sqrt(a) << std::endl;               // returns sqrt of bigint
// Output : 7526901790514881921

---

big_log2(bigint) - log2 function

It takes one bigint as arguments and return type is also bigint(floor value), returns the log to base 2 of the bigint.

cout << big_log2(a) << std::endl;               // returns log to the base 2 bigint
// Output : 125

---

big_log10(bigint) - log10 function

It takes one bigint as arguments and return type is also bigint(floor value), returns the log to base 10 of the bigint.

cout << big_log10(a) << std::endl;              // returns log to the base 10 bigint
// Output : 37

---

big_logwithbase(bigint, bigint) - logwithbase function

It takes two bigints as arguments and return type is also bigint(floor value), returns the first arg. log to base of second arg. of the bigint.

cout << big_logwithbase(a, b) << std::endl;         // returns log of 'a' to the base 'b' bigint
// Output : 1

---

big_swap(bigint, bigint) - swap function

It takes two arguments as bigint and swaps them.

big_swap(a, b);
cout << a << "\t" << b << std::endl;    // Output : 56      56654250564056135415631554531554513813

---

big_gcd(bigint, bigint) - Greatest Common Divisor function (GCD or HCF)

It takes two bigint as arguments and return type is also bigint, returns the gcd of both as bigint.

cout << big_gcd(a, b) << std::endl;      // Output : 1

---

big_lcm(bigint, bigint) - Lowest Common Multiple function (LCM)

It takes two bigint as arguments and return type is also bigint, returns the lcm of both as bigint.

cout << big_lcm(a, b) << std::endl;     // Output : 3172638031587143583275367053767052773528

---

big_fact(bigint) - factorial function

It takes one bigint as argument and return type is also bigint, returns the factorial of arg. bigint.

a = to_bigint("15");
cout << big_fact(a) << std::endl;       // Output : 1307674368000

---

big_isPrime(bigint) - Prime number checker function

It takes one bigint as argument and return type is boolean, returns true if the bigint is prime or false in other cases.

a = to_bigint("67");
b = to_bigint("33");
cout << big_isPrime(a) << std::endl;      // Output : 1   (true)
cout << big_isPrime(b) << std::endl;      // Output : 0   (false)

---

big_reverse(bigint) - Reverse function

It takes one bigint as argumnet and return type is also bigint, returns bigint after reversing the digits on the bigint.

a = to_bigint("65894");
cout << big_reverse(a) << std::endl;            // Output : 49856

---

big_isPalindrome(bigint) - Palindrome checker

It takes one bigint as argument and return type is boolean, returns true if the bigint is palindromic bigint or false in other cases.

cout << big_isPalindrome(a) << std::endl;        // Output : 0  (false)
a = to_bigint("654456");
cout << big_isPalindrome(a) << std::endl;        // Output : 1   (true)

---

Increment and Decrement

Increment and Decrement can be done as it is done with general integer types of variables.

cout << a << "\t" << ++a << std::endl;              // Output : 654456  654457
cout << a << "\t" << --a << std::endl;              // Output : 654457  654456