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 IntegerAddition
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 : 56715071128747796771095069997119178531Subtraction
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 : -56715071128747796771095069997119178427Multiplication
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 : 17559508934546761837787142663762383673015669257983708921734037614082485987264Division
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 : 931Mod
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 : 41Conditional 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 : 60820564691661355463515465564664568big_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 : 56654250564056135415631554531554513813big_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 : 60820564691661355463515465564664568big_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 : 7526901790514881921big_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 : 125big_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 : 37big_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 : 1big_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 56654250564056135415631554531554513813big_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 : 1big_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 : 3172638031587143583275367053767052773528big_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 : 1307674368000big_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 : 49856big_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