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