@creativeintelligence/abbie 0.1.0

package/src/lib/math.test.ts

@@ -0,0 +1,299 @@
+import { describe, expect, it } from "bun:test";
+
+import {
+  add,
+  average,
+  clamp,
+  degreesToRadians,
+  divide,
+  factorial,
+  fibonacci,
+  gcd,
+  isPrime,
+  lcm,
+  lerp,
+  modulo,
+  multiply,
+  power,
+  radiansToDegrees,
+  randomInt,
+  randomRange,
+  roundTo,
+  subtract,
+  sum,
+} from "./math";
+
+describe("math", () => {
+  describe("basic arithmetic", () => {
+    it("adds two numbers correctly", () => {
+      expect(add(2, 3)).toBe(5);
+      expect(add(-1, 1)).toBe(0);
+      expect(add(0, 0)).toBe(0);
+      expect(add(1.5, 2.5)).toBe(4);
+    });
+
+    it("subtracts two numbers correctly", () => {
+      expect(subtract(5, 3)).toBe(2);
+      expect(subtract(0, 1)).toBe(-1);
+      expect(subtract(-5, -3)).toBe(-2);
+      expect(subtract(5.5, 0.5)).toBe(5);
+    });
+
+    it("multiplies two numbers correctly", () => {
+      expect(multiply(2, 3)).toBe(6);
+      expect(multiply(-2, 3)).toBe(-6);
+      expect(multiply(-2, -3)).toBe(6);
+      expect(multiply(0, 5)).toBe(0);
+    });
+
+    it("divides two numbers correctly", () => {
+      expect(divide(6, 2)).toBe(3);
+      expect(divide(5, 2)).toBe(2.5);
+      expect(divide(-6, 2)).toBe(-3);
+    });
+
+    it("throws error when dividing by zero", () => {
+      expect(() => divide(5, 0)).toThrow("Division by zero");
+    });
+
+    it("calculates modulo correctly", () => {
+      expect(modulo(10, 3)).toBe(1);
+      expect(modulo(10, 5)).toBe(0);
+      expect(modulo(10, 2)).toBe(0);
+    });
+
+    it("throws error when calculating modulo by zero", () => {
+      expect(() => modulo(5, 0)).toThrow("Division by zero");
+    });
+  });
+
+  describe("power function", () => {
+    it("calculates positive exponents correctly", () => {
+      expect(power(2, 3)).toBe(8);
+      expect(power(5, 0)).toBe(1);
+      expect(power(5, 1)).toBe(5);
+      expect(power(3, 2)).toBe(9);
+    });
+
+    it("calculates fractional exponents correctly", () => {
+      expect(power(9, 0.5)).toBeCloseTo(3);
+      expect(power(16, 0.25)).toBeCloseTo(2);
+      expect(power(27, 1 / 3)).toBeCloseTo(3);
+    });
+
+    it("calculates negative exponents correctly", () => {
+      expect(power(2, -1)).toBe(0.5);
+      expect(power(10, -2)).toBe(0.01);
+    });
+
+    it("handles zero as base correctly", () => {
+      expect(power(0, 5)).toBe(0);
+      expect(power(0, 1)).toBe(0);
+    });
+  });
+
+  describe("clamp function", () => {
+    it("clamps values within range", () => {
+      expect(clamp(5, 0, 10)).toBe(5);
+      expect(clamp(-5, 0, 10)).toBe(0);
+      expect(clamp(15, 0, 10)).toBe(10);
+      expect(clamp(0, 0, 10)).toBe(0);
+      expect(clamp(10, 0, 10)).toBe(10);
+    });
+  });
+
+  describe("lerp function", () => {
+    it("linearly interpolates between values", () => {
+      expect(lerp(0, 10, 0.5)).toBe(5);
+      expect(lerp(0, 10, 0)).toBe(0);
+      expect(lerp(0, 10, 1)).toBe(10);
+      expect(lerp(0, 100, 0.25)).toBe(25);
+    });
+
+    it("clamps t parameter to [0, 1]", () => {
+      expect(lerp(0, 10, -1)).toBe(0);
+      expect(lerp(0, 10, 2)).toBe(10);
+    });
+  });
+
+  describe("roundTo function", () => {
+    it("rounds to specified decimal places", () => {
+      expect(roundTo(Math.PI, 2)).toBe(3.14);
+      // biome-ignore lint/suspicious/noApproximativeNumericConstant: expected rounded value
+      expect(roundTo(Math.PI, 3)).toBe(3.142);
+      expect(roundTo(Math.PI, 0)).toBe(3);
+      expect(roundTo(3.5, 0)).toBe(4);
+    });
+  });
+
+  describe("sum function", () => {
+    it("sums array of numbers", () => {
+      expect(sum(1, 2, 3, 4)).toBe(10);
+      expect(sum(1, 2, 3)).toBe(6);
+      expect(sum(-1, 1)).toBe(0);
+      expect(sum(0, 0, 0)).toBe(0);
+    });
+
+    it("handles single value", () => {
+      expect(sum(5)).toBe(5);
+    });
+
+    it("handles no values", () => {
+      expect(sum()).toBe(0);
+    });
+  });
+
+  describe("average function", () => {
+    it("calculates average correctly", () => {
+      expect(average(1, 2, 3)).toBe(2);
+      expect(average(2, 4, 6, 8)).toBe(5);
+      expect(average(5)).toBe(5);
+    });
+
+    it("handles negative numbers", () => {
+      expect(average(-5, 5)).toBe(0);
+    });
+
+    it("throws error on empty array", () => {
+      expect(() => average()).toThrow("Cannot calculate average of empty array");
+    });
+  });
+
+  describe("fibonacci function", () => {
+    it("calculates fibonacci numbers correctly", () => {
+      expect(fibonacci(0)).toBe(0);
+      expect(fibonacci(1)).toBe(1);
+      expect(fibonacci(2)).toBe(1);
+      expect(fibonacci(3)).toBe(2);
+      expect(fibonacci(4)).toBe(3);
+      expect(fibonacci(5)).toBe(5);
+      expect(fibonacci(10)).toBe(55);
+    });
+
+    it("throws error for negative input", () => {
+      expect(() => fibonacci(-1)).toThrow("Fibonacci is not defined for negative numbers");
+    });
+  });
+
+  describe("gcd function", () => {
+    it("calculates greatest common divisor correctly", () => {
+      expect(gcd(12, 8)).toBe(4);
+      expect(gcd(17, 5)).toBe(1);
+      expect(gcd(100, 10)).toBe(10);
+      expect(gcd(0, 5)).toBe(5);
+      expect(gcd(5, 0)).toBe(5);
+      expect(gcd(0, 0)).toBe(0);
+    });
+
+    it("handles negative numbers", () => {
+      expect(gcd(-12, 8)).toBe(4);
+      expect(gcd(12, -8)).toBe(4);
+      expect(gcd(-12, -8)).toBe(4);
+    });
+  });
+
+  describe("lcm function", () => {
+    it("calculates least common multiple correctly", () => {
+      expect(lcm(4, 6)).toBe(12);
+      expect(lcm(5, 7)).toBe(35);
+      expect(lcm(12, 8)).toBe(24);
+      expect(lcm(1, 5)).toBe(5);
+    });
+
+    it("handles zero correctly", () => {
+      expect(lcm(0, 5)).toBe(0);
+      expect(lcm(5, 0)).toBe(0);
+    });
+
+    it("handles negative numbers", () => {
+      expect(lcm(-4, 6)).toBe(12);
+      expect(lcm(4, -6)).toBe(12);
+      expect(lcm(-4, -6)).toBe(12);
+    });
+  });
+
+  describe("isPrime function", () => {
+    it("identifies prime numbers correctly", () => {
+      expect(isPrime(2)).toBe(true);
+      expect(isPrime(3)).toBe(true);
+      expect(isPrime(5)).toBe(true);
+      expect(isPrime(7)).toBe(true);
+      expect(isPrime(11)).toBe(true);
+      expect(isPrime(97)).toBe(true);
+    });
+
+    it("identifies non-prime numbers correctly", () => {
+      expect(isPrime(0)).toBe(false);
+      expect(isPrime(1)).toBe(false);
+      expect(isPrime(4)).toBe(false);
+      expect(isPrime(6)).toBe(false);
+      expect(isPrime(9)).toBe(false);
+      expect(isPrime(100)).toBe(false);
+    });
+  });
+
+  describe("factorial function", () => {
+    it("calculates factorial correctly", () => {
+      expect(factorial(0)).toBe(1);
+      expect(factorial(1)).toBe(1);
+      expect(factorial(2)).toBe(2);
+      expect(factorial(3)).toBe(6);
+      expect(factorial(4)).toBe(24);
+      expect(factorial(5)).toBe(120);
+    });
+
+    it("throws error for negative input", () => {
+      expect(() => factorial(-1)).toThrow("Factorial is not defined for negative numbers");
+    });
+  });
+
+  describe("degree/radian conversion", () => {
+    it("converts degrees to radians correctly", () => {
+      expect(degreesToRadians(0)).toBe(0);
+      expect(degreesToRadians(180)).toBeCloseTo(Math.PI);
+      expect(degreesToRadians(90)).toBeCloseTo(Math.PI / 2);
+      expect(degreesToRadians(360)).toBeCloseTo(2 * Math.PI);
+    });
+
+    it("converts radians to degrees correctly", () => {
+      expect(radiansToDegrees(0)).toBe(0);
+      expect(radiansToDegrees(Math.PI)).toBeCloseTo(180);
+      expect(radiansToDegrees(Math.PI / 2)).toBeCloseTo(90);
+      expect(radiansToDegrees(2 * Math.PI)).toBeCloseTo(360);
+    });
+
+    it("conversions are reversible", () => {
+      const degrees = 45;
+      const radians = degreesToRadians(degrees);
+      expect(radiansToDegrees(radians)).toBeCloseTo(degrees);
+    });
+  });
+
+  describe("random functions", () => {
+    it("randomRange returns value within bounds", () => {
+      const min = 5;
+      const max = 10;
+      for (let i = 0; i < 100; i++) {
+        const value = randomRange(min, max);
+        expect(value).toBeGreaterThanOrEqual(min);
+        expect(value).toBeLessThan(max);
+      }
+    });
+
+    it("randomInt returns integer within bounds", () => {
+      const min = 5;
+      const max = 10;
+      for (let i = 0; i < 100; i++) {
+        const value = randomInt(min, max);
+        expect(value).toBeGreaterThanOrEqual(min);
+        expect(value).toBeLessThanOrEqual(max);
+        expect(Number.isInteger(value)).toBe(true);
+      }
+    });
+
+    it("randomInt handles same min and max", () => {
+      const value = randomInt(5, 5);
+      expect(value).toBe(5);
+    });
+  });
+});

package/src/lib/math.ts

@@ -0,0 +1,120 @@
+export const add = (a: number, b: number): number => a + b;
+
+export const subtract = (a: number, b: number): number => a - b;
+
+export const multiply = (a: number, b: number): number => a * b;
+
+export const divide = (a: number, b: number): number => {
+  if (b === 0) {
+    throw new Error("Division by zero");
+  }
+  return a / b;
+};
+
+export const modulo = (a: number, b: number): number => {
+  if (b === 0) {
+    throw new Error("Division by zero");
+  }
+  return a % b;
+};
+
+export const power = (base: number, exponent: number): number => {
+  if (!Number.isInteger(exponent)) {
+    return base ** exponent;
+  }
+  if (exponent === 0) return 1;
+  if (exponent === 1) return base;
+  let result = 1;
+  const absExponent = Math.abs(exponent);
+  for (let i = 0; i < absExponent; i++) {
+    result *= base;
+  }
+  return exponent < 0 ? 1 / result : result;
+};
+
+export const clamp = (value: number, min: number, max: number): number => {
+  return Math.min(Math.max(value, min), max);
+};
+
+export const lerp = (start: number, end: number, t: number): number => {
+  const clampedT = clamp(t, 0, 1);
+  return start + (end - start) * clampedT;
+};
+
+export const roundTo = (value: number, decimals: number): number => {
+  const multiplier = 10 ** decimals;
+  return Math.round(value * multiplier) / multiplier;
+};
+
+export const sum = (...numbers: number[]): number => {
+  return numbers.reduce((acc, n) => acc + n, 0);
+};
+
+export const average = (...numbers: number[]): number => {
+  if (numbers.length === 0) {
+    throw new Error("Cannot calculate average of empty array");
+  }
+  return sum(...numbers) / numbers.length;
+};
+
+export const fibonacci = (n: number): number => {
+  if (n < 0) {
+    throw new Error("Fibonacci is not defined for negative numbers");
+  }
+  if (n <= 1) return n;
+  let a = 0,
+    b = 1;
+  for (let i = 2; i <= n; i++) {
+    [a, b] = [b, a + b];
+  }
+  return b;
+};
+
+export const gcd = (a: number, b: number): number => {
+  a = Math.abs(a);
+  b = Math.abs(b);
+  while (b !== 0) {
+    [a, b] = [b, a % b];
+  }
+  return a;
+};
+
+export const lcm = (a: number, b: number): number => {
+  if (a === 0 || b === 0) return 0;
+  return Math.abs(a * b) / gcd(a, b);
+};
+
+export const isPrime = (n: number): boolean => {
+  if (n < 2) return false;
+  if (n === 2) return true;
+  if (n % 2 === 0) return false;
+  const sqrt = Math.sqrt(n);
+  for (let i = 3; i <= sqrt; i += 2) {
+    if (n % i === 0) return false;
+  }
+  return true;
+};
+
+export const factorial = (n: number): number => {
+  if (n < 0) {
+    throw new Error("Factorial is not defined for negative numbers");
+  }
+  if (n === 0 || n === 1) return 1;
+  let result = 1;
+  for (let i = 2; i <= n; i++) {
+    result *= i;
+  }
+  return result;
+};
+
+export const degreesToRadians = (degrees: number): number => (degrees * Math.PI) / 180;
+
+export const radiansToDegrees = (radians: number): number => (radians * 180) / Math.PI;
+
+export const randomRange = (min: number, max: number): number => {
+  return Math.random() * (max - min) + min;
+};
+
+export const randomInt = (min: number, max: number): number => {
+  return Math.floor(randomRange(min, max + 1));
+};