lite-math 1.0.0

package/src/arithmetic/divide.ts

@@ -0,0 +1,11 @@
+/**
+ * Divides two numbers
+ * @param a - Dividend
+ * @param b - Divisor
+ * @returns Quotient of a and b
+ * @throws Error if b is zero
+ */
+export function divide(a: number, b: number): number {
+  if (b === 0) throw new Error("Division by zero")
+  return a / b
+}

package/src/arithmetic/floor.ts

@@ -0,0 +1,8 @@
+/**
+ * Rounds down to nearest integer
+ * @param value - The number
+ * @returns Floor value
+ */
+export function floor(value: number): number {
+  return Math.floor(value)
+}

package/src/arithmetic/modulo.ts

@@ -0,0 +1,9 @@
+/**
+ * Returns remainder of division
+ * @param a - Dividend
+ * @param b - Divisor
+ * @returns Remainder of a divided by b
+ */
+export function modulo(a: number, b: number): number {
+  return a % b
+}

package/src/arithmetic/multiply.ts

@@ -0,0 +1,9 @@
+/**
+ * Multiplies two numbers
+ * @param a - First number
+ * @param b - Second number
+ * @returns Product of a and b
+ */
+export function multiply(a: number, b: number): number {
+  return a * b
+}

package/src/arithmetic/percentage.ts

@@ -0,0 +1,9 @@
+/**
+ * Calculates percentage of a number
+ * @param value - The number
+ * @param percent - The percentage
+ * @returns Percentage value
+ */
+export function percentage(value: number, percent: number): number {
+  return (value * percent) / 100
+}

package/src/arithmetic/round.ts

@@ -0,0 +1,10 @@
+/**
+ * Rounds a number to specified decimal places
+ * @param value - The number to round
+ * @param decimals - Number of decimal places (default: 0)
+ * @returns Rounded number
+ */
+export function round(value: number, decimals = 0): number {
+  const multiplier = Math.pow(10, decimals)
+  return Math.round(value * multiplier) / multiplier
+}

package/src/arithmetic/subtract.ts

@@ -0,0 +1,9 @@
+/**
+ * Subtracts two numbers
+ * @param a - First number
+ * @param b - Second number
+ * @returns Difference of a and b
+ */
+export function subtract(a: number, b: number): number {
+  return a - b
+}

package/src/cli.ts

@@ -0,0 +1,321 @@
+#!/usr/bin/env node
+
+import {
+  add,
+  subtract,
+  multiply,
+  divide,
+  modulo,
+  percentage,
+  clamp,
+  round,
+  ceil,
+  floor,
+  factorial,
+  fibonacci,
+  gcd,
+  lcm,
+  primeCheck,
+  primeList,
+  power,
+  sqrt,
+  cubeRoot,
+  mean,
+  median,
+  mode,
+  variance,
+  stdDev,
+  range,
+  randomInt,
+  randomFloat,
+  randomArray,
+  solveLinear,
+  solveQuadratic,
+  distance,
+  slope,
+  midpoint,
+  triangleArea,
+  circleArea,
+  degToRad,
+  radToDeg,
+  kmToMiles,
+  milesToKm,
+  cToF,
+  fToC,
+} from "./index"
+
+const args = process.argv.slice(2)
+
+function formatOutput(value: any): string {
+  if (Array.isArray(value)) {
+    return `[${value.map((v) => (typeof v === "number" ? (Number.isInteger(v) ? v : v.toFixed(4)) : v)).join(", ")}]`
+  }
+  return typeof value === "number" ? (Number.isInteger(value) ? value.toString() : value.toFixed(4)) : String(value)
+}
+
+const commands: { [key: string]: () => void } = {
+  add: () => {
+    const [a, b] = [Number.parseFloat(args[1]), Number.parseFloat(args[2])]
+    console.log(formatOutput(add(a, b)))
+  },
+  subtract: () => {
+    const [a, b] = [Number.parseFloat(args[1]), Number.parseFloat(args[2])]
+    console.log(formatOutput(subtract(a, b)))
+  },
+  multiply: () => {
+    const [a, b] = [Number.parseFloat(args[1]), Number.parseFloat(args[2])]
+    console.log(formatOutput(multiply(a, b)))
+  },
+  divide: () => {
+    const [a, b] = [Number.parseFloat(args[1]), Number.parseFloat(args[2])]
+    console.log(formatOutput(divide(a, b)))
+  },
+  modulo: () => {
+    const [a, b] = [Number.parseFloat(args[1]), Number.parseFloat(args[2])]
+    console.log(formatOutput(modulo(a, b)))
+  },
+  percentage: () => {
+    const [value, percent] = [Number.parseFloat(args[1]), Number.parseFloat(args[2])]
+    console.log(formatOutput(percentage(value, percent)))
+  },
+  clamp: () => {
+    const [value, min, max] = [Number.parseFloat(args[1]), Number.parseFloat(args[2]), Number.parseFloat(args[3])]
+    console.log(formatOutput(clamp(value, min, max)))
+  },
+  round: () => {
+    const value = Number.parseFloat(args[1])
+    const decimals = args[2] ? Number.parseInt(args[2]) : 0
+    console.log(formatOutput(round(value, decimals)))
+  },
+  ceil: () => {
+    const value = Number.parseFloat(args[1])
+    console.log(formatOutput(ceil(value)))
+  },
+  floor: () => {
+    const value = Number.parseFloat(args[1])
+    console.log(formatOutput(floor(value)))
+  },
+  factorial: () => {
+    const n = Number.parseInt(args[1])
+    console.log(formatOutput(factorial(n)))
+  },
+  fibonacci: () => {
+    const n = Number.parseInt(args[1])
+    console.log(formatOutput(fibonacci(n)))
+  },
+  gcd: () => {
+    const [a, b] = [Number.parseInt(args[1]), Number.parseInt(args[2])]
+    console.log(formatOutput(gcd(a, b)))
+  },
+  lcm: () => {
+    const [a, b] = [Number.parseInt(args[1]), Number.parseInt(args[2])]
+    console.log(formatOutput(lcm(a, b)))
+  },
+  primeCheck: () => {
+    const n = Number.parseInt(args[1])
+    console.log(primeCheck(n))
+  },
+  primeList: () => {
+    const n = Number.parseInt(args[1])
+    console.log(formatOutput(primeList(n)))
+  },
+  power: () => {
+    const [base, exp] = [Number.parseFloat(args[1]), Number.parseFloat(args[2])]
+    console.log(formatOutput(power(base, exp)))
+  },
+  sqrt: () => {
+    const n = Number.parseFloat(args[1])
+    console.log(formatOutput(sqrt(n)))
+  },
+  cbrt: () => {
+    const n = Number.parseFloat(args[1])
+    console.log(formatOutput(cubeRoot(n)))
+  },
+  mean: () => {
+    const nums = args.slice(1).map(Number.parseFloat)
+    console.log(formatOutput(mean(nums)))
+  },
+  median: () => {
+    const nums = args.slice(1).map(Number.parseFloat)
+    console.log(formatOutput(median(nums)))
+  },
+  mode: () => {
+    const nums = args.slice(1).map(Number.parseFloat)
+    console.log(formatOutput(mode(nums)))
+  },
+  variance: () => {
+    const nums = args.slice(1).map(Number.parseFloat)
+    console.log(formatOutput(variance(nums)))
+  },
+  stddev: () => {
+    const nums = args.slice(1).map(Number.parseFloat)
+    console.log(formatOutput(stdDev(nums)))
+  },
+  range: () => {
+    const nums = args.slice(1).map(Number.parseFloat)
+    console.log(formatOutput(range(nums)))
+  },
+  randomInt: () => {
+    const [min, max] = [Number.parseInt(args[1]), Number.parseInt(args[2])]
+    console.log(formatOutput(randomInt(min, max)))
+  },
+  randomFloat: () => {
+    const [min, max] = [Number.parseFloat(args[1]), Number.parseFloat(args[2])]
+    console.log(formatOutput(randomFloat(min, max)))
+  },
+  randomArray: () => {
+    const [length, min, max] = [Number.parseInt(args[1]), Number.parseInt(args[2]), Number.parseInt(args[3])]
+    console.log(formatOutput(randomArray(length, min, max)))
+  },
+  solveLinear: () => {
+    const [a, b] = [Number.parseFloat(args[1]), Number.parseFloat(args[2])]
+    console.log(formatOutput(solveLinear(a, b)))
+  },
+  solveQuadratic: () => {
+    const [a, b, c] = [Number.parseFloat(args[1]), Number.parseFloat(args[2]), Number.parseFloat(args[3])]
+    console.log(formatOutput(solveQuadratic(a, b, c)))
+  },
+  distance: () => {
+    const [x1, y1, x2, y2] = [
+      Number.parseFloat(args[1]),
+      Number.parseFloat(args[2]),
+      Number.parseFloat(args[3]),
+      Number.parseFloat(args[4]),
+    ]
+    console.log(formatOutput(distance(x1, y1, x2, y2)))
+  },
+  slope: () => {
+    const [x1, y1, x2, y2] = [
+      Number.parseFloat(args[1]),
+      Number.parseFloat(args[2]),
+      Number.parseFloat(args[3]),
+      Number.parseFloat(args[4]),
+    ]
+    console.log(formatOutput(slope(x1, y1, x2, y2)))
+  },
+  midpoint: () => {
+    const [x1, y1, x2, y2] = [
+      Number.parseFloat(args[1]),
+      Number.parseFloat(args[2]),
+      Number.parseFloat(args[3]),
+      Number.parseFloat(args[4]),
+    ]
+    console.log(formatOutput(midpoint(x1, y1, x2, y2)))
+  },
+  triangleArea: () => {
+    const [a, b, c] = [Number.parseFloat(args[1]), Number.parseFloat(args[2]), Number.parseFloat(args[3])]
+    console.log(formatOutput(triangleArea(a, b, c)))
+  },
+  circleArea: () => {
+    const r = Number.parseFloat(args[1])
+    console.log(formatOutput(circleArea(r)))
+  },
+  degToRad: () => {
+    const degrees = Number.parseFloat(args[1])
+    console.log(formatOutput(degToRad(degrees)))
+  },
+  radToDeg: () => {
+    const radians = Number.parseFloat(args[1])
+    console.log(formatOutput(radToDeg(radians)))
+  },
+  kmToMiles: () => {
+    const km = Number.parseFloat(args[1])
+    console.log(formatOutput(kmToMiles(km)))
+  },
+  milesToKm: () => {
+    const miles = Number.parseFloat(args[1])
+    console.log(formatOutput(milesToKm(miles)))
+  },
+  cToF: () => {
+    const celsius = Number.parseFloat(args[1])
+    console.log(formatOutput(cToF(celsius)))
+  },
+  fToC: () => {
+    const fahrenheit = Number.parseFloat(args[1])
+    console.log(formatOutput(fToC(fahrenheit)))
+  },
+  help: () => {
+    console.log(`
+math-ops - A comprehensive mathematics utility CLI
+
+Usage: math-ops <command> [arguments]
+
+Arithmetic Commands:
+  add <a> <b>              - Add two numbers
+  subtract <a> <b>         - Subtract two numbers
+  multiply <a> <b>         - Multiply two numbers
+  divide <a> <b>           - Divide two numbers
+  modulo <a> <b>           - Get remainder
+  percentage <value> <pct> - Calculate percentage
+  clamp <val> <min> <max>  - Clamp value between min and max
+  round <value> [decimals] - Round to decimal places
+  ceil <value>             - Round up
+  floor <value>            - Round down
+
+Advanced Commands:
+  factorial <n>            - Calculate factorial
+  fibonacci <n>            - Get nth Fibonacci number
+  gcd <a> <b>              - Greatest common divisor
+  lcm <a> <b>              - Least common multiple
+  primeCheck <n>           - Check if number is prime
+  primeList <n>            - List all primes up to n
+  power <base> <exp>       - Raise to power
+  sqrt <n>                 - Square root
+  cbrt <n>                 - Cube root
+
+Statistics Commands:
+  mean <n1> <n2> ...       - Calculate mean
+  median <n1> <n2> ...     - Calculate median
+  mode <n1> <n2> ...       - Calculate mode
+  variance <n1> <n2> ...   - Calculate variance
+  stddev <n1> <n2> ...     - Calculate standard deviation
+  range <n1> <n2> ...      - Calculate range
+
+Random Commands:
+  randomInt <min> <max>    - Random integer between min and max
+  randomFloat <min> <max>  - Random float between min and max
+  randomArray <len> <min> <max> - Generate random array
+
+Algebra Commands:
+  solveLinear <a> <b>      - Solve ax + b = 0
+  solveQuadratic <a> <b> <c> - Solve ax^2 + bx + c = 0
+  distance <x1> <y1> <x2> <y2> - Distance between points
+  slope <x1> <y1> <x2> <y2>    - Slope between points
+  midpoint <x1> <y1> <x2> <y2> - Midpoint between points
+  triangleArea <a> <b> <c> - Triangle area (Heron's formula)
+  circleArea <r>           - Circle area
+
+Conversion Commands:
+  degToRad <degrees>       - Degrees to radians
+  radToDeg <radians>       - Radians to degrees
+  kmToMiles <km>           - Kilometers to miles
+  milesToKm <miles>        - Miles to kilometers
+  cToF <celsius>           - Celsius to Fahrenheit
+  fToC <fahrenheit>        - Fahrenheit to Celsius
+
+Examples:
+  math-ops add 10 20
+  math-ops factorial 5
+  math-ops primeCheck 17
+  math-ops solveQuadratic 1 -3 2
+  math-ops mean 10 20 30 40 50
+    `)
+  },
+}
+
+const command = args[0]
+
+if (!command || command === "help") {
+  commands.help?.()
+} else if (commands[command]) {
+  try {
+    commands[command]()
+  } catch (error) {
+    console.error(`Error: ${error instanceof Error ? error.message : "Unknown error"}`)
+    process.exit(1)
+  }
+} else {
+  console.error(`Unknown command: ${command}`)
+  console.log("Run 'math-ops help' for usage information")
+  process.exit(1)
+}

package/src/convert/c-to-f.ts

@@ -0,0 +1,8 @@
+/**
+ * Converts Celsius to Fahrenheit
+ * @param celsius - Temperature in Celsius
+ * @returns Temperature in Fahrenheit
+ */
+export function cToF(celsius: number): number {
+  return (celsius * 9) / 5 + 32
+}

package/src/convert/deg-to-rad.ts

@@ -0,0 +1,8 @@
+/**
+ * Converts degrees to radians
+ * @param degrees - Angle in degrees
+ * @returns Angle in radians
+ */
+export function degToRad(degrees: number): number {
+  return degrees * (Math.PI / 180)
+}

package/src/convert/f-to-c.ts

@@ -0,0 +1,8 @@
+/**
+ * Converts Fahrenheit to Celsius
+ * @param fahrenheit - Temperature in Fahrenheit
+ * @returns Temperature in Celsius
+ */
+export function fToC(fahrenheit: number): number {
+  return ((fahrenheit - 32) * 5) / 9
+}

package/src/convert/km-to-miles.ts

@@ -0,0 +1,8 @@
+/**
+ * Converts kilometers to miles
+ * @param km - Distance in kilometers
+ * @returns Distance in miles
+ */
+export function kmToMiles(km: number): number {
+  return km * 0.621371
+}

package/src/convert/miles-to-km.ts

@@ -0,0 +1,8 @@
+/**
+ * Converts miles to kilometers
+ * @param miles - Distance in miles
+ * @returns Distance in kilometers
+ */
+export function milesToKm(miles: number): number {
+  return miles * 1.60934
+}

package/src/convert/rad-to-deg.ts

@@ -0,0 +1,8 @@
+/**
+ * Converts radians to degrees
+ * @param radians - Angle in radians
+ * @returns Angle in degrees
+ */
+export function radToDeg(radians: number): number {
+  return radians * (180 / Math.PI)
+}

package/src/index.ts

@@ -0,0 +1,49 @@
+export * from "./arithmetic/add"
+export * from "./arithmetic/subtract"
+export * from "./arithmetic/multiply"
+export * from "./arithmetic/divide"
+export * from "./arithmetic/modulo"
+export * from "./arithmetic/percentage"
+export * from "./arithmetic/clamp"
+export * from "./arithmetic/round"
+export * from "./arithmetic/ceil"
+export * from "./arithmetic/floor"
+
+export * from "./advanced/factorial"
+export * from "./advanced/fibonacci"
+export * from "./advanced/gcd"
+export * from "./advanced/lcm"
+export * from "./advanced/prime-check"
+export * from "./advanced/prime-list"
+export * from "./advanced/power"
+export * from "./advanced/sqrt"
+export * from "./advanced/cube-root"
+
+export * from "./statistics/mean"
+export * from "./statistics/median"
+export * from "./statistics/mode"
+export * from "./statistics/variance"
+export * from "./statistics/std-dev"
+export * from "./statistics/range"
+export * from "./statistics/sum-array"
+export * from "./statistics/product-array"
+
+export * from "./random/random-int"
+export * from "./random/random-float"
+export * from "./random/random-from-array"
+export * from "./random/random-array"
+
+export * from "./algebra/solve-linear"
+export * from "./algebra/solve-quadratic"
+export * from "./algebra/distance"
+export * from "./algebra/slope"
+export * from "./algebra/midpoint"
+export * from "./algebra/triangle-area"
+export * from "./algebra/circle-area"
+
+export * from "./convert/deg-to-rad"
+export * from "./convert/rad-to-deg"
+export * from "./convert/km-to-miles"
+export * from "./convert/miles-to-km"
+export * from "./convert/c-to-f"
+export * from "./convert/f-to-c"

package/src/random/random-array.ts

@@ -0,0 +1,10 @@
+/**
+ * Generates array of random integers
+ * @param length - Length of array
+ * @param min - Minimum value
+ * @param max - Maximum value
+ * @returns Array of random numbers
+ */
+export function randomArray(length: number, min: number, max: number): number[] {
+  return Array.from({ length }, () => Math.floor(Math.random() * (max - min + 1)) + min)
+}

package/src/random/random-float.ts

@@ -0,0 +1,9 @@
+/**
+ * Generates random float between min and max
+ * @param min - Minimum value
+ * @param max - Maximum value
+ * @returns Random float
+ */
+export function randomFloat(min: number, max: number): number {
+  return Math.random() * (max - min) + min
+}

package/src/random/random-from-array.ts

@@ -0,0 +1,8 @@
+/**
+ * Returns random element from array
+ * @param array - Array to pick from
+ * @returns Random element
+ */
+export function randomFromArray<T>(array: T[]): T {
+  return array[Math.floor(Math.random() * array.length)]
+}

package/src/random/random-int.ts

@@ -0,0 +1,9 @@
+/**
+ * Generates random integer between min and max
+ * @param min - Minimum value (inclusive)
+ * @param max - Maximum value (inclusive)
+ * @returns Random integer
+ */
+export function randomInt(min: number, max: number): number {
+  return Math.floor(Math.random() * (max - min + 1)) + min
+}

package/src/statistics/mean.ts

@@ -0,0 +1,9 @@
+/**
+ * Calculates mean (average)
+ * @param numbers - Array of numbers
+ * @returns Mean value
+ */
+export function mean(numbers: number[]): number {
+  if (numbers.length === 0) throw new Error("Array cannot be empty")
+  return numbers.reduce((a, b) => a + b, 0) / numbers.length
+}

package/src/statistics/median.ts

@@ -0,0 +1,11 @@
+/**
+ * Calculates median
+ * @param numbers - Array of numbers
+ * @returns Median value
+ */
+export function median(numbers: number[]): number {
+  if (numbers.length === 0) throw new Error("Array cannot be empty")
+  const sorted = [...numbers].sort((a, b) => a - b)
+  const mid = Math.floor(sorted.length / 2)
+  return sorted.length % 2 ? sorted[mid] : (sorted[mid - 1] + sorted[mid]) / 2
+}

package/src/statistics/mode.ts

@@ -0,0 +1,16 @@
+/**
+ * Calculates mode (most frequent value)
+ * @param numbers - Array of numbers
+ * @returns Mode value(s)
+ */
+export function mode(numbers: number[]): number[] {
+  if (numbers.length === 0) throw new Error("Array cannot be empty")
+  const freq = new Map<number, number>()
+  for (const num of numbers) {
+    freq.set(num, (freq.get(num) || 0) + 1)
+  }
+  const maxFreq = Math.max(...freq.values())
+  return Array.from(freq.entries())
+    .filter(([, f]) => f === maxFreq)
+    .map(([n]) => n)
+}

package/src/statistics/product-array.ts

@@ -0,0 +1,8 @@
+/**
+ * Multiplies all numbers in array
+ * @param numbers - Array of numbers
+ * @returns Product of all numbers
+ */
+export function productArray(numbers: number[]): number {
+  return numbers.reduce((a, b) => a * b, 1)
+}

package/src/statistics/range.ts

@@ -0,0 +1,9 @@
+/**
+ * Calculates range (max - min)
+ * @param numbers - Array of numbers
+ * @returns Range value
+ */
+export function range(numbers: number[]): number {
+  if (numbers.length === 0) throw new Error("Array cannot be empty")
+  return Math.max(...numbers) - Math.min(...numbers)
+}

package/src/statistics/std-dev.ts

@@ -0,0 +1,14 @@
+/**
+ * Calculates standard deviation
+ * @param numbers - Array of numbers
+ * @returns Standard deviation
+ */
+export function stdDev(numbers: number[]): number {
+  return Math.sqrt(variance(numbers))
+}
+
+function variance(numbers: number[]): number {
+  if (numbers.length === 0) throw new Error("Array cannot be empty")
+  const avg = numbers.reduce((a, b) => a + b, 0) / numbers.length
+  return numbers.reduce((sum, n) => sum + Math.pow(n - avg, 2), 0) / numbers.length
+}

package/src/statistics/sum-array.ts

@@ -0,0 +1,8 @@
+/**
+ * Sums all numbers in array
+ * @param numbers - Array of numbers
+ * @returns Sum of all numbers
+ */
+export function sumArray(numbers: number[]): number {
+  return numbers.reduce((a, b) => a + b, 0)
+}

package/src/statistics/variance.ts

@@ -0,0 +1,10 @@
+/**
+ * Calculates variance
+ * @param numbers - Array of numbers
+ * @returns Variance value
+ */
+export function variance(numbers: number[]): number {
+  if (numbers.length === 0) throw new Error("Array cannot be empty")
+  const avg = numbers.reduce((a, b) => a + b, 0) / numbers.length
+  return numbers.reduce((sum, n) => sum + Math.pow(n - avg, 2), 0) / numbers.length
+}