test length of grid test actual

Author: N8Brooks

_util.ts

@@ -1,8 +1,23 @@
 /** Returns an array of length `n` containing elements `0` through `n - 1` */
 export function range(n: number): number[] {
-  const result = Array(n);
+  if (!Number.isInteger(n)) {
+    throw RangeError("n must be an integer");
+  }
+  const result = Array(Math.max(0, n));
   for (let i = 0; i < n; i++) {
     result[i] = i;
   }
   return result;
 }
+
+/** Return `n` factorial as an integer. */
+export function factorial(n: number): number {
+  if (n < 0 || !Number.isInteger(n)) {
+    throw RangeError("n must be a non-negative integer");
+  }
+  let result = 1;
+  for (let i = 2; i <= n; i++) {
+    result *= i;
+  }
+  return result;
+}

_util_test.ts

@@ -1,5 +1,26 @@
-import { assertEquals } from "https://deno.land/[email protected]/testing/asserts.ts";
-import { range } from "./_util.ts";
+import {
+  assertEquals,
+  assertStrictEquals,
+  assertThrows,
+} from "https://deno.land/[email protected]/testing/asserts.ts";
+import { factorial, range } from "./_util.ts";
+
+Deno.test("n = NaN", () => {
+  assertThrows(() => range(NaN), RangeError, "n must be an integer");
+});
+
+Deno.test("n = Infinity", () => {
+  assertThrows(() => range(Infinity), RangeError, "n must be an integer");
+});
+
+Deno.test("n = Math.PI", () => {
+  assertThrows(() => range(Math.PI), RangeError, "n must be an integer");
+});
+
+Deno.test("n = -1", () => {
+  const actual = range(-1);
+  assertEquals(actual, []);
+});
 
 Deno.test("n = 0", () => {
   const actual = range(0);
@@ -23,3 +44,55 @@ Deno.test("n = 10", () => {
   const expected = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
   assertEquals(actual, expected);
 });
+
+Deno.test("n = NaN", () => {
+  assertThrows(
+    () => factorial(NaN),
+    RangeError,
+    "n must be a non-negative integer",
+  );
+});
+
+Deno.test("n < Infinity", () => {
+  assertThrows(
+    () => factorial(Infinity),
+    RangeError,
+    "n must be a non-negative integer",
+  );
+});
+
+Deno.test("n < Math.PI", () => {
+  assertThrows(
+    () => factorial(Math.PI),
+    RangeError,
+    "n must be a non-negative integer",
+  );
+});
+
+Deno.test("n < -1", () => {
+  assertThrows(
+    () => factorial(-1),
+    RangeError,
+    "n must be a non-negative integer",
+  );
+});
+
+Deno.test("n = 0", () => {
+  const actual = factorial(0);
+  assertStrictEquals(actual, 1);
+});
+
+Deno.test("n = 1", () => {
+  const actual = factorial(1);
+  assertStrictEquals(actual, 1);
+});
+
+Deno.test("n = 2", () => {
+  const actual = factorial(2);
+  assertStrictEquals(actual, 2);
+});
+
+Deno.test("n = 10", () => {
+  const actual = factorial(10);
+  assertStrictEquals(actual, 3628800);
+});

combinations_test.ts

@@ -1,11 +1,12 @@
 import {
   assertEquals,
+  assertStrictEquals,
   assertThrows,
 } from "https://deno.land/[email protected]/testing/asserts.ts";
 import { combinations } from "./combinations.ts";
 import { combinationsWithReplacement } from "./combinations_with_replacement.ts";
 import { permutations } from "./permutations.ts";
-import { range } from "./_util.ts";
+import { factorial, range } from "./_util.ts";
 
 Deno.test("r = -1", () => {
   assertThrows(
@@ -61,13 +62,28 @@ for (let n = 0; n < 8; n++) {
     Deno.test(`combinations([${iterable}], ${r})`, () => {
       const actual = [...combinations(r, iterable)];
       const expected1 = [...combinations1(r, iterable)];
-      const expected2 = [...combinations2(r, iterable)];
       assertEquals(actual, expected1);
+      const expected2 = [...combinations2(r, iterable)];
       assertEquals(actual, expected2);
+      const expectedLength = comb(iterable.length, r);
+      assertStrictEquals(actual.length, expectedLength);
     });
   }
 }
 
+/** Return the number of ways to choose `r` items from `n` items without repetition and without order. */
+function comb(n: number, r: number): number {
+  if (n < 0 || !Number.isInteger(n)) {
+    throw RangeError("n must be a non-negative integer");
+  } else if (r < 0 || !Number.isInteger(r)) {
+    throw RangeError("r must be a non-negative integer");
+  } else if (r <= n) {
+    return factorial(n) / (factorial(r) * factorial(n - r));
+  } else {
+    return 0;
+  }
+}
+
 /** Equivalent to `combinations` for testing. */
 export function* combinations1<T>(
   r: number,

combinations_with_replacement_test.ts

@@ -1,10 +1,11 @@
 import {
   assertEquals,
+  assertStrictEquals,
   assertThrows,
 } from "https://deno.land/[email protected]/testing/asserts.ts";
 import { combinationsWithReplacement } from "./combinations_with_replacement.ts";
 import { product } from "./product.ts";
-import { range } from "./_util.ts";
+import { factorial, range } from "./_util.ts";
 
 Deno.test("r = -1", () => {
   assertThrows(
@@ -90,10 +91,27 @@ for (let n = 0; n < 6; n++) {
       const actual = [...combinationsWithReplacement(r, iterable)];
       const expected1 = [...combinationsWithReplacement1(r, iterable)];
       assertEquals(actual, expected1);
+      const expectedLength = cwr(iterable.length, r);
+      assertStrictEquals(actual.length, expectedLength);
     });
   }
 }
 
+/** Return the number of ways to choose `r` items from `n` items with replacement and without order. */
+function cwr(n: number, r: number): number {
+  if (n < 0 || !Number.isInteger(n)) {
+    throw RangeError("n must be a non-negative integer");
+  } else if (r < 0 || !Number.isInteger(r)) {
+    throw RangeError("r must be a non-negative integer");
+  } else if (r > n && n === 0) {
+    return 0;
+  } else if (r === 0) {
+    return 1;
+  } else {
+    return factorial(n + r - 1) / (factorial(r) * factorial(n - 1));
+  }
+}
+
 /** Equivalent to `combinationsWithReplacement1` for testing. */
 function* combinationsWithReplacement1<T>(
   r: number,

permutations_test.ts

@@ -1,10 +1,11 @@
 import {
   assertEquals,
+  assertStrictEquals,
   assertThrows,
 } from "https://deno.land/[email protected]/testing/asserts.ts";
 import { permutations } from "./permutations.ts";
 import { product } from "./product.ts";
-import { range } from "./_util.ts";
+import { factorial, range } from "./_util.ts";
 
 Deno.test("r = -1", () => {
   assertThrows(
@@ -86,16 +87,31 @@ for (let n = 0; n < 8; n++) {
   for (let r = 0; r < 6; r++) {
     Deno.test(`permutations([${iterable}], ${r})`, () => {
       const actual = [...permutations(r, iterable)];
-      const expected1 = [...permutations1(iterable, r)];
+      const expected1 = [...permutations1(r, iterable)];
       assertEquals(actual, expected1);
+      const expectedLength = perm(iterable.length, r);
+      assertStrictEquals(actual.length, expectedLength);
     });
   }
 }
 
+/** Return the number of ways to choose `r` items from `n` items without replacement and with order. */
+function perm(n: number, r: number): number {
+  if (n < 0 || !Number.isInteger(n)) {
+    throw RangeError("n must be a non-negative integer");
+  } else if (r < 0 || !Number.isInteger(r)) {
+    throw RangeError("r must be a non-negative integer");
+  } else if (r > n) {
+    return 0;
+  } else {
+    return factorial(n) / factorial(n - r);
+  }
+}
+
 /** Equivalent to `permutations` for testing. */
 function* permutations1<T>(
-  iterable: Iterable<T>,
   r: number,
+  iterable: Iterable<T>,
 ): Generator<T[]> {
   const pool = [...iterable];
   const n = pool.length;

power_set.ts

@@ -1,6 +1,6 @@
 import { range } from "./_util.ts";
 
-/** Yields all successive subsets of input `iterable`. */
+/** Yields every subset of elements from `iterable`. */
 export function* powerSet<T>(iterable: Iterable<T>): Generator<T[]> {
   const pool = [...iterable];
   const n = pool.length;

power_set_test.ts

@@ -1,4 +1,7 @@
-import { assertEquals } from "https://deno.land/[email protected]/testing/asserts.ts";
+import {
+  assertEquals,
+  assertStrictEquals,
+} from "https://deno.land/[email protected]/testing/asserts.ts";
 import { combinations } from "./combinations.ts";
 import { combinations1, combinations2 } from "./combinations_test.ts";
 import { powerSet } from "./power_set.ts";
@@ -40,14 +43,25 @@ for (let i = 0; i < 8; i++) {
   Deno.test(`powerSet([${iterable}])`, () => {
     const actual = [...powerSet(iterable)];
     const expected1 = [...powerSet1(iterable)];
-    const expected2 = [...powerSet2(iterable)];
-    const expected3 = [...powerSet3(iterable)];
     assertEquals(actual, expected1);
+    const expected2 = [...powerSet2(iterable)];
     assertEquals(actual, expected2);
+    const expected3 = [...powerSet3(iterable)];
     assertEquals(actual, expected3);
+    const expectedLength = ps(iterable.length);
+    assertStrictEquals(actual.length, expectedLength);
   });
 }
 
+/** Return the number of subsets of a set with `n` elements. */
+function ps(n: number): number {
+  if (n < 0 || !Number.isInteger(n)) {
+    throw RangeError("n must be a non-negative integer");
+  } else {
+    return Math.pow(2, n);
+  }
+}
+
 /** Equivalent to `powerSet` for testing. */
 function* powerSet1<T>(iterable: Iterable<T>): Generator<T[]> {
   const pool = [...iterable];

product_test.ts

@@ -1,5 +1,6 @@
 import {
   assertEquals,
+  assertStrictEquals,
   assertThrows,
 } from "https://deno.land/[email protected]/testing/asserts.ts";
 import { product } from "./product.ts";
@@ -133,6 +134,8 @@ for (let elements = 1; elements < 10; elements += 0.1) {
     const actual = [...product(r, ...iterables)];
     const expected1 = [...product1(r, ...iterables)];
     assertEquals(actual, expected1);
+    const expectedLength = prod(r, iterables.map(({ length }) => length));
+    assertStrictEquals(actual.length, expectedLength);
   });
 }
 
@@ -141,6 +144,15 @@ function randRange(stop: number): number {
   return Math.floor(Math.random() * stop);
 }
 
+/** Calculate the product of all the elements of the input `iterable` repeated `r` times. */
+function prod(r: number, iterable: Iterable<number>): number {
+  let product = 1;
+  for (const factor of iterable) {
+    product *= factor;
+  }
+  return Math.pow(product, r);
+}
+
 /** Equivalent to `product` for testing. */
 function* product1<T>(r: number, ...iterables: Iterable<T>[]): Generator<T[]> {
   const pools: T[][] = Array(r)