import divide from "./divide";
import multiply from "./multiply";
import subtract from "./subtract";
import compare, { isEqual } from "./compare";
import { floor } from "./rounding";
import { parseStringNumber, isInteger, isZero } from "./utils";
import abs from "./abs";
import add from "./add";
/**
* Modulo operation (remainder after division)
* For positive numbers: a mod n = a - n * floor(a/n)
* Result always has the same sign as the divisor n
* @param dividend The number being divided
* @param divisor The number to divide by
* @returns Remainder as string
*/
export function mod(dividend: string, divisor: string): string {
if (isZero(divisor)) {
throw new Error("Division by zero in modulo operation");
}
if (!isInteger(dividend) || !isInteger(divisor)) {
throw new Error("Modulo operation requires integer arguments");
}
if (isZero(dividend)) {
return "0";
}
// Calculate quotient using floor division
const quotient = divide(dividend, divisor, 0);
const flooredQuotient = floor(quotient);
// Calculate remainder: dividend - divisor * floor(dividend/divisor)
const product = multiply(divisor, flooredQuotient);
const remainder = subtract(dividend, product);
// Ensure result has same sign as divisor (mathematical modulo)
const divisorParsed = parseStringNumber(divisor);
const remainderParsed = parseStringNumber(remainder);
if (isZero(remainder)) {
return "0";
}
// If remainder and divisor have different signs, adjust
if (divisorParsed.sign !== remainderParsed.sign) {
return add(remainder, divisor);
}
return remainder;
}
/**
* Euclidean algorithm for Greatest Common Divisor
* @param a First number as string
* @param b Second number as string
* @returns GCD as string
*/
export function gcd(a: string, b: string): string {
if (!isInteger(a) || !isInteger(b)) {
throw new Error("GCD requires integer arguments");
}
// Work with absolute values
let numA = abs(a);
let numB = abs(b);
if (isZero(numA)) {
return numB;
}
if (isZero(numB)) {
return numA;
}
// Euclidean algorithm: gcd(a,b) = gcd(b, a mod b)
while (!isZero(numB)) {
const temp = numB;
numB = mod(numA, numB);
numA = temp;
}
return numA;
}
/**
* Least Common Multiple using the formula: lcm(a,b) = |a*b| / gcd(a,b)
* @param a First number as string
* @param b Second number as string
* @returns LCM as string
*/
export function lcm(a: string, b: string): string {
if (!isInteger(a) || !isInteger(b)) {
throw new Error("LCM requires integer arguments");
}
if (isZero(a) || isZero(b)) {
return "0";
}
// lcm(a,b) = |a*b| / gcd(a,b)
const product = multiply(abs(a), abs(b));
const gcdResult = gcd(a, b);
return divide(product, gcdResult, 0);
}
/**
* Remainder operation (different from modulo for negative numbers)
* Result has the same sign as the dividend
* @param dividend The number being divided
* @param divisor The number to divide by
* @returns Remainder as string
*/
export function remainder(dividend: string, divisor: string): string {
if (isZero(divisor)) {
throw new Error("Division by zero in remainder operation");
}
if (!isInteger(dividend) || !isInteger(divisor)) {
throw new Error("Remainder operation requires integer arguments");
}
if (isZero(dividend)) {
return "0";
}
// For remainder operation, we use truncated division
const quotient = divide(dividend, divisor, 0);
// Truncate towards zero (different from floor for negative numbers)
const truncatedQuotient = quotient.startsWith("-") ?
"-" + floor(quotient.substring(1)) :
floor(quotient);
// Calculate remainder: dividend - divisor * truncate(dividend/divisor)
const product = multiply(divisor, truncatedQuotient);
return subtract(dividend, product);
}