@creativeintelligence/abbie 0.1.4 → 0.1.5

package/src/lib/math.test.ts

@@ -1,299 +0,0 @@
-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

@@ -1,120 +0,0 @@
-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));
-};