1.0.4 ⢠Published 2 months ago
competitive-math-toolkit v1.0.4
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