@woosh/meep-engine 2.80.0 → 2.81.0

package/build/meep.module.js

@@ -86056,7 +86056,7 @@ function computeStatisticalPartialMedian(values, start, end) {
 
     const range = end - start;
 
-    const position = (start + range) >> 1;
+    const position = start + (range >> 1);
 
     return copy[position];
 }

package/package.json

@@ -5,7 +5,7 @@
   "description": "Fully featured ECS game engine written in JavaScript",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "2.80.0",
+  "version": "2.81.0",
   "main": "build/meep.module.js",
   "module": "build/meep.module.js",
   "exports": {
@@ -43,7 +43,7 @@
     "pako": "2.0.3"
   },
   "peerDependencies": {
-    "three": ">=0.135.0 & <0.137.0"
+    "three": ">=0.135.0"
   },
   "devDependencies": {
     "@babel/core": "7.22.9",

package/src/core/math/bell_membership_function.js

@@ -3,7 +3,7 @@
  * @see "dbellmf" function from Matlab
  * @see https://codecrucks.com/what-is-fuzzy-membership-function-complete-guide/
  * @see https://researchhubs.com/post/maths/fundamentals/bell-shaped-function.html
- * @param {number} v
+ * @param {number} v value to be filtered (have membership adjustment applied to)
  * @param {number} a Controls window, larger value = larger window. Function will return exactly 0.5 at this distance away from center
  * @param {number} b Slope, larger slope makes function's tails sharper, meaning that values fall off faster away from center
  * @param {number} c Controls center of the bell curve

package/src/core/math/computeIsoscelesTriangleApexAngle.js

@@ -1,8 +1,8 @@
 /**
- *
+ * Compute apex angle of an isosceles triangle (triangle with two equal sides)
  * @param {number} side length of the side
  * @param {number} base length of the base
- * @returns {number}
+ * @returns {number} Apex angle in radians
  */
 export function computeIsoscelesTriangleApexAngle(side, base) {
     const b2 = base * base;

package/src/core/math/computeIsoscelesTriangleApexAngle.spec.js

@@ -0,0 +1,6 @@
+import { computeIsoscelesTriangleApexAngle } from "./computeIsoscelesTriangleApexAngle.js";
+
+test("sanity", () => {
+    // right-angle triangle
+    expect(computeIsoscelesTriangleApexAngle(1, Math.SQRT2)).toBeCloseTo(Math.PI / 2);
+});

package/src/core/math/statistics/computeStatisticalPartialMedian.js

@@ -10,15 +10,21 @@ import { number_compare_ascending } from "../../primitives/numbers/number_compar
  */
 export function computeStatisticalPartialMedian(values, start, end) {
     assert.isArrayLike(values, 'values');
+    assert.isNumber(start, 'start');
+    assert.greaterThanOrEqual(start, 0);
+
+    assert.isNumber(end, 'end');
     assert.lessThan(end, values.length);
 
+    assert.lessThanOrEqual(start, end);
+
     const copy = values.slice();
 
     copy.sort(number_compare_ascending);
 
     const range = end - start;
 
-    const position = (start + range) >> 1;
+    const position = start + (range >> 1);
 
     return copy[position];
 }

package/src/core/math/statistics/computeStatisticalPercentile.js

@@ -1,14 +1,23 @@
-import { computeStatisticalPartialMedian } from "./computeStatisticalPartialMedian.js";
+import { assert } from "../../assert.js";
 import { clamp } from "../clamp.js";
+import { computeStatisticalPartialMedian } from "./computeStatisticalPartialMedian.js";
 
 /**
  *
  * @param {number[]} values
- * @param {number} percentile_low
- * @param {number} percentile_high
+ * @param {number} percentile_low 0..1
+ * @param {number} percentile_high 0..1
  * @returns {number}
  */
 export function computeStatisticalPercentile(values, percentile_low, percentile_high) {
+    assert.isNumber(percentile_low, 'percentile_low');
+    assert.notNaN(percentile_low, 'percentile_low');
+
+    assert.isNumber(percentile_high, 'percentile_high');
+    assert.notNaN(percentile_high, 'percentile_high');
+
+    assert.greaterThanOrEqual(percentile_high, percentile_low);
+
     const n = values.length;
 
     const start = clamp(Math.floor(n * percentile_low), 0, n - 1);

package/src/core/math/statistics/computeStatisticalPercentile.spec.js

@@ -0,0 +1,11 @@
+import { computeStatisticalPercentile } from "./computeStatisticalPercentile.js";
+
+test("half", () => {
+    expect(computeStatisticalPercentile([
+        0, 1, 2, 3, 4, 5, 6, 7, 8, 9
+    ], 0, 0.5)).toBeCloseTo(2);
+
+    expect(computeStatisticalPercentile([
+        0, 1, 2, 3, 4, 5, 6, 7, 8, 9
+    ], 0.5, 1)).toBeCloseTo(7);
+});

package/src/core/math/statistics/computeStatisticalStandardDeviation.js

@@ -0,0 +1,12 @@
+import { computeStatisticalVariance } from "./computeStatisticalVariance.js";
+
+/**
+ *
+ * @param {number[]} sample
+ * @returns {number}
+ */
+export function computeStatisticalStandardDeviation(sample) {
+    const variance = computeStatisticalVariance(sample);
+
+    return Math.sqrt(variance);
+}

package/src/core/math/statistics/{computeSampleStandardDeviation.js → computeStatisticalVariance.js}

@@ -1,11 +1,11 @@
 import { computeStatisticalMean } from "./computeStatisticalMean.js";
 
 /**
- *
+ * Compute statistical variance for a given sample of numbers
  * @param {number[]} sample
  * @returns {number}
  */
-export function computeSampleStandardDeviation(sample) {
+export function computeStatisticalVariance(sample) {
     //compute sample mean
     const mean = computeStatisticalMean(sample);
 
@@ -22,7 +22,5 @@ export function computeSampleStandardDeviation(sample) {
         SUM += delta2;
     }
 
-    const variance = SUM / (N - 1);
-
-    return Math.sqrt(variance);
-}
+    return SUM / N;
+}

package/src/core/math/statistics/computeStatisticalVariance.spec.js

@@ -0,0 +1,10 @@
+import { computeStatisticalVariance } from "./computeStatisticalVariance.js";
+
+test("sanity", () => {
+
+    expect(computeStatisticalVariance([
+        1, 2, 3, 4, 5, 6
+    ]))
+        .toBeCloseTo(2.92);
+
+});

package/src/core/model/node-graph/Connection.js

@@ -1,7 +1,7 @@
-import {assert} from "../../assert.js";
-import {noop} from "../../function/Functions.js";
-import {objectKeyByValue} from "../object/objectKeyByValue.js";
-import {PortDirection} from "./node/PortDirection.js";
+import { assert } from "../../assert.js";
+import { noop } from "../../function/Functions.js";
+import { objectKeyByValue } from "../object/objectKeyByValue.js";
+import { PortDirection } from "./node/PortDirection.js";
 
 /**
  *
@@ -102,7 +102,8 @@ export class Connection {
         assert.isNumber(id, 'id');
         assert.isInteger(id, 'id');
 
-        return this.source.instance.id === id || this.target.instance.id === id;
+        return this.source?.instance?.id === id
+            || this.target?.instance?.id === id;
     }
 
     /**

package/src/core/model/node-graph/Connection.spec.js

@@ -19,3 +19,15 @@ test("equality on self", () => {
 
     expect(thing.equals(thing)).toBe(true);
 });
+
+test("isAttachedToNode", () => {
+    const connection = new Connection();
+
+    expect(connection.isAttachedToNode(0)).toBe(false);
+});
+
+test("toString", () => {
+    const ut = new Connection();
+
+    expect(typeof ut.toString()).toBe("string");
+});

package/src/core/model/node-graph/DataType.spec.js

@@ -26,3 +26,22 @@ test('equals', () => {
 
     expect(c.equals(d)).toBe(false);
 });
+
+test("hash", () => {
+
+    const a = DataType.from(7, 'kitty');
+    const b = DataType.from(7, 'kitty');
+
+    expect(a.hash()).toEqual(a.hash()); //stability
+    expect(typeof a.hash()).toBe("number");
+    expect(Number.isInteger(a.hash())).toBe(true);
+
+
+    expect(a.hash()).toEqual(b.hash());
+});
+
+test("toString", () => {
+    const type = DataType.from(7, 'kitty');
+
+    expect(typeof type.toString()).toBe("string");
+});

package/src/core/model/node-graph/node/NodeDescription.spec.js

@@ -24,4 +24,42 @@ test("get port by ID", () => {
 
     expect(port).not.toBeNull();
     expect(port.name).toBe("a");
+});
+
+test("get ports by name", () => {
+
+    const node = new NodeDescription();
+
+    expect(node.getPortsByName("a")).toEqual([]);
+
+    node.createPort(DUMMY_TYPE, "a", PortDirection.In);
+
+    const result_0 = node.getPortsByName("a");
+    expect(result_0.length).toBe(1);
+    expect(result_0[0].name).toBe("a");
+
+    node.createPort(DUMMY_TYPE, "b", PortDirection.In);
+
+    const result_1 = node.getPortsByName("a");
+    expect(result_1.length).toBe(1);
+    expect(result_1[0].name).toBe("a");
+});
+
+test("delete port", () => {
+    const node = new NodeDescription();
+
+    expect(node.deletePort(1)).toBe(false);
+
+    const id = node.createPort(DUMMY_TYPE, "a", PortDirection.In);
+
+    expect(node.deletePort(id)).toBe(true);
+
+    expect(node.getPorts()).toEqual([]);
+});
+
+test("toString", () => {
+    const node = new NodeDescription();
+
+    expect(typeof node.toString()).toBe("string");
+    expect(node.toString().length).toBeGreaterThan(0);
 });

package/src/core/model/node-graph/node/NodeInstancePortReference.spec.js

@@ -0,0 +1,66 @@
+import { DataType } from "../DataType.js";
+import { NodeGraph } from "../NodeGraph.js";
+import { NodeDescription } from "./NodeDescription.js";
+import { NodeInstancePortReference } from "./NodeInstancePortReference.js";
+import { PortDirection } from "./PortDirection.js";
+
+const DUMMY_TYPE = DataType.from(0, 'dummy');
+test("constructor does not throw", () => {
+    new NodeInstancePortReference()
+});
+
+test("outgoing connections", () => {
+    const nd = new NodeDescription();
+    const port_a_id = nd.createPort(DUMMY_TYPE, "a", PortDirection.Out);
+    const port_b_id = nd.createPort(DUMMY_TYPE, "b", PortDirection.In);
+
+
+    const graph = new NodeGraph();
+    const node_instance_id = graph.createNode(nd);
+
+    const port_a_ref = graph.getConnectionEndpoint(node_instance_id, port_a_id);
+
+    expect(port_a_ref.outConnections).toEqual([]);
+
+    const connection_id = graph.createConnection(node_instance_id, port_a_id, node_instance_id, port_b_id);
+
+    const connection = graph.getConnection(connection_id);
+
+    expect(port_a_ref.outConnections).toEqual([connection]);
+});
+
+test("incoming connections", () => {
+    const nd = new NodeDescription();
+    const port_a_id = nd.createPort(DUMMY_TYPE, "a", PortDirection.Out);
+    const port_b_id = nd.createPort(DUMMY_TYPE, "b", PortDirection.In);
+
+
+    const graph = new NodeGraph();
+    const node_instance_id = graph.createNode(nd);
+
+    const port_b_ref = graph.getConnectionEndpoint(node_instance_id, port_b_id);
+
+    expect(port_b_ref.inConnections).toEqual([]);
+
+    const connection_id = graph.createConnection(node_instance_id, port_a_id, node_instance_id, port_b_id);
+
+    const connection = graph.getConnection(connection_id);
+
+    expect(port_b_ref.inConnections).toEqual([connection]);
+});
+
+test("hash", () => {
+
+    const nd = new NodeDescription();
+    const port_a_id = nd.createPort(DUMMY_TYPE, "a", PortDirection.Out);
+
+
+    const graph = new NodeGraph();
+    const node_instance_id = graph.createNode(nd);
+
+    const port_a_ref = graph.getConnectionEndpoint(node_instance_id, port_a_id);
+
+    expect(port_a_ref.hash()).toEqual(port_a_ref.hash());
+    expect(typeof port_a_ref.hash()).toBe("number");
+    expect(Number.isInteger(port_a_ref.hash())).toBe(true);
+});

package/src/core/model/node-graph/util/graph_clone_by_node_subset.js

@@ -1,16 +1,13 @@
-import { NodeGraph } from "../NodeGraph.js";
 import { assert } from "../../../assert.js";
+import { NodeGraph } from "../NodeGraph.js";
 import { graph_collect_connections_amongst_nodes } from "./graph_collect_connections_amongst_nodes.js";
 
 /**
  * Clone portion of a graph as a new graph, retaining connections amongst those nodes
- * @param {NodeGraph} graph
  * @param {NodeInstance[]} nodes
+ * @returns {NodeGraph}
  */
-export function graph_clone_by_node_subset({ graph, nodes }) {
-
-    assert.defined(graph, 'graph');
-    assert.notNull(graph, 'graph');
+export function graph_clone_by_node_subset({ nodes }) {
 
     assert.defined(nodes, 'nodes');
     assert.notNull(nodes, 'nodes');
@@ -18,7 +15,7 @@ export function graph_clone_by_node_subset({ graph, nodes }) {
 
     const result = new NodeGraph();
 
-    const connections = graph_collect_connections_amongst_nodes({ graph, nodes });
+    const connections = graph_collect_connections_amongst_nodes({ nodes });
 
     result.mergeFragment({
         nodes,

package/src/core/model/node-graph/util/graph_collect_connections_amongst_nodes.js

@@ -1,11 +1,9 @@
 /**
  * Given a graph and a set of nodes, get all connections that connect these nodes amongst themselves
- * @param {NodeGraph} graph
  * @param {NodeInstance[]} nodes
  * @returns {Connection[]}
  */
 export function graph_collect_connections_amongst_nodes({
-                                                            graph,
                                                             nodes
                                                         }) {