Initial commit.

.gitattributes

+# Disable line-ending conversions for this repository.
+* -text

.gitignore

+# dependencies
+/node_modules
+
+# testing
+/coverage
+
+# production
+/build
+
+# environments
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local
+
+# logs
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+# misc
+*~
+.DS_Store

.gitmodules

+[submodule "eslint-config"]
+	path = eslint-config
+	url = git@git.unl.edu:csce-310/eslint-config.git

README.md

+# Homework 4
+
+Starter code for Homework 4 in the CSCE 310 course at UNL.
+
+# Quick Start
+
+Recursively clone this repository and `cd` into the root folder:
+
+```
+$ git clone --recursive git@git.unl.edu:csce-310/homework-4.git
+$ cd homework-4
+```
+
+(If you forget `--recursive` when cloning, you can `cd` into your clone and run
+`git submodule update --init --recursive` instead.)
+
+Install dependencies:
+
+```
+$ npm install
+```
+
+# Instructions
+
+See <https://canvas.unl.edu/courses/136556/assignments/1303212> for Dr. Brady's students.
+See <…> for Dr. Vinod's students.

eslint-config @ 16524f5a

+Subproject commit 16524f5ac58d4b13378261f1ab29bc1acc2a2099

homework-4.code-workspace

+{
+	"folders": [
+		{
+			"path": "."
+		}
+	],
+	"settings": {
+		"files.eol": "\n",
+		"files.exclude": {
+			"**/node_modules": true
+		},
+		"files.trimFinalNewlines": true,
+		"files.trimTrailingWhitespace": true
+	}
+}

homework-4/.gitignore

+# dependencies
+/node_modules
+
+# testing
+/coverage
+
+# production
+/build
+
+# environments
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local
+
+# logs
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+# misc
+*~
+.DS_Store

homework-4/package.json

+{
+  "name": "@unlcsce/homework-4",
+  "version": "1.0.0",
+  "description": "Starter code for Homework 4.",
+  "type": "module",
+  "private": true,
+  "license": "UNLICENSED",
+  "scripts": {
+    "lint:js": "eslint --max-warnings 0 ./src",
+    "lint": "run-s --continue-on-error lint:**",
+    "test-once:search": "node --experimental-vm-modules node_modules/jest/bin/jest.js -t \"the searching monoid\"",
+    "test-once:texMath": "node --experimental-vm-modules node_modules/jest/bin/jest.js -t \"the TeX math monoid\"",
+    "test-once:volume": "node --experimental-vm-modules node_modules/jest/bin/jest.js -t \"the volume monoid\"",
+    "test-once:downtime": "node --experimental-vm-modules node_modules/jest/bin/jest.js -t \"the average-downtime monoid\"",
+    "test-once:calculator": "node --experimental-vm-modules node_modules/jest/bin/jest.js -t \"the calculator monoid\"",
+    "test-once": "node --experimental-vm-modules node_modules/jest/bin/jest.js",
+    "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js --watchAll"
+  },
+  "dependencies": {
+    "npm-run-all": "^4.1.5"
+  },
+  "devDependencies": {
+    "@unlcsce/eslint-config": "file:../eslint-config",
+    "eslint": "^8.20.0",
+    "jest": "^28.1.3",
+    "jest-environment-node": "^28.1.3"
+  },
+  "eslintConfig": {
+    "extends": "@unlcsce"
+  },
+  "jest": {
+    "clearMocks": true,
+    "resetMocks": false,
+    "restoreMocks": false,
+    "setupFilesAfterEnv": [
+      "./src/setupTests.js"
+    ],
+    "testEnvironment": "./src/testing/failFast.js",
+    "transform": {}
+  },
+  "//": [
+    "See https://github.com/facebook/jest/issues/9430 for information on Jest+ES6."
+  ]
+}

homework-4/src/calculator.js

+/* IMPORTANT: Remove these directives when you start working on the code so that
+ * the linter will warn you about code style issues. */
+/* eslint-disable no-useless-constructor */
+
+class MonoidElement {
+  constructor() {
+    // Implement this constructor per the assignment instructions.
+  }
+
+  get value() {
+    return 0; // Implement this getter per the assignment instructions.
+  }
+}
+
+export const IDENTITY_ELEMENT = new MonoidElement(); // Define this object per the assignment instructions.
+
+export function encodeAsMonoidElement(character) {
+  return IDENTITY_ELEMENT; // Implement this function per the assignment instructions.
+}
+
+export function combineMonoidElements(left, right) {
+  return IDENTITY_ELEMENT; // Implement this function per the assignment instructions.
+}

homework-4/src/calculator.test.js

+import { parallelMapReduce } from './mapReduce.js';
+
+describe('map-reduce with the calculator monoid', () => {
+  test('evaluates the empty expression as zero with one thread', async() => {
+    const result = await parallelMapReduce('./calculator.js', '', 1);
+    expect(result.value).toBe(0);
+  });
+  test('evaluates a one-digit number with one thread', async() => {
+    const result = await parallelMapReduce('./calculator.js', '5', 1);
+    expect(result.value).toBe(5);
+  });
+  test('evaluates a sum of two one-digit numbers with one thread', async() => {
+    const result = await parallelMapReduce('./calculator.js', '2+9', 1);
+    expect(result.value).toBe(11);
+  });
+  test('evaluates a sum of several one-digit numbers with one thread', async() => {
+    const result = await parallelMapReduce('./calculator.js', '2+9+4+5+6+8', 1);
+    expect(result.value).toBe(34);
+  });
+  test('evaluates a multi-digit number with one thread', async() => {
+    const result = await parallelMapReduce('./calculator.js', '55', 1);
+    expect(result.value).toBe(55);
+  });
+  test('evaluates a sum of two multi-digit numbers with one thread', async() => {
+    const result = await parallelMapReduce('./calculator.js', '222+19', 1);
+    expect(result.value).toBe(241);
+  });
+  test('evaluates a sum of several multi-digit numbers with one thread', async() => {
+    const result = await parallelMapReduce('./calculator.js', '29+45+6+8+11+999', 1);
+    expect(result.value).toBe(1098);
+  });
+  test('evaluates random expression #0 with one thread', async() => {
+    const result = await parallelMapReduce('./calculator.js', '0+3+344+503666+8824559+82+7+972340', 1);
+    expect(result.value).toBe(10301001);
+  });
+  test('evaluates random expression #1 with one thread', async() => {
+    const result = await parallelMapReduce('./calculator.js', '426+56695+860907+0+61018152+957', 1);
+    expect(result.value).toBe(61937137);
+  });
+  test('evaluates random expression #2 with one thread', async() => {
+    const result = await parallelMapReduce('./calculator.js', '370128+46566235+0+87+4576+1+94', 1);
+    expect(result.value).toBe(46941121);
+  });
+  test('evaluates random expression #3 with one thread', async() => {
+    const result = await parallelMapReduce('./calculator.js', '37708+4089+2270915+5248685+0+80976', 1);
+    expect(result.value).toBe(7642373);
+  });
+  test('evaluates the empty expression as zero with two threads', async() => {
+    const result = await parallelMapReduce('./calculator.js', '', 2);
+    expect(result.value).toBe(0);
+  });
+  test('evaluates a one-digit number with two threads', async() => {
+    const result = await parallelMapReduce('./calculator.js', '5', 2);
+    expect(result.value).toBe(5);
+  });
+  test('evaluates a sum of two one-digit numbers with two threads', async() => {
+    const result = await parallelMapReduce('./calculator.js', '2+9', 2);
+    expect(result.value).toBe(11);
+  });
+  test('evaluates a sum of several one-digit numbers with two threads', async() => {
+    const result = await parallelMapReduce('./calculator.js', '2+9+4+5+6+8', 2);
+    expect(result.value).toBe(34);
+  });
+  test('evaluates a multi-digit number with two threads', async() => {
+    const result = await parallelMapReduce('./calculator.js', '55', 2);
+    expect(result.value).toBe(55);
+  });
+  test('evaluates a sum of two multi-digit numbers with two threads', async() => {
+    const result = await parallelMapReduce('./calculator.js', '222+19', 2);
+    expect(result.value).toBe(241);
+  });
+  test('evaluates a sum of several multi-digit numbers with two threads', async() => {
+    const result = await parallelMapReduce('./calculator.js', '29+45+6+8+11+999', 2);
+    expect(result.value).toBe(1098);
+  });
+  test('evaluates random expression #0 with two threads', async() => {
+    const result = await parallelMapReduce('./calculator.js', '0+3+344+503666+8824559+82+7+972340', 2);
+    expect(result.value).toBe(10301001);
+  });
+  test('evaluates random expression #1 with two threads', async() => {
+    const result = await parallelMapReduce('./calculator.js', '426+56695+860907+0+61018152+957', 2);
+    expect(result.value).toBe(61937137);
+  });
+  test('evaluates random expression #2 with two threads', async() => {
+    const result = await parallelMapReduce('./calculator.js', '370128+46566235+0+87+4576+1+94', 2);
+    expect(result.value).toBe(46941121);
+  });
+  test('evaluates random expression #3 with two threads', async() => {
+    const result = await parallelMapReduce('./calculator.js', '37708+4089+2270915+5248685+0+80976', 2);
+    expect(result.value).toBe(7642373);
+  });
+  test('evaluates the empty expression as zero with three threads', async() => {
+    const result = await parallelMapReduce('./calculator.js', '', 3);
+    expect(result.value).toBe(0);
+  });
+  test('evaluates a one-digit number with three threads', async() => {
+    const result = await parallelMapReduce('./calculator.js', '5', 3);
+    expect(result.value).toBe(5);
+  });
+  test('evaluates a sum of two one-digit numbers with three threads', async() => {
+    const result = await parallelMapReduce('./calculator.js', '2+9', 3);
+    expect(result.value).toBe(11);
+  });
+  test('evaluates a sum of several one-digit numbers with three threads', async() => {
+    const result = await parallelMapReduce('./calculator.js', '2+9+4+5+6+8', 3);
+    expect(result.value).toBe(34);
+  });
+  test('evaluates a multi-digit number with three threads', async() => {
+    const result = await parallelMapReduce('./calculator.js', '55', 3);
+    expect(result.value).toBe(55);
+  });
+  test('evaluates a sum of two multi-digit numbers with three threads', async() => {
+    const result = await parallelMapReduce('./calculator.js', '222+19', 3);
+    expect(result.value).toBe(241);
+  });
+  test('evaluates a sum of several multi-digit numbers with three threads', async() => {
+    const result = await parallelMapReduce('./calculator.js', '29+45+6+8+11+999', 3);
+    expect(result.value).toBe(1098);
+  });
+  test('evaluates random expression #0 with three threads', async() => {
+    const result = await parallelMapReduce('./calculator.js', '0+3+344+503666+8824559+82+7+972340', 3);
+    expect(result.value).toBe(10301001);
+  });
+  test('evaluates random expression #1 with three threads', async() => {
+    const result = await parallelMapReduce('./calculator.js', '426+56695+860907+0+61018152+957', 3);
+    expect(result.value).toBe(61937137);
+  });
+  test('evaluates random expression #2 with three threads', async() => {
+    const result = await parallelMapReduce('./calculator.js', '370128+46566235+0+87+4576+1+94', 3);
+    expect(result.value).toBe(46941121);
+  });
+  test('evaluates random expression #3 with three threads', async() => {
+    const result = await parallelMapReduce('./calculator.js', '37708+4089+2270915+5248685+0+80976', 3);
+    expect(result.value).toBe(7642373);
+  });
+});

homework-4/src/downtime.js

+/* IMPORTANT: Remove these directives when you start working on the code so that
+ * the linter will warn you about code style issues. */
+/* eslint-disable no-useless-constructor */
+
+class MonoidElement {
+  constructor() {
+    // Implement this constructor per the assignment instructions.
+  }
+
+  get averageDowntime() {
+    return 0; // Implement this getter per the assignment instructions.
+  }
+}
+
+export const IDENTITY_ELEMENT = new MonoidElement(); // Define this object per the assignment instructions.
+
+export function encodeAsMonoidElement(up) {
+  return IDENTITY_ELEMENT; // Implement this function per the assignment instructions.
+}
+
+export function combineMonoidElements(left, right) {
+  return IDENTITY_ELEMENT; // Implement this function per the assignment instructions.
+}

homework-4/src/downtime.test.js

+import { parallelMapReduce } from './mapReduce.js';
+
+describe('map-reduce with the average-downtime monoid', () => {
+  test('finds the average downtime in a one-minute log with one thread', async() => {
+    const result = await parallelMapReduce('./downtime.js', [false], 1);
+    expect(result.averageDowntime).toBe(1 / 1);
+  });
+  test('finds the average downtime in a longer completely-down log with one thread', async() => {
+    const result = await parallelMapReduce('./downtime.js', [false, false, false], 1);
+    expect(result.averageDowntime).toBe(3 / 1);
+  });
+  test('finds the average downtime of a single blip with one thread', async() => {
+    const result = await parallelMapReduce('./downtime.js', [true, true, false, true, true], 1);
+    expect(result.averageDowntime).toBe(1 / 1);
+  });
+  test('finds the average downtime of a single crash with one thread', async() => {
+    const result = await parallelMapReduce('./downtime.js', [true, true, false, false, false, false, true, true], 1);
+    expect(result.averageDowntime).toBe(4 / 1);
+  });
+  test('finds the average downtime of two blips with one thread', async() => {
+    const result = await parallelMapReduce('./downtime.js', [false, true, true, false, true], 1);
+    expect(result.averageDowntime).toBe(2 / 2);
+  });
+  test('finds the average downtime of two equal crashes with one thread', async() => {
+    const result = await parallelMapReduce('./downtime.js', [true, false, false, true, true, false, false], 1);
+    expect(result.averageDowntime).toBe(4 / 2);
+  });
+  test('finds the average downtime of two unequal crashes with one thread', async() => {
+    const result = await parallelMapReduce('./downtime.js', [false, false, false, true, true, false, false], 1);
+    expect(result.averageDowntime).toBe(5 / 2);
+  });
+  test('finds the average downtime of four interruptions with one thread', async() => {
+    const result = await parallelMapReduce('./downtime.js', [
+      false, false, true, true, true, false, false, true, false, false, false, true, true, false, false, false, false,
+    ], 1);
+    expect(result.averageDowntime).toBe(11 / 4);
+  });
+  test('finds the average downtime of random log #0 with one thread', async() => {
+    const result = await parallelMapReduce('./downtime.js', [
+      false, true, false, false, true, false, false, true, false, true, true, false, false, false, true, true,
+    ], 1);
+    expect(result.averageDowntime).toBe(9 / 5);
+  });
+  test('finds the average downtime of random log #1 with one thread', async() => {
+    const result = await parallelMapReduce('./downtime.js', [
+      false, false, true, false, false, true, false, true, true, true, true, true, true, true, false, true,
+    ], 1);
+    expect(result.averageDowntime).toBe(6 / 4);
+  });
+  test('finds the average downtime of random log #2 with one thread', async() => {
+    const result = await parallelMapReduce('./downtime.js', [
+      true, true, true, true, true, false, true, true, false, false, false, true, false, false, true, false,
+    ], 1);
+    expect(result.averageDowntime).toBe(7 / 4);
+  });
+  test('finds the average downtime of random log #3 with one thread', async() => {
+    const result = await parallelMapReduce('./downtime.js', [
+      true, true, false, true, false, false, false, false, true, false, true, true, false, false, false, true,
+    ], 1);
+    expect(result.averageDowntime).toBe(9 / 4);
+  });
+  test('finds the average downtime in a one-minute log with two threads', async() => {
+    const result = await parallelMapReduce('./downtime.js', [false], 2);
+    expect(result.averageDowntime).toBe(1 / 1);
+  });
+  test('finds the average downtime in a longer completely-down log with two threads', async() => {
+    const result = await parallelMapReduce('./downtime.js', [false, false, false], 2);
+    expect(result.averageDowntime).toBe(3 / 1);
+  });
+  test('finds the average downtime of a single blip with two threads', async() => {
+    const result = await parallelMapReduce('./downtime.js', [true, true, false, true, true], 2);
+    expect(result.averageDowntime).toBe(1 / 1);
+  });
+  test('finds the average downtime of a single crash with two threads', async() => {
+    const result = await parallelMapReduce('./downtime.js', [true, true, false, false, false, false, true, true], 2);
+    expect(result.averageDowntime).toBe(4 / 1);
+  });
+  test('finds the average downtime of two blips with two threads', async() => {
+    const result = await parallelMapReduce('./downtime.js', [false, true, true, false, true], 2);
+    expect(result.averageDowntime).toBe(2 / 2);
+  });
+  test('finds the average downtime of two equal crashes with two threads', async() => {
+    const result = await parallelMapReduce('./downtime.js', [true, false, false, true, true, false, false], 2);
+    expect(result.averageDowntime).toBe(4 / 2);
+  });
+  test('finds the average downtime of two unequal crashes with two threads', async() => {
+    const result = await parallelMapReduce('./downtime.js', [false, false, false, true, true, false, false], 2);
+    expect(result.averageDowntime).toBe(5 / 2);
+  });
+  test('finds the average downtime of four interruptions with two threads', async() => {
+    const result = await parallelMapReduce('./downtime.js', [
+      false, false, true, true, true, false, false, true, false, false, false, true, true, false, false, false, false,
+    ], 2);
+    expect(result.averageDowntime).toBe(11 / 4);
+  });
+  test('finds the average downtime of random log #0 with two threads', async() => {
+    const result = await parallelMapReduce('./downtime.js', [
+      false, true, false, false, true, false, false, true, false, true, true, false, false, false, true, true,
+    ], 2);
+    expect(result.averageDowntime).toBe(9 / 5);
+  });
+  test('finds the average downtime of random log #1 with two threads', async() => {
+    const result = await parallelMapReduce('./downtime.js', [
+      false, false, true, false, false, true, false, true, true, true, true, true, true, true, false, true,
+    ], 2);
+    expect(result.averageDowntime).toBe(6 / 4);
+  });
+  test('finds the average downtime of random log #2 with two threads', async() => {
+    const result = await parallelMapReduce('./downtime.js', [
+      true, true, true, true, true, false, true, true, false, false, false, true, false, false, true, false,
+    ], 2);
+    expect(result.averageDowntime).toBe(7 / 4);
+  });
+  test('finds the average downtime of random log #3 with two threads', async() => {
+    const result = await parallelMapReduce('./downtime.js', [
+      true, true, false, true, false, false, false, false, true, false, true, true, false, false, false, true,
+    ], 2);
+    expect(result.averageDowntime).toBe(9 / 4);
+  });
+  test('finds the average downtime in a one-minute log with three threads', async() => {
+    const result = await parallelMapReduce('./downtime.js', [false], 3);
+    expect(result.averageDowntime).toBe(1 / 1);
+  });
+  test('finds the average downtime in a longer completely-down log with three threads', async() => {
+    const result = await parallelMapReduce('./downtime.js', [false, false, false], 3);
+    expect(result.averageDowntime).toBe(3 / 1);
+  });
+  test('finds the average downtime of a single blip with three threads', async() => {
+    const result = await parallelMapReduce('./downtime.js', [true, true, false, true, true], 3);
+    expect(result.averageDowntime).toBe(1 / 1);
+  });
+  test('finds the average downtime of a single crash with three threads', async() => {
+    const result = await parallelMapReduce('./downtime.js', [true, true, false, false, false, false, true, true], 3);
+    expect(result.averageDowntime).toBe(4 / 1);
+  });
+  test('finds the average downtime of two blips with three threads', async() => {
+    const result = await parallelMapReduce('./downtime.js', [false, true, true, false, true], 3);
+    expect(result.averageDowntime).toBe(2 / 2);
+  });
+  test('finds the average downtime of two equal crashes with three threads', async() => {
+    const result = await parallelMapReduce('./downtime.js', [true, false, false, true, true, false, false], 3);
+    expect(result.averageDowntime).toBe(4 / 2);
+  });
+  test('finds the average downtime of two unequal crashes with three threads', async() => {
+    const result = await parallelMapReduce('./downtime.js', [false, false, false, true, true, false, false], 3);
+    expect(result.averageDowntime).toBe(5 / 2);
+  });
+  test('finds the average downtime of four interruptions with three threads', async() => {
+    const result = await parallelMapReduce('./downtime.js', [
+      false, false, true, true, true, false, false, true, false, false, false, true, true, false, false, false, false,
+    ], 3);
+    expect(result.averageDowntime).toBe(11 / 4);
+  });
+  test('finds the average downtime of random log #0 with three threads', async() => {
+    const result = await parallelMapReduce('./downtime.js', [
+      false, true, false, false, true, false, false, true, false, true, true, false, false, false, true, true,
+    ], 3);
+    expect(result.averageDowntime).toBe(9 / 5);
+  });
+  test('finds the average downtime of random log #1 with three threads', async() => {
+    const result = await parallelMapReduce('./downtime.js', [
+      false, false, true, false, false, true, false, true, true, true, true, true, true, true, false, true,
+    ], 3);
+    expect(result.averageDowntime).toBe(6 / 4);
+  });
+  test('finds the average downtime of random log #2 with three threads', async() => {
+    const result = await parallelMapReduce('./downtime.js', [
+      true, true, true, true, true, false, true, true, false, false, false, true, false, false, true, false,
+    ], 3);
+    expect(result.averageDowntime).toBe(7 / 4);
+  });
+  test('finds the average downtime of random log #3 with three threads', async() => {
+    const result = await parallelMapReduce('./downtime.js', [
+      true, true, false, true, false, false, false, false, true, false, true, true, false, false, false, true,
+    ], 3);
+    expect(result.averageDowntime).toBe(9 / 4);
+  });
+});

homework-4/src/mapReduce.js

+import { Worker } from 'worker_threads';
+
+class ModuleWorker extends Worker {
+  constructor(path) {
+    const code = `import '${new URL(path, import.meta.url).href}';`;
+    super(new URL(`data:text/javascript,${encodeURIComponent(code)}`));
+  }
+
+  dispatch(data) {
+    this.postMessage(data);
+    return new Promise((resolve) => this.once('message', resolve));
+  }
+}
+
+function iterativeReduce(identityElement, combineMonoidElements, sequence) {
+  let result = identityElement;
+  for (const element of sequence) {
+    result = combineMonoidElements(result, element);
+  }
+  return result;
+}
+
+export async function parallelMapReduce(proceduresURL, sequence, workerCount) {
+  console.assert(workerCount > 0, `Cannot distribute work to a nonpositive (${workerCount}) number of threads.`);
+  const {
+    IDENTITY_ELEMENT,
+    combineMonoidElements,
+  } = await import(proceduresURL);
+  const workers = [...Array(workerCount)].map(() => new ModuleWorker('./worker.js'));
+  const jobs = workers.map((worker, workerIndex) => {
+    const low = Math.floor(workerIndex * sequence.length / workerCount);
+    const high = Math.floor((workerIndex + 1) * sequence.length / workerCount);
+    return worker.dispatch({
+      proceduresURL,
+      data: [...sequence.slice(low, high)],
+    });
+  });
+  const threadResults = (await Promise.all(jobs)).map(
+    (element) => Object.assign(Object.create(Object.getPrototypeOf(IDENTITY_ELEMENT)), element),
+  );
+  for (const worker of workers) {
+    worker.terminate();
+  }
+  return iterativeReduce(IDENTITY_ELEMENT, combineMonoidElements, threadResults);
+}

homework-4/src/search.js

+/* IMPORTANT: Remove these directives when you start working on the code so that
+ * the linter will warn you about code style issues. */
+/* eslint-disable no-useless-constructor */
+
+class MonoidElement {
+  constructor() {
+    // Implement this constructor per the assignment instructions.
+  }
+
+  get index() {
+    return 0; // Implement this getter per the assignment instructions.
+  }
+}
+
+export const IDENTITY_ELEMENT = new MonoidElement(); // Define this object per the assignment instructions.
+
+export function encodeAsMonoidElement(flag) {
+  return IDENTITY_ELEMENT; // Implement this function per the assignment instructions.
+}
+
+export function combineMonoidElements(left, right) {
+  return IDENTITY_ELEMENT; // Implement this function per the assignment instructions.
+}

homework-4/src/search.test.js

+import { parallelMapReduce } from './mapReduce.js';
+
+describe('map-reduce with the searching monoid', () => {
+  test('finds an only index with one thread', async() => {
+    const result = await parallelMapReduce('./search.js', [true], 1);
+    expect(result.index).toBe(0);
+  });
+  test('finds a beginning index with one thread', async() => {
+    const result = await parallelMapReduce('./search.js', [true, false, false, false], 1);
+    expect(result.index).toBe(0);
+  });
+  test('finds a middle index with one thread', async() => {
+    const result = await parallelMapReduce('./search.js', [false, false, true, false], 1);
+    expect(result.index).toBe(2);
+  });
+  test('finds a ending index with one thread', async() => {
+    const result = await parallelMapReduce('./search.js', [false, false, false, true], 1);
+    expect(result.index).toBe(3);
+  });
+  test('finds an index in random list #0 with one thread', async() => {
+    const result = await parallelMapReduce('./search.js', [
+      false, false, false, false, true, false, false, false, false, false, false, false,
+    ], 1);
+    expect(result.index).toBe(4);
+  });
+  test('finds an index in random list #1 with one thread', async() => {
+    const result = await parallelMapReduce('./search.js', [
+      false, false, false, false, false, false, false, false, true, false, false, false,
+    ], 1);
+    expect(result.index).toBe(8);
+  });
+  test('finds an index in random list #2 with one thread', async() => {
+    const result = await parallelMapReduce('./search.js', [
+      false, false, false, false, false, false, false, false, false, false, false, true,
+    ], 1);
+    expect(result.index).toBe(11);
+  });
+  test('finds an index in random list #3 with one thread', async() => {
+    const result = await parallelMapReduce('./search.js', [
+      false, false, false, true, false, false, false, false, false, false, false, false,
+    ], 1);
+    expect(result.index).toBe(3);
+  });
+  test('finds an index in random list #5 with one thread', async() => {
+    const result = await parallelMapReduce('./search.js', [
+      false, false, false, false, false, false, false, false, false, false, true, false,
+    ], 1);
+    expect(result.index).toBe(10);
+  });
+  test('finds an index in random list #6 with one thread', async() => {
+    const result = await parallelMapReduce('./search.js', [
+      true, false, false, false, false, false, false, false, false, false, false, false,
+    ], 1);
+    expect(result.index).toBe(0);
+  });
+  test('finds an only index with two threads', async() => {
+    const result = await parallelMapReduce('./search.js', [true], 2);
+    expect(result.index).toBe(0);
+  });
+  test('finds an only index with three threads', async() => {
+    const result = await parallelMapReduce('./search.js', [true], 3);
+    expect(result.index).toBe(0);
+  });
+  test('finds an only index with four threads', async() => {
+    const result = await parallelMapReduce('./search.js', [true], 4);
+    expect(result.index).toBe(0);
+  });
+  test('finds a beginning index with two threads', async() => {
+    const result = await parallelMapReduce('./search.js', [true, false, false, false], 2);
+    expect(result.index).toBe(0);
+  });
+  test('finds a middle index with two threads', async() => {
+    const result = await parallelMapReduce('./search.js', [false, false, true, false], 2);
+    expect(result.index).toBe(2);
+  });
+  test('finds a ending index with two threads', async() => {
+    const result = await parallelMapReduce('./search.js', [false, false, false, true], 2);
+    expect(result.index).toBe(3);
+  });
+  test('finds an index in random list #0 with two threads', async() => {
+    const result = await parallelMapReduce('./search.js', [
+      false, false, false, false, true, false, false, false, false, false, false, false,
+    ], 2);
+    expect(result.index).toBe(4);
+  });
+  test('finds an index in random list #1 with two threads', async() => {
+    const result = await parallelMapReduce('./search.js', [
+      false, false, false, false, false, false, false, false, true, false, false, false,
+    ], 2);
+    expect(result.index).toBe(8);
+  });
+  test('finds an index in random list #2 with two threads', async() => {
+    const result = await parallelMapReduce('./search.js', [
+      false, false, false, false, false, false, false, false, false, false, false, true,
+    ], 2);
+    expect(result.index).toBe(11);
+  });
+  test('finds an index in random list #3 with two threads', async() => {
+    const result = await parallelMapReduce('./search.js', [
+      false, false, false, true, false, false, false, false, false, false, false, false,
+    ], 2);
+    expect(result.index).toBe(3);
+  });
+  test('finds an index in random list #5 with two threads', async() => {
+    const result = await parallelMapReduce('./search.js', [
+      false, false, false, false, false, false, false, false, false, false, true, false,
+    ], 2);
+    expect(result.index).toBe(10);
+  });
+  test('finds an index in random list #6 with two threads', async() => {
+    const result = await parallelMapReduce('./search.js', [
+      true, false, false, false, false, false, false, false, false, false, false, false,
+    ], 2);
+    expect(result.index).toBe(0);
+  });
+  test('finds a beginning index with three threads', async() => {
+    const result = await parallelMapReduce('./search.js', [true, false, false, false], 3);
+    expect(result.index).toBe(0);
+  });
+  test('finds a middle index with three threads', async() => {
+    const result = await parallelMapReduce('./search.js', [false, false, true, false], 3);
+    expect(result.index).toBe(2);
+  });
+  test('finds a ending index with three threads', async() => {
+    const result = await parallelMapReduce('./search.js', [false, false, false, true], 3);
+    expect(result.index).toBe(3);
+  });
+  test('finds an index in random list #0 with three threads', async() => {
+    const result = await parallelMapReduce('./search.js', [
+      false, false, false, false, true, false, false, false, false, false, false, false,
+    ], 3);
+    expect(result.index).toBe(4);
+  });
+  test('finds an index in random list #1 with three threads', async() => {
+    const result = await parallelMapReduce('./search.js', [
+      false, false, false, false, false, false, false, false, true, false, false, false,
+    ], 3);
+    expect(result.index).toBe(8);
+  });
+  test('finds an index in random list #2 with three threads', async() => {
+    const result = await parallelMapReduce('./search.js', [
+      false, false, false, false, false, false, false, false, false, false, false, true,
+    ], 3);
+    expect(result.index).toBe(11);
+  });
+  test('finds an index in random list #3 with three threads', async() => {
+    const result = await parallelMapReduce('./search.js', [
+      false, false, false, true, false, false, false, false, false, false, false, false,
+    ], 3);
+    expect(result.index).toBe(3);
+  });
+  test('finds an index in random list #5 with three threads', async() => {
+    const result = await parallelMapReduce('./search.js', [
+      false, false, false, false, false, false, false, false, false, false, true, false,
+    ], 3);
+    expect(result.index).toBe(10);
+  });
+  test('finds an index in random list #6 with three threads', async() => {
+    const result = await parallelMapReduce('./search.js', [
+      true, false, false, false, false, false, false, false, false, false, false, false,
+    ], 3);
+    expect(result.index).toBe(0);
+  });
+  test('finds a beginning index with four threads', async() => {
+    const result = await parallelMapReduce('./search.js', [true, false, false, false], 4);
+    expect(result.index).toBe(0);
+  });
+  test('finds a middle index with four threads', async() => {
+    const result = await parallelMapReduce('./search.js', [false, false, true, false], 4);
+    expect(result.index).toBe(2);
+  });
+  test('finds a ending index with four threads', async() => {
+    const result = await parallelMapReduce('./search.js', [false, false, false, true], 4);
+    expect(result.index).toBe(3);
+  });
+  test('finds an index in random list #0 with four threads', async() => {
+    const result = await parallelMapReduce('./search.js', [
+      false, false, false, false, true, false, false, false, false, false, false, false,
+    ], 4);
+    expect(result.index).toBe(4);
+  });
+  test('finds an index in random list #1 with four threads', async() => {
+    const result = await parallelMapReduce('./search.js', [
+      false, false, false, false, false, false, false, false, true, false, false, false,
+    ], 4);
+    expect(result.index).toBe(8);
+  });
+  test('finds an index in random list #2 with four threads', async() => {
+    const result = await parallelMapReduce('./search.js', [
+      false, false, false, false, false, false, false, false, false, false, false, true,
+    ], 4);
+    expect(result.index).toBe(11);
+  });
+  test('finds an index in random list #3 with four threads', async() => {
+    const result = await parallelMapReduce('./search.js', [
+      false, false, false, true, false, false, false, false, false, false, false, false,
+    ], 4);
+    expect(result.index).toBe(3);
+  });
+  test('finds an index in random list #5 with four threads', async() => {
+    const result = await parallelMapReduce('./search.js', [
+      false, false, false, false, false, false, false, false, false, false, true, false,
+    ], 4);
+    expect(result.index).toBe(10);
+  });
+  test('finds an index in random list #6 with four threads', async() => {
+    const result = await parallelMapReduce('./search.js', [
+      true, false, false, false, false, false, false, false, false, false, false, false,
+    ], 4);
+    expect(result.index).toBe(0);
+  });
+});

homework-4/src/setupTests.js

+import { jest } from '@jest/globals';
+
+// This is included for consistency with `create-react-app`.  It may be become
+// unnecessary in future versions of Jest (see
+// https://github.com/facebook/jest/issues/9430#issuecomment-616232029), but
+// Jest may also choose to move away from magic globals and use imports instead,
+// which are already opt-in (see https://github.com/facebook/jest/issues/4473).
+globalThis.jest = jest;

homework-4/src/sum.js

+class MonoidElement {
+  constructor(total) {
+    this.total = total;
+  }
+}
+
+export const IDENTITY_ELEMENT = new MonoidElement(0);
+
+export function encodeAsMonoidElement(number) {
+  return new MonoidElement(number);
+}
+
+export function combineMonoidElements(left, right) {
+  return new MonoidElement(left.total + right.total);
+}

homework-4/src/sum.test.js

+import { parallelMapReduce } from './mapReduce.js';
+
+describe('map-reduce with the addition monoid', () => {
+  test('totals the example list with one thread', async() => {
+    expect((await parallelMapReduce('./sum.js', [4, 6, 8, -9], 1)).total).toEqual(9);
+  });
+  test('totals the example list with two threads', async() => {
+    expect((await parallelMapReduce('./sum.js', [4, 6, 8, -9], 2)).total).toEqual(9);
+  });
+  test('totals the example list with three threads', async() => {
+    expect((await parallelMapReduce('./sum.js', [4, 6, 8, -9], 3)).total).toEqual(9);
+  });
+  test('totals the example list with four threads', async() => {
+    expect((await parallelMapReduce('./sum.js', [4, 6, 8, -9], 4)).total).toEqual(9);
+  });
+  test('totals the example list with five threads', async() => {
+    expect((await parallelMapReduce('./sum.js', [4, 6, 8, -9], 5)).total).toEqual(9);
+  });
+});

homework-4/src/testing/failFast.js

+import jestEnvironmentNode from 'jest-environment-node';
+
+export default class FailFastEnvironment extends jestEnvironmentNode.default {
+  constructor(...rest) {
+    super(...rest);
+    this.failed = false;
+  }
+
+  async handleTestEvent(event, state) {
+    switch (event.name) {
+    case 'hook_failure':
+    case 'test_fn_failure':
+      this.failed = true;
+      break;
+    case 'test_start':
+      if (this.failed) {
+        event.test.mode = 'skip';
+      }
+      break;
+    default:
+    }
+    if (super.handleTestEvent !== undefined) {
+      await super.handleTestEvent(event, state);
+    }
+  }
+}