competitive-math-toolkit

Competitive Math Toolkit 🚀

A high-performance math library optimized for competitive programming.

📌 Features

✔️ Number Theory: GCD, LCM, Modular Exponentiation, Modular Inverse, Prime Sieve, Chinese Remainder Theorem
✔️ Combinatorics: Factorial, nCr (Combinations), Catalan Numbers
✔️ Matrix Exponentiation: Fast Fibonacci, Solving Recurrence Relations
✔️ Graph Math: Eulerian Path Detection
✔️ Optimized for O(log n) and O(1) operations wherever possible

📦 Installation

npm install competitive-math-toolkit

🔰 Usage

1️⃣ Number Theory

const mathToolkit = require("competitive-math-toolkit");

console.log(mathToolkit.gcd(36, 60)); // Output: 12
console.log(mathToolkit.lcm(12, 15)); // Output: 60
console.log(mathToolkit.modExp(2, 10, 1000000007)); // Output: 1024
console.log(mathToolkit.sieve(50)); // Output: [2, 3, 5, 7, 11, 13, ...]
console.log(mathToolkit.isDivisible(10, 5)); // Output: "Yes"
console.log(mathToolkit.findDivisors(10)); // Output: [1, 2, 5, 10]
console.log(mathToolkit.primeFactorization(60)); // Output: [2, 2, 3, 5]
console.log(mathToolkit.isPrime(13)); // Output: true
console.log(mathToolkit.modAdd(10, 15, 7)); // Output: 4
console.log(mathToolkit.modSubtract(10, 15, 7)); // Output: 2
console.log(mathToolkit.modMultiply(10, 15, 7)); // Output: 1
console.log(mathToolkit.modInverse(3, 11)); // Output: 4
console.log(mathToolkit.modDivide(10, 5, 7)); // Output: 2
console.log(mathToolkit.nthRoot(3, 27)); // Output: 3
console.log(mathToolkit.isPerfectSquare(25)); // Output: true
console.log(mathToolkit.isPerfectCube(27)); // Output: true
console.log(mathToolkit.binaryExponentiation(2, 10, 1000000007)); // Output: 1024
console.log(mathToolkit.isCoprime(14, 25)); // Output: true
console.log(mathToolkit.sumOfDivisors(12)); // Output: 28
console.log(mathToolkit.countPrimes(50)); // Output: 15

2️⃣ Combinatorics

console.log(mathToolkit.factorial(5)); // Output: 120
console.log(mathToolkit.nCr(5, 2)); // Output: 10
console.log(mathToolkit.nPr(5, 2)); // Output: 20

3️⃣ Matrix Exponentiation

console.log(mathToolkit.nthFibonacci(10)); // Output: 55

4️⃣ Graph Math

const graph = {
  A: ["B", "C"],
  B: ["A", "D"],
  C: ["A", "D"],
  D: ["B", "C"],
};
console.log(mathToolkit.countEulerianPaths(graph)); // Output: true

5️⃣ Chinese Remainder Theorem

const num = [3, 5, 7];
const rem = [2, 3, 2];

console.log(mathToolkit.chineseRemainderTheorem(num, rem)); // Output: 23

6️⃣ Bitwise Operations

Efficient bitwise operations and conversions.

const mathToolkit = require("competitive-math-toolkit");

console.log(mathToolkit.and(5, 3)); // Output: 1
console.log(mathToolkit.or(5, 3)); // Output: 7
console.log(mathToolkit.xor(5, 3)); // Output: 6
console.log(mathToolkit.not(5)); // Output: -6
console.log(mathToolkit.leftShift(5, 1)); // Output: 10
console.log(mathToolkit.rightShift(5, 1)); // Output: 2

console.log(mathToolkit.countSetBits(9)); // Output: 2
console.log(mathToolkit.isPowerOfTwo(8)); // Output: true

// Bitwise Manipulation
console.log(mathToolkit.setBit(5, 1)); // Output: 7
console.log(mathToolkit.clearBit(7, 1)); // Output: 5
console.log(mathToolkit.toggleBit(5, 0)); // Output: 4
console.log(mathToolkit.checkBit(5, 2)); // Output: true

// Conversions
console.log(mathToolkit.decimalToBinary(10)); // Output: "1010"
console.log(mathToolkit.binaryToDecimal("1010")); // Output: 10
console.log(mathToolkit.decimalToHex(255)); // Output: "FF"
console.log(mathToolkit.hexToDecimal("FF")); // Output: 255
console.log(mathToolkit.decimalToOctal(64)); // Output: "100"
console.log(mathToolkit.octalToDecimal("100")); // Output: 64
console.log(mathToolkit.binaryToHex("1111")); // Output: "F"
console.log(mathToolkit.hexToBinary("F")); // Output: "1111"

📜 API Reference

Function	Description
gcd(a, b)	Returns the Greatest Common Divisor (GCD) of two numbers
lcm(a, b)	Returns the Least Common Multiple (LCM) of two numbers
modExp(base, exp, mod)	Fast exponentiation (base^exp % mod)
modInverse(a, mod)	Finds modular inverse using Extended Euclidean Algorithm
sieve(n)	Returns all prime numbers up to n using Sieve of Eratosthenes
isDivisible(number, divisor)	Checks if number is divisible by divisor. Returns "Yes" or "No".
findDivisors(number)	Returns an array of all divisors of number.
primeFactorization(number)	Returns an array of prime factors of number.
isPrime(number)	Checks if number is prime. Returns true or false.
factorial(n, mod)	Returns factorial of n modulo mod
nCr(n, r, mod)	Returns nCr (binomial coefficient) modulo mod
nthFibonacci(n, mod)	Returns nth Fibonacci number using Matrix Exponentiation
modAdd(a, b, m)	Computes ( (a + b) \mod m )
modSubtract(a, b, m)	Computes ( (a - b) \mod m )
modMultiply(a, b, m)	Computes ( (a \times b) \mod m )
modInverse(a, m)	Computes the modular inverse of ( a ) under modulo ( m )
modDivide(a, b, m)	Computes ( (a / b) \mod m ) using modular inverse
nthRoot(n, a)	Computes the ( n )-th root of ( a )
isPerfectSquare(n)	Checks if ( n ) is a perfect square
isPerfectCube(n)	Checks if ( n ) is a perfect cube
binaryExponentiation(base, exp, m)	Computes ( \text{base}^{\text{exp}} \mod m ) using fast exponentiation
nPr(n, r)	Computes permutations ( P(n, r) )
isCoprime(a, b)	Checks if two numbers are coprime (i.e., their GCD is 1)
sumOfDivisors(n)	Computes the sum of all divisors of ( n )
countPrimes(n)	Counts the number of prime numbers up to ( n )
countEulerianPaths(graph)	Checks if a given graph has an Eulerian path
chineseRemainderTheorem(num, rem)	Solves a system of simultaneous congruences using the Chinese Remainder Theorem
and(a, b)	Computes the bitwise AND of two numbers
or(a, b)	Computes the bitwise OR of two numbers
xor(a, b)	Computes the bitwise XOR of two numbers
not(a)	Computes the bitwise NOT (1's complement) of a number
leftShift(a, n)	Shifts bits of a to the left by n positions
rightShift(a, n)	Shifts bits of a to the right by n positions (signed shift)
countSetBits(num)	Counts the number of 1s in the binary representation of a number
isPowerOfTwo(num)	Checks if a number is a power of two
setBit(num, pos)	Sets the bit at position pos in num to 1
clearBit(num, pos)	Clears the bit at position pos in num (sets to 0)
toggleBit(num, pos)	Toggles the bit at position pos in num
checkBit(num, pos)	Checks if the bit at position pos is 1
decimalToBinary(num)	Converts a decimal number to binary (as a string)
binaryToDecimal(str)	Converts a binary string to decimal
decimalToHex(num)	Converts a decimal number to hexadecimal (as a string)
hexToDecimal(str)	Converts a hexadecimal string to decimal
decimalToOctal(num)	Converts a decimal number to octal (as a string)
octalToDecimal(str)	Converts an octal string to decimal
binaryToHex(str)	Converts a binary string to hexadecimal
hexToBinary(str)	Converts a hexadecimal string to binary

⚡ Performance

• Most operations are O(log N) for efficiency.
• Matrix exponentiation speeds up Fibonacci and recurrence relations.
• Uses modular arithmetic for safe computation.

🛠️ Running Tests

You can run unit tests using:

npm test

📝 License

This project is licensed under the MIT License.

🌟 Contributing

Feel free to contribute, report issues, or request new features!

• Fork the repository.
• Create a new branch: git checkout -b feature-new-feature
• Commit changes: git commit -m "Added a new feature"
• Push and submit a PR!

🚀 Future Enhancements

• ✅ Add big integer support
• ✅ Implement fast polynomial calculations
• ✅ Provide TypeScript support

👨‍💻 Author

Developed by Apurva Kumar 🚀
GitHub | LinkedIn