@woosh/meep-engine 2.109.23 → 2.109.25

package/src/core/collection/heap/FastBinaryHeap.spec.js

@@ -2,20 +2,20 @@ import { passThrough } from "../../function/passThrough.js";
 import { returnZero } from "../../function/returnZero.js";
 import { randomIntegerBetween } from "../../math/random/randomIntegerBetween.js";
 import { seededRandom } from "../../math/random/seededRandom.js";
-import BinaryHeap from "./FastBinaryHeap.js";
+import FastBinaryHeap from "./FastBinaryHeap.js";
 
 test("constructor doesn't throw", () => {
-    new BinaryHeap(returnZero);
+    new FastBinaryHeap(returnZero);
 });
 
 test("empty heap has size 0", () => {
-    const h = new BinaryHeap(returnZero);
+    const h = new FastBinaryHeap(returnZero);
 
     expect(h.size()).toBe(0);
 });
 
 test('clear empty', () => {
-    const h = new BinaryHeap(returnZero);
+    const h = new FastBinaryHeap(returnZero);
 
     h.clear();
 
@@ -24,7 +24,7 @@ test('clear empty', () => {
 });
 
 test('clear heap with 1 element', () => {
-    const h = new BinaryHeap(returnZero);
+    const h = new FastBinaryHeap(returnZero);
 
     h.push(1);
 
@@ -35,7 +35,7 @@ test('clear heap with 1 element', () => {
 });
 
 test("isEmpty", () => {
-    const h = new BinaryHeap(returnZero);
+    const h = new FastBinaryHeap(returnZero);
 
     expect(h.isEmpty()).toBe(true);
 
@@ -49,7 +49,7 @@ test("isEmpty", () => {
 });
 
 test("push followed by a pop", () => {
-    const h = new BinaryHeap(returnZero);
+    const h = new FastBinaryHeap(returnZero);
 
     h.push(7);
 
@@ -63,7 +63,7 @@ test("push followed by a pop", () => {
 });
 
 test("contains method", () => {
-    const h = new BinaryHeap(returnZero);
+    const h = new FastBinaryHeap(returnZero);
 
     expect(h.contains(7)).toBe(false);
 
@@ -82,7 +82,7 @@ test("contains method", () => {
 });
 
 test("correct sorting of 4 numbers", () => {
-    const h = new BinaryHeap(passThrough);
+    const h = new FastBinaryHeap(passThrough);
 
     const input = [2, 7, 1, 5];
 
@@ -100,7 +100,7 @@ test("correct sorting of 4 numbers", () => {
 });
 
 test.skip("performance 100k random fill -> drain", () => {
-    const h = new BinaryHeap(passThrough);
+    const h = new FastBinaryHeap(passThrough);
 
     const random = seededRandom(42);
 

package/src/core/collection/table/RowFirstTable.d.ts

@@ -1,7 +1,10 @@
+/**
+ * Compact binary table storage
+ */
 export class RowFirstTable {
     /**
      *
-     * @param {RowFirstTableSpec} spec
+     * @param {RowFirstTableSpec} spec what does the schema look like? How many columns do we have and what are their types?
      * @param {boolean} [shared_array] should we use SharedArrayBuffer instead of ArrayBuffer?
      * @constructor
      */
@@ -71,9 +74,9 @@ export class RowFirstTable {
     hash(): number;
     /**
      *
-     * @param {int} rowCount
+     * @param {number} rowCount
      */
-    setCapacity(rowCount: int): void;
+    setCapacity(rowCount: number): void;
     /**
      * Drop excess capacity, setting capacity exactly to the current length
      */
@@ -112,15 +115,15 @@ export class RowFirstTable {
     insertRows(index: number, rowCount: number): void;
     /**
      *
-     * @param {Array.<Number>} values
+     * @param {Array.<number>} values
      */
     addRow(values: Array<number>): void;
     /**
      *
-     * @param {int} count number of rows to be added
-     * @param {function} valueSupplier supplier of row values, called with row index and an empty row to be filled
+     * @param {number} count number of rows to be added
+     * @param {function(row_index:number, row:Array.<number>):*} valueSupplier supplier of row values, called with row index and an empty row to be filled
      */
-    addRows(count: int, valueSupplier: Function): void;
+    addRows(count: number, valueSupplier: any): void;
     /**
      * Copy data from another table. Specs must match.
      * NOTE: does not send onAdded signal

package/src/core/collection/table/RowFirstTable.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RowFirstTable.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/table/RowFirstTable.js"],"names":[],"mappings":"AAMA;IACI;;;;;OAKG;IACH,oDAHW,OAAO,EAuDjB;IA/CG;;;OAGG;IACH,wBAAgB;IAEhB;;;OAGG;IACH,gBAFU,qBAAsB,CAET;IAEvB;;;OAGG;IACH,MAFU,WAAW,CAEuB;IAE5C;;;OAGG;IACH,gBAFU,MAAM,CAEyB;IAEzC;;;OAGG;IACH,QAFU,MAAM,CAED;IAEf;;;OAGG;IACH,UAFU,MAAM,CAEC;IAEjB;;;OAGG;IACH,UAFU,QAAQ,CAEE;IAEpB;;MAEC;IAKL;;OAEG;IACH,mBAiBC;IAXG;;;OAGG;IACH,sBAFmB,QAAQ,QAAE,MAAM,QAAE,MAAM,EAAE,KAAG,IAAI,CAEb;IAEvC;;;OAGG;IACH,uBAFmB,QAAQ,QAAE,MAAM,QAAE,MAAM,EAAE,KAAG,IAAI,CAEX;IAG7C;;;;OAIG;IACH,uDAMC;IAED;;;OAGG;IACH,QAFa,MAAM,CA4BlB;IAED;;;OAGG;IACH,iCAoCC;IAED;;OAEG;IACH,aAEC;IAED;;;OAGG;IACH,iBAFW,MAAM,QAYhB;IAED;;;;;OAKG;IACH,yBAJW,MAAM,eACN,MAAM,SACN,MAAM,QAchB;IAED;;;;;OAKG;IACH,wBAJW,MAAM,eACN,MAAM,GACJ,MAAM,CAclB;IAED;;;;OAIG;IACH,kBAHW,MAAM,YACN,MAAM,QAyBhB;IAED;;;;;OAKG;IACH,kBAHW,MAAM,YACN,MAAM,QAqBhB;IAED;;;OAGG;IACH,eAFW,aAAc,QAgBxB;IAED;;;;OAIG;IACH,mDAiCC;IAED;;;;OAIG;IACH,YAFW,aAAa,QAsBvB;IAED;;;OAGG;IACH,cAHW,aAAa,GACX,OAAO,CAyBnB;IAED;;;;OAIG;IACH,wCAEC;IAED;;;;OAIG;IACH,cAHW,MAAM,UACN,MAAM,EAAE,QAIlB;IAED;;OAEG;IACH,qBA4BC;IAED;;OAEG;IACH,cAIC;IAED;;;OAGG;IACH,wBAEC;IAED;;;OAGG;IACH,cAFa,MAAM,EAAE,EAAE,CAgBtB;IAED;;OAEG;IACH,uBAIC;CACJ;mBA1fkB,+BAA+B"}
+{"version":3,"file":"RowFirstTable.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/table/RowFirstTable.js"],"names":[],"mappings":"AAMA;;GAEG;AACH;IACI;;;;;OAKG;IACH,oDAHW,OAAO,EAuDjB;IA/CG;;;OAGG;IACH,wBAAgB;IAEhB;;;OAGG;IACH,gBAFU,qBAAsB,CAET;IAEvB;;;OAGG;IACH,MAFU,WAAW,CAEuB;IAE5C;;;OAGG;IACH,gBAFU,MAAM,CAEyB;IAEzC;;;OAGG;IACH,QAFU,MAAM,CAED;IAEf;;;OAGG;IACH,UAFU,MAAM,CAEC;IAEjB;;;OAGG;IACH,UAFU,QAAQ,CAEE;IAEpB;;MAEC;IAKL;;OAEG;IACH,mBAiBC;IAXG;;;OAGG;IACH,sBAFmB,QAAQ,QAAE,MAAM,QAAE,MAAM,EAAE,KAAG,IAAI,CAEb;IAEvC;;;OAGG;IACH,uBAFmB,QAAQ,QAAE,MAAM,QAAE,MAAM,EAAE,KAAG,IAAI,CAEX;IAG7C;;;;OAIG;IACH,uDAMC;IAED;;;OAGG;IACH,QAFa,MAAM,CA4BlB;IAED;;;OAGG;IACH,sBAFW,MAAM,QA+ChB;IAED;;OAEG;IACH,aAEC;IAED;;;OAGG;IACH,iBAFW,MAAM,QAchB;IAED;;;;;OAKG;IACH,yBAJW,MAAM,eACN,MAAM,SACN,MAAM,QAchB;IAED;;;;;OAKG;IACH,wBAJW,MAAM,eACN,MAAM,GACJ,MAAM,CAclB;IAED;;;;OAIG;IACH,kBAHW,MAAM,YACN,MAAM,QAyBhB;IAED;;;;;OAKG;IACH,kBAHW,MAAM,YACN,MAAM,QAqBhB;IAED;;;OAGG;IACH,eAFW,MAAO,MAAM,CAAC,QAexB;IAED;;;;OAIG;IACH,eAHW,MAAM,4BAoChB;IAED;;;;OAIG;IACH,YAFW,aAAa,QAsBvB;IAED;;;OAGG;IACH,cAHW,aAAa,GACX,OAAO,CAyBnB;IAED;;;;OAIG;IACH,wCAIC;IAED;;;;OAIG;IACH,cAHW,MAAM,UACN,MAAM,EAAE,QAMlB;IAED;;OAEG;IACH,qBA4BC;IAED;;OAEG;IACH,cAIC;IAED;;;OAGG;IACH,wBAEC;IAED;;;OAGG;IACH,cAFa,MAAM,EAAE,EAAE,CAgBtB;IAED;;OAEG;IACH,uBAIC;CACJ;mBA3gBkB,+BAA+B"}

package/src/core/collection/table/RowFirstTable.js

@@ -4,10 +4,13 @@ import Signal from "../../events/signal/Signal.js";
 import { max2 } from "../../math/max2.js";
 import { array_copy } from "../array/array_copy.js";
 
+/**
+ * Compact binary table storage
+ */
 export class RowFirstTable {
     /**
      *
-     * @param {RowFirstTableSpec} spec
+     * @param {RowFirstTableSpec} spec what does the schema look like? How many columns do we have and what are their types?
      * @param {boolean} [shared_array] should we use SharedArrayBuffer instead of ArrayBuffer?
      * @constructor
      */
@@ -134,13 +137,22 @@ export class RowFirstTable {
 
     /**
      *
-     * @param {int} rowCount
+     * @param {number} rowCount
      */
     setCapacity(rowCount) {
+        assert.isNonNegativeInteger(rowCount, 'rowCount');
+
+        if(this.capacity === rowCount){
+            // already right size
+            return;
+        }
+
+
         const oldData = this.data;
 
         const bytesPerRecord = this.bytesPerRecord;
         const byteSize = rowCount * bytesPerRecord;
+
         try {
             // can be either ArrayBuffer or SharedArrayBuffer
             const BufferConstructor = this.data.constructor;
@@ -186,6 +198,8 @@ export class RowFirstTable {
      * @param {number} rowCount
      */
     resize(rowCount) {
+        assert.isNonNegativeInteger(rowCount, 'rowCount');
+
         if (this.capacity < rowCount) {
             //grow
             const growFactor = 1.5;
@@ -296,7 +310,7 @@ export class RowFirstTable {
 
     /**
      *
-     * @param {Array.<Number>} values
+     * @param {Array.<number>} values
      */
     addRow(values) {
 
@@ -308,7 +322,6 @@ export class RowFirstTable {
 
         this.length = newRowCount;
 
-
         this.writeRowMethod(this.dataView, this.bytesPerRecord * rowIndex, values);
 
         this.on.added.send2(rowIndex, values);
@@ -316,8 +329,8 @@ export class RowFirstTable {
 
     /**
      *
-     * @param {int} count number of rows to be added
-     * @param {function} valueSupplier supplier of row values, called with row index and an empty row to be filled
+     * @param {number} count number of rows to be added
+     * @param {function(row_index:number, row:Array.<number>):*} valueSupplier supplier of row values, called with row index and an empty row to be filled
      */
     addRows(count, valueSupplier) {
         const newRowCount = this.length + count;
@@ -416,6 +429,8 @@ export class RowFirstTable {
      * @param {Array} result where row values are to be stored
      */
     getRow(index, result) {
+        assert.isNonNegativeInteger(index,'index');
+
         this.readRowMethod(this.dataView, this.bytesPerRecord * index, result);
     }
 
@@ -425,6 +440,8 @@ export class RowFirstTable {
      * @param {number[]} record
      */
     setRow(index, record) {
+        assert.isNonNegativeInteger(index,'index');
+
         this.writeRowMethod(this.dataView, this.bytesPerRecord * index, record);
     }
 

package/src/core/collection/table/bind/TableRecord.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TableRecord.d.ts","sourceRoot":"","sources":["../../../../../../src/core/collection/table/bind/TableRecord.js"],"names":[],"mappings":"AAGA;IA+DI;;;OAGG;IACH,yBAUC;IA7BD,qBAEC;IAND,kBAEC;IAOD,uBAIC;IAED,YAEC;IAkBD,sCAEC;IAED;;;;OAIG;IACH,sCAFW,MAAM,QAKhB;;CACJ;kCA9FiC,yBAAyB"}
+{"version":3,"file":"TableRecord.d.ts","sourceRoot":"","sources":["../../../../../../src/core/collection/table/bind/TableRecord.js"],"names":[],"mappings":"AAKA;IA+DI;;;OAGG;IACH,yBAYC;IA/BD,qBAEC;IAND,kBAEC;IAOD,uBAIC;IAED,YAEC;IAoBD,sCAEC;IAED;;;;OAIG;IACH,sCAFW,MAAM,QAKhB;;CACJ;kCAhGiC,yBAAyB"}

package/src/core/collection/table/bind/TableRecord.js

@@ -1,4 +1,6 @@
 import { assert } from "../../../assert.js";
+import { BinaryDataType } from "../../../binary/type/BinaryDataType.js";
+import { validate_enum_schema } from "../../../model/validate_enum_schema.js";
 import { RowFirstTableSpec } from "../RowFirstTableSpec.js";
 
 export class TableRecord {
@@ -72,6 +74,8 @@ export class TableRecord {
         assert.notNull(schema, 'schema');
         assert.defined(schema, 'schema');
 
+        assert.ok(validate_enum_schema(schema, BinaryDataType, console.warn), 'invalid schema');
+
         this.#schema = schema;
         const keys = Object.keys(schema);
 

package/src/core/geom/3d/normal/octahedron/encode_unit_to_octahedron.js

@@ -23,10 +23,10 @@ export function encode_unit_to_octahedron(
     const inverse_sum = 1 / abs_sum;
 
     let p_x = x * inverse_sum;
-    let p_y = y * inverse_sum;
+    let p_y = z * inverse_sum;
 
     // Reflect the folds of the lower hemisphere over the diagonals
-    if (z < 0) {
+    if (y < 0) {
         const abs_x = Math.abs(p_x);
         const abs_y = Math.abs(p_y);
 

package/src/core/geom/packing/max-rect/MaxRectanglesPacker.js

@@ -1,5 +1,5 @@
 import { assert } from "../../../assert.js";
-import BinaryHeap from "../../../collection/heap/FastBinaryHeap.js";
+import FastBinaryHeap from "../../../collection/heap/FastBinaryHeap.js";
 import AABB2 from "../../2d/aabb/AABB2.js";
 import { QuadTreeDatum } from "../../2d/quad-tree/QuadTreeDatum.js";
 import { QuadTreeNode } from "../../2d/quad-tree/QuadTreeNode.js";
@@ -136,7 +136,7 @@ export class MaxRectanglesPacker {
             return -Math.min(box.getWidth(), box.getHeight());
         }
 
-        const heap = new BinaryHeap(scoreBoxByMinSide);
+        const heap = new FastBinaryHeap(scoreBoxByMinSide);
 
         for (let i = 0; i < numBoxes; i++) {
             heap.push(i);

package/src/core/model/validate_enum_schema.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @template T
+ * @param {Object<BinaryDataType>} schema
+ * @param {Object<T>} enumerable
+ * @param {function(message:string)} [error_consumer]
+ * @param {*} [error_consumer_context]
+ */
+export function validate_enum_schema<T>(schema: any, enumerable: any, error_consumer?: typeof noop, error_consumer_context?: any): boolean;
+import { noop } from "../function/noop.js";
+//# sourceMappingURL=validate_enum_schema.d.ts.map

package/src/core/model/validate_enum_schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate_enum_schema.d.ts","sourceRoot":"","sources":["../../../../src/core/model/validate_enum_schema.js"],"names":[],"mappings":"AAGA;;;;;;GAMG;AACH,2IAoBC;qBA7BoB,qBAAqB"}

package/src/core/model/validate_enum_schema.js

@@ -0,0 +1,31 @@
+import { assert } from "../assert.js";
+import { noop } from "../function/noop.js";
+
+/**
+ * @template T
+ * @param {Object<BinaryDataType>} schema
+ * @param {Object<T>} enumerable
+ * @param {function(message:string)} [error_consumer]
+ * @param {*} [error_consumer_context]
+ */
+export function validate_enum_schema(schema, enumerable, error_consumer = noop, error_consumer_context) {
+
+    assert.notNull(schema, 'schema');
+    assert.isObject(schema, 'schema');
+
+    let valid = true;
+    const valid_types = Object.values(enumerable);
+
+    for (const schemaKey in schema) {
+
+        const type = schema[schemaKey];
+
+        if (!valid_types.includes(type)) {
+            error_consumer.call(error_consumer_context, `Field '${schemaKey}' is expected to have have BinaryDataType value, instead found '${type}'. Valid values are: ${valid_types.join(', ')}.`);
+            valid = false;
+        }
+
+    }
+
+    return valid;
+}

package/src/engine/animation/async/TimeSeries.d.ts

@@ -0,0 +1,76 @@
+/**
+ * @template T
+ */
+export class TimeSeries<T> {
+    /**
+     *
+     * @param {Object<BinaryDataType>} schema
+     * @param {string} [time_column_name]
+     */
+    constructor(schema: any, time_column_name?: string);
+    /**
+     * @type {RowFirstTableSpec}
+     */
+    spec: RowFirstTableSpec;
+    /**
+     * @type {RowFirstTable}
+     */
+    table: RowFirstTable;
+    time_column_index: number;
+    /**
+     *
+     * @param {number} index
+     * @returns {Object}
+     */
+    getSampleObjectByIndex(index: number): any;
+    /**
+     *
+     * @returns {number}
+     */
+    get sample_count(): number;
+    /**
+     *
+     * @returns {number}
+     */
+    get last_timestamp(): number;
+    validateNextSample(data: any): void;
+    /**
+     *
+     * @param {number[]} data
+     */
+    addSample(data: number[]): void;
+    /**
+     *
+     * @param {Object} sample
+     */
+    addObjectSample(sample: any): void;
+    /**
+     *
+     * @param {number[]} result
+     * @param {number} index
+     */
+    getSampleByIndex(result: number[], index: number): void;
+    /**
+     *
+     * @param {number} time
+     * @returns {number}
+     */
+    findLowSampleIndexByTime(time: number): number;
+    /**
+     *
+     * @param {number[]} result
+     * @param {number} result_offset
+     * @param {number} time
+     */
+    sampleLinear(result: number[], result_offset: number, time: number): void;
+    /**
+     * Get linearly interpolated sample for given time in object form, following supplied schema
+     * @param {number} time
+     * @returns {Object}
+     */
+    sampleObjectLinear(time: number): any;
+    #private;
+}
+import { RowFirstTableSpec } from "../../../core/collection/table/RowFirstTableSpec.js";
+import { RowFirstTable } from "../../../core/collection/table/RowFirstTable.js";
+//# sourceMappingURL=TimeSeries.d.ts.map

package/src/engine/animation/async/TimeSeries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TimeSeries.d.ts","sourceRoot":"","sources":["../../../../../src/engine/animation/async/TimeSeries.js"],"names":[],"mappings":"AAiBA;;GAEG;AACH;IA+BI;;;;OAIG;IACH,4CAFW,MAAM,EAuChB;IAxED;;OAEG;IACH,MAFU,iBAAiB,CAEvB;IAEJ;;OAEG;IACH,OAFU,aAAa,CAElB;IAEL,0BAAsB;IAyHtB;;;;OAIG;IACH,8BAHW,MAAM,OAOhB;IAED;;;OAGG;IACH,2BAEC;IAED;;;OAGG;IACH,6BAWC;IAED,oCAcC;IAED;;;OAGG;IACH,gBAFW,MAAM,EAAE,QAQlB;IAED;;;OAGG;IACH,mCAIC;IAED;;;;OAIG;IACH,yBAHW,MAAM,EAAE,SACR,MAAM,QAIhB;IAED;;;;OAIG;IACH,+BAHW,MAAM,GACJ,MAAM,CAMlB;IAED;;;;;OAKG;IACH,qBAJW,MAAM,EAAE,iBACR,MAAM,QACN,MAAM,QAuBhB;IAED;;;;OAIG;IACH,yBAHW,MAAM,OAShB;;CAEJ;kCA7RiC,qDAAqD;8BADzD,iDAAiD"}

package/src/engine/animation/async/TimeSeries.js

@@ -0,0 +1,289 @@
+import { assert } from "../../../core/assert.js";
+import { BinaryDataType } from "../../../core/binary/type/BinaryDataType.js";
+import { RowFirstTable } from "../../../core/collection/table/RowFirstTable.js";
+import { RowFirstTableSpec } from "../../../core/collection/table/RowFirstTableSpec.js";
+import { inverseLerp } from "../../../core/math/inverseLerp.js";
+import { lerp } from "../../../core/math/lerp.js";
+import { max2 } from "../../../core/math/max2.js";
+import { min2 } from "../../../core/math/min2.js";
+import { validate_enum_schema } from "../../../core/model/validate_enum_schema.js";
+import { table_find_min_index_in_ordered_column } from "./table_find_min_index_in_ordered_column.js";
+
+/**
+ *
+ * @type {number[]}
+ */
+const scratch_row = [];
+
+/**
+ * @template T
+ */
+export class TimeSeries {
+    /**
+     * @type {RowFirstTableSpec}
+     */
+    spec
+
+    /**
+     * @type {RowFirstTable}
+     */
+    table
+
+    time_column_index = 0;
+
+    /**
+     *
+     * @type {Object<BinaryDataType>}
+     */
+    #schema = {}
+
+    /**
+     *
+     * @type {Object<number>}
+     */
+    #schema_column_names_to_indices = {};
+
+    /**
+     *
+     * @type {string[]}
+     */
+    #schema_column_indices_to_names = [];
+
+    /**
+     *
+     * @param {Object<BinaryDataType>} schema
+     * @param {string} [time_column_name]
+     */
+    constructor(schema, time_column_name = 'time') {
+        assert.isString(time_column_name, 'time_column_name');
+        assert.notNull(schema, 'schema');
+        assert.isObject(schema, 'schema');
+
+        let issues = [];
+
+        if (!validate_enum_schema(schema, BinaryDataType, (issue) => issues.push(issue))) {
+            throw new TypeError(`Invalid schema. Problems:\n ${issues.join('\n')}`);
+        }
+
+        this.#schema = schema;
+
+        const schema_keys = Object.keys(schema);
+
+        const time_row_index = schema_keys.indexOf(time_column_name);
+
+        if (time_row_index === -1) {
+            throw new TypeError(`supplies schema does not include time column '${time_column_name}', exising columns: ${schema_keys.join(', ')}`);
+        }
+
+        this.time_column_index = time_row_index;
+
+
+        this.#schema_column_names_to_indices = {};
+
+        for (let i = 0; i < schema_keys.length; i++) {
+            const key = schema_keys[i];
+
+            this.#schema_column_names_to_indices[key] = i;
+            this.#schema_column_indices_to_names[i] = key;
+        }
+
+        this.spec = RowFirstTableSpec.get(Object.values(schema));
+
+        this.table = new RowFirstTable(this.spec);
+
+    }
+
+    /**
+     *
+     * @param {number[]} row
+     * @param {Object} object
+     */
+    #object_to_row(row, object) {
+
+        const columnCount = this.spec.getColumnCount();
+
+        for (let i = 0; i < columnCount; i++) {
+
+            const key = this.#schema_column_indices_to_names[i];
+
+            const value = object[key];
+
+            const t = typeof value;
+
+            if (t !== "number") {
+                throw new TypeError(`Expected sample.${key} to be a number, instead was ${t} (=${value})`);
+            }
+
+            row[i] = value;
+
+        }
+    }
+
+    /**
+     *
+     * @param {Object} object
+     * @param {number[]} row
+     */
+    #row_to_object(object, row) {
+
+        const columnCount = this.spec.getColumnCount();
+        for (let i = 0; i < columnCount; i++) {
+
+            const key = this.#schema_column_indices_to_names[i];
+
+            object[key] = row[i];
+        }
+
+    }
+
+    /**
+     *
+     * @param {number[]} row
+     * @returns {Object}
+     */
+    #row_to_object_allocating(row) {
+
+        const result = {};
+
+        this.#row_to_object(result, row);
+
+        return result;
+    }
+
+    /**
+     *
+     * @param {number} index
+     * @returns {Object}
+     */
+    getSampleObjectByIndex(index) {
+        this.table.getRow(index, scratch_row);
+
+        return this.#row_to_object_allocating(scratch_row);
+    }
+
+    /**
+     *
+     * @returns {number}
+     */
+    get sample_count() {
+        return this.table.length;
+    }
+
+    /**
+     *
+     * @returns {number}
+     */
+    get last_timestamp() {
+        const table = this.table;
+        const record_count = table.length;
+
+        if (record_count === 0) {
+            // default
+            return 0;
+        }
+
+        const time_column = this.time_column_index;
+        return table.readCellValue(record_count - 1, time_column);
+    }
+
+    validateNextSample(data) {
+
+        const table = this.table;
+        const record_count = table.length;
+
+        if (record_count > 0) {
+            const time_column = this.time_column_index;
+            const last_time = table.readCellValue(record_count - 1, time_column);
+
+            if (data[time_column] <= last_time) {
+                throw new Error(`Sample.time[${time_column}] = ${data[time_column]}, which is <= to previous time stamp(=${last_time}). Each sample's time stamp must be strictly greater than the previous one`);
+            }
+        }
+
+    }
+
+    /**
+     *
+     * @param {number[]} data
+     */
+    addSample(data) {
+        // validate
+        this.validateNextSample(data);
+
+        const table = this.table;
+        table.addRow(data);
+    }
+
+    /**
+     *
+     * @param {Object} sample
+     */
+    addObjectSample(sample) {
+        this.#object_to_row(scratch_row, sample);
+
+        this.addSample(scratch_row);
+    }
+
+    /**
+     *
+     * @param {number[]} result
+     * @param {number} index
+     */
+    getSampleByIndex(result, index) {
+        this.table.getRow(index, result)
+    }
+
+    /**
+     *
+     * @param {number} time
+     * @returns {number}
+     */
+    findLowSampleIndexByTime(time) {
+        const table = this.table;
+        const time_column_index = this.time_column_index;
+        return max2(0, table_find_min_index_in_ordered_column(table, time, time_column_index))
+    }
+
+    /**
+     *
+     * @param {number[]} result
+     * @param {number} result_offset
+     * @param {number} time
+     */
+    sampleLinear(result, result_offset, time) {
+        const table = this.table;
+        const time_column_index = this.time_column_index;
+
+        // seek to the right sample
+        const sample_index = this.findLowSampleIndexByTime(time);
+        const next_sample_index = min2(table.length - 1, sample_index + 1);
+
+        const prev = table.readCellValue(sample_index, time_column_index);
+        const next = table.readCellValue(next_sample_index, time_column_index);
+
+        const normalized_offset = inverseLerp(prev, next, time);
+
+        const column_count = this.spec.getColumnCount();
+
+        for (let i = 0; i < column_count; i++) {
+            const v0 = table.readCellValue(sample_index, i);
+            const v1 = table.readCellValue(next_sample_index, i);
+
+            result[result_offset + i] = lerp(v0, v1, normalized_offset)
+        }
+    }
+
+    /**
+     * Get linearly interpolated sample for given time in object form, following supplied schema
+     * @param {number} time
+     * @returns {Object}
+     */
+    sampleObjectLinear(time) {
+
+        this.sampleLinear(scratch_row, 0, time);
+
+        return this.#row_to_object_allocating(scratch_row);
+
+    }
+
+}