diff --git a/lib/node_modules/@stdlib/ml/base/kmeans/stats/struct-factory/README.md b/lib/node_modules/@stdlib/ml/base/kmeans/stats/struct-factory/README.md new file mode 100644 index 000000000000..55f1d077ba06 --- /dev/null +++ b/lib/node_modules/@stdlib/ml/base/kmeans/stats/struct-factory/README.md @@ -0,0 +1,145 @@ + + +# structFactory + +> Create a new [`struct`][@stdlib/dstructs/struct] constructor tailored to a specified floating-point data type. + + + +
+ +
+ + + + + +
+ +## Usage + +```javascript +var structFactory = require( '@stdlib/ml/base/kmeans/stats/struct-factory' ); +``` + +#### structFactory( dtype, k ) + +Returns a new [`struct`][@stdlib/dstructs/struct] constructor tailored to a specified floating-point data type. + +```javascript +var Struct = structFactory( 'float64', 5 ); +// returns + +var s = new Struct(); +// returns +``` + +The function supports the following parameters: + +- **dtype**: floating-point data type for storing floating-point results. Must be either `'float64'` or `'float32'`. +- **k**: number of centroids. + +
+ + + + + +
+ +## Notes + +- A [`struct`][@stdlib/dstructs/struct] provides a fixed-width composite data structure for storing kmeans clustering statistics and provides an ABI-stable data layout for JavaScript-C interoperation. + +
+ + + + + +
+ +## Examples + + + +```javascript +var Float64Array = require( '@stdlib/array/float64' ); +var Float32Array = require( '@stdlib/array/float32' ); +var Int32Array = require( '@stdlib/array/int32' ); +var structFactory = require( '@stdlib/ml/base/kmeans/stats/struct-factory' ); + +var Struct = structFactory( 'float64', 2 ); +var results = new Struct({ + 'nObs': new Int32Array( [ 3, 2 ] ), + 'sumSquaredDist': new Float64Array( [ 9.998, 11.412 ] ), + 'meanSquaredDist': new Float64Array( [ 4.353, 2.897 ] ), + 'stdevSquaredDist': new Float64Array( [ 1.232, 8.913 ] ) +}); + +var str = results.toString({ + 'format': 'linear' +}); +console.log( str ); + +Struct = structFactory( 'float32', 2 ); +results = new Struct({ + 'nObs': new Int32Array( [ 3, 2 ] ), + 'sumSquaredDist': new Float32Array( [ 9.998, 11.412 ] ), + 'meanSquaredDist': new Float32Array( [ 4.353, 2.897 ] ), + 'stdevSquaredDist': new Float32Array( [ 1.232, 8.913 ] ) +}); + +str = results.toString({ + 'format': 'linear' +}); +console.log( str ); +``` + +
+ + + + + +
+ +
+ + + + + +
+ +
+ + + + + +
+ +[@stdlib/dstructs/struct]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/dstructs/struct + +
+ + diff --git a/lib/node_modules/@stdlib/ml/base/kmeans/stats/struct-factory/benchmark/benchmark.js b/lib/node_modules/@stdlib/ml/base/kmeans/stats/struct-factory/benchmark/benchmark.js new file mode 100644 index 000000000000..ac81a9917743 --- /dev/null +++ b/lib/node_modules/@stdlib/ml/base/kmeans/stats/struct-factory/benchmark/benchmark.js @@ -0,0 +1,56 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2026 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var bench = require( '@stdlib/bench' ); +var isFunction = require( '@stdlib/assert/is-function' ); +var pkg = require( './../package.json' ).name; +var factory = require( './../lib' ); + + +// MAIN // + +bench( pkg, function benchmark( b ) { + var values; + var v; + var k; + var i; + + values = [ + 'float64', + 'float32' + ]; + k = 10; + + b.tic(); + for ( i = 0; i < b.iterations; i++ ) { + v = factory( values[ i%values.length ], k ); + if ( typeof v !== 'function' ) { + b.fail( 'should return a function' ); + } + } + b.toc(); + if ( !isFunction( v ) ) { + b.fail( 'should return a function' ); + } + b.pass( 'benchmark finished' ); + b.end(); +}); diff --git a/lib/node_modules/@stdlib/ml/base/kmeans/stats/struct-factory/docs/repl.txt b/lib/node_modules/@stdlib/ml/base/kmeans/stats/struct-factory/docs/repl.txt new file mode 100644 index 000000000000..878f735724f3 --- /dev/null +++ b/lib/node_modules/@stdlib/ml/base/kmeans/stats/struct-factory/docs/repl.txt @@ -0,0 +1,28 @@ + +{{alias}}( dtype, k ) + Returns a new struct constructor tailored to a specified floating-point data + type. + + Parameters + ---------- + dtype: string + Floating-point data type for storing floating-point statistics. + + k: integer + Number of centroids. + + Returns + ------- + fcn: Function + Struct constructor. + + Examples + -------- + > var S = {{alias}}( 'float64', 3 ); + > var r = new S(); + > r.toString() + + + See Also + -------- + diff --git a/lib/node_modules/@stdlib/ml/base/kmeans/stats/struct-factory/docs/types/index.d.ts b/lib/node_modules/@stdlib/ml/base/kmeans/stats/struct-factory/docs/types/index.d.ts new file mode 100644 index 000000000000..785b96e92fb4 --- /dev/null +++ b/lib/node_modules/@stdlib/ml/base/kmeans/stats/struct-factory/docs/types/index.d.ts @@ -0,0 +1,141 @@ +/* +* @license Apache-2.0 +* +* Copyright (c) 2026 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +// TypeScript Version: 4.1 + +/** +* Interface describing cluster statistics. +*/ +interface Statistics { + /** + * Number of observations in each cluster. + */ + nObs?: Int32Array; + + /** + * Sum of squared distance from cluster centroids. + */ + sumSquaredDist?: T; + + /** + * Mean squared distance from cluster centroids. + */ + meanSquaredDist?: T; + + /** + * Standard deviation of squared distance from cluster centroids. + */ + stdevSquaredDist?: T; +} + +/** +* Interface describing a struct data structure. +*/ +declare class Struct { + /** + * Struct constructor. + * + * @param arg - buffer or data object + * @param byteOffset - byte offset + * @param byteLength - maximum byte length + * @returns struct + */ + constructor( arg?: ArrayBuffer | Statistics, byteOffset?: number, byteLength?: number ); + + /** + * Number of observations in each cluster. + */ + nObs: Int32Array; + + /** + * Sum of squared distance from cluster centroids. + */ + sumSquaredDist: T; + + /** + * Mean squared distance from cluster centroids. + */ + meanSquaredDist: T; + + /** + * Standard deviation of squared distance from cluster centroids. + */ + stdevSquaredDist: T; +} + +/** +* Interface defining a struct constructor which is both "newable" and "callable". +*/ +interface StructConstructor { + /** + * Struct constructor. + * + * @param arg - buffer or data object + * @param byteOffset - byte offset + * @param byteLength - maximum byte length + * @returns struct + */ + new( arg?: ArrayBuffer | Statistics, byteOffset?: number, byteLength?: number ): Struct; + + /** + * Struct constructor. + * + * @param arg - buffer or data object + * @param byteOffset - byte offset + * @param byteLength - maximum byte length + * @returns struct + */ + ( arg?: ArrayBuffer | Statistics, byteOffset?: number, byteLength?: number ): Struct; +} + +/** +* Returns a new struct constructor tailored to a specified floating-point data type. +* +* @param dtype - floating-point data type for storing floating-point statistics +* @param k - number of centroids +* @returns struct constructor +* +* @example +* var Struct = structFactory( 'float64', 5 ); +* // returns +* +* var s = new Struct(); +* // returns +*/ +declare function structFactory( dtype: 'float64', k: number ): StructConstructor; + +/** +* Returns a new struct constructor tailored to a specified floating-point data type. +* +* @param dtype - floating-point data type for storing floating-point statistics +* @param k - number of centroids +* @returns struct constructor +* +* @example +* var Struct = structFactory( 'float32', 5 ); +* // returns +* +* var s = new Struct(); +* // returns +*/ +declare function structFactory( dtype: 'float32', k: number ): StructConstructor; + + +// EXPORTS // + +export = structFactory; diff --git a/lib/node_modules/@stdlib/ml/base/kmeans/stats/struct-factory/docs/types/test.ts b/lib/node_modules/@stdlib/ml/base/kmeans/stats/struct-factory/docs/types/test.ts new file mode 100644 index 000000000000..7c9cb49e02e9 --- /dev/null +++ b/lib/node_modules/@stdlib/ml/base/kmeans/stats/struct-factory/docs/types/test.ts @@ -0,0 +1,159 @@ +/* +* @license Apache-2.0 +* +* Copyright (c) 2026 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +import structFactory = require( './index' ); + + +// TESTS // + +// The function returns a function... +{ + var k = 5; + + structFactory( 'float64', k ); // $ExpectType StructConstructor + structFactory( 'float32', k ); // $ExpectType StructConstructor +} + +// The compiler throws an error if not provided a supported data type... +{ + structFactory( 10 ); // $ExpectError + structFactory( true ); // $ExpectError + structFactory( false ); // $ExpectError + structFactory( null ); // $ExpectError + structFactory( undefined ); // $ExpectError + structFactory( [] ); // $ExpectError + structFactory( {} ); // $ExpectError + structFactory( ( x: number ): number => x ); // $ExpectError +} + +// The function returns a function which returns a struct object... +{ + var k = 5; + + const Struct = structFactory( 'float64', k ); + + // eslint-disable-next-line @typescript-eslint/no-unused-vars + const s1 = new Struct( new ArrayBuffer( 80 ) ); // $ExpectType Struct + + // eslint-disable-next-line @typescript-eslint/no-unused-vars + const s2 = new Struct( new ArrayBuffer( 80 ), 8 ); // $ExpectType Struct + + // eslint-disable-next-line @typescript-eslint/no-unused-vars + const s3 = new Struct( new ArrayBuffer( 80 ), 8, 16 ); // $ExpectType Struct +} + +// The returned constructor can be invoked without `new`... +{ + var k = 5; + + const Struct = structFactory( 'float64', k ); + + // eslint-disable-next-line @typescript-eslint/no-unused-vars + const s1 = Struct( new ArrayBuffer( 80 ) ); // $ExpectType Struct + + // eslint-disable-next-line @typescript-eslint/no-unused-vars + const s2 = Struct( new ArrayBuffer( 80 ), 8 ); // $ExpectType Struct + + // eslint-disable-next-line @typescript-eslint/no-unused-vars + const s3 = Struct( new ArrayBuffer( 80 ), 8, 16 ); // $ExpectType Struct +} + +// The results object has the expected properties (float64)... +{ + var k = 5; + + const Struct = structFactory( 'float64', k ); + const s = new Struct( {} ); + + // eslint-disable-next-line @typescript-eslint/no-unused-expressions + s.nObs; // $ExpectType Int32Array + + // eslint-disable-next-line @typescript-eslint/no-unused-expressions + s.sumSquaredDist; // $ExpectType Float64Array + + // eslint-disable-next-line @typescript-eslint/no-unused-expressions + s.meanSquaredDist; // $ExpectType Float64Array + + // eslint-disable-next-line @typescript-eslint/no-unused-expressions + s.stdevSquaredDist; // $ExpectType Float64Array +} + +// The results object has the expected properties (float32)... +{ + var k = 5; + + const Struct = structFactory( 'float32', k ); + const s = new Struct( {} ); + + // eslint-disable-next-line @typescript-eslint/no-unused-expressions + s.nObs; // $ExpectType Int32Array + + // eslint-disable-next-line @typescript-eslint/no-unused-expressions + s.sumSquaredDist; // $ExpectType Float32Array + + // eslint-disable-next-line @typescript-eslint/no-unused-expressions + s.meanSquaredDist; // $ExpectType Float32Array + + // eslint-disable-next-line @typescript-eslint/no-unused-expressions + s.stdevSquaredDist; // $ExpectType Float32Array +} + +// The compiler throws an error if the constructor is provided a first argument which is not an ArrayBuffer or object... +{ + var k = 5; + + const Struct = structFactory( 'float64', k ); + + new Struct( 'abc' ); // $ExpectError + new Struct( 123 ); // $ExpectError + new Struct( true ); // $ExpectError + new Struct( false ); // $ExpectError + new Struct( null ); // $ExpectError + new Struct( [] ); // $ExpectError + new Struct( ( x: number ): number => x ); // $ExpectError +} + +// The compiler throws an error if the constructor is provided a second argument which is not a number... +{ + var k = 5; + + const Struct = structFactory( 'float64', k ); + + new Struct( new ArrayBuffer( 80 ), 'abc' ); // $ExpectError + new Struct( new ArrayBuffer( 80 ), true ); // $ExpectError + new Struct( new ArrayBuffer( 80 ), false ); // $ExpectError + new Struct( new ArrayBuffer( 80 ), null ); // $ExpectError + new Struct( new ArrayBuffer( 80 ), [] ); // $ExpectError + new Struct( new ArrayBuffer( 80 ), {} ); // $ExpectError + new Struct( new ArrayBuffer( 80 ), ( x: number ): number => x ); // $ExpectError +} + +// The compiler throws an error if the constructor is provided a third argument which is not a number... +{ + var k = 5; + + const Struct = structFactory( 'float64', k ); + + new Struct( new ArrayBuffer( 80 ), 8, 'abc' ); // $ExpectError + new Struct( new ArrayBuffer( 80 ), 8, true ); // $ExpectError + new Struct( new ArrayBuffer( 80 ), 8, false ); // $ExpectError + new Struct( new ArrayBuffer( 80 ), 8, null ); // $ExpectError + new Struct( new ArrayBuffer( 80 ), 8, [] ); // $ExpectError + new Struct( new ArrayBuffer( 80 ), 8, {} ); // $ExpectError + new Struct( new ArrayBuffer( 80 ), 8, ( x: number ): number => x ); // $ExpectError +} diff --git a/lib/node_modules/@stdlib/ml/base/kmeans/stats/struct-factory/examples/index.js b/lib/node_modules/@stdlib/ml/base/kmeans/stats/struct-factory/examples/index.js new file mode 100644 index 000000000000..ca5bda3b52ab --- /dev/null +++ b/lib/node_modules/@stdlib/ml/base/kmeans/stats/struct-factory/examples/index.js @@ -0,0 +1,50 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2026 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +var Float64Array = require( '@stdlib/array/float64' ); +var Float32Array = require( '@stdlib/array/float32' ); +var Int32Array = require( '@stdlib/array/int32' ); +var structFactory = require( './../lib' ); + +var Struct = structFactory( 'float64', 2 ); +var results = new Struct({ + 'nObs': new Int32Array( [ 3, 2 ] ), + 'sumSquaredDist': new Float64Array( [ 9.998, 11.412 ] ), + 'meanSquaredDist': new Float64Array( [ 4.353, 2.897 ] ), + 'stdevSquaredDist': new Float64Array( [ 1.232, 8.913 ] ) +}); + +var str = results.toString({ + 'format': 'linear' +}); +console.log( str ); + +Struct = structFactory( 'float32', 2 ); +results = new Struct({ + 'nObs': new Int32Array( [ 3, 2 ] ), + 'sumSquaredDist': new Float32Array( [ 9.998, 11.412 ] ), + 'meanSquaredDist': new Float32Array( [ 4.353, 2.897 ] ), + 'stdevSquaredDist': new Float32Array( [ 1.232, 8.913 ] ) +}); + +str = results.toString({ + 'format': 'linear' +}); +console.log( str ); diff --git a/lib/node_modules/@stdlib/ml/base/kmeans/stats/struct-factory/lib/index.js b/lib/node_modules/@stdlib/ml/base/kmeans/stats/struct-factory/lib/index.js new file mode 100644 index 000000000000..cb6d2d98677e --- /dev/null +++ b/lib/node_modules/@stdlib/ml/base/kmeans/stats/struct-factory/lib/index.js @@ -0,0 +1,43 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2026 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +/** +* Create a new struct constructor tailored to a specified floating-point data type. +* +* @module @stdlib/ml/base/kmeans/stats/struct-factory +* +* @example +* var structFactory = require( '@stdlib/ml/base/kmeans/stats/struct-factory' ); +* +* var Struct = structFactory( 'float64', 5 ); +* // returns +* +* var s = new Struct(); +* // returns +*/ + +// MODULES // + +var main = require( './main.js' ); + + +// EXPORTS // + +module.exports = main; diff --git a/lib/node_modules/@stdlib/ml/base/kmeans/stats/struct-factory/lib/main.js b/lib/node_modules/@stdlib/ml/base/kmeans/stats/struct-factory/lib/main.js new file mode 100644 index 000000000000..41e936191eec --- /dev/null +++ b/lib/node_modules/@stdlib/ml/base/kmeans/stats/struct-factory/lib/main.js @@ -0,0 +1,79 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2026 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var struct = require( '@stdlib/dstructs/struct' ); + + +// MAIN // + +/** +* Returns a new struct constructor tailored to a specified floating-point data type. +* +* @param {string} dtype - floating-point data type +* @param {NonNegativeInteger} k - number of centroids +* @returns {Function} struct constructor +* +* @example +* var Struct = factory( 'float64', 5 ); +* // returns +* +* var s = new Struct(); +* // returns +*/ +function factory( dtype, k ) { + var schema = [ + { + 'name': 'nObs', + 'description': 'number of observations in each cluster', + 'type': 'int32', + 'length': k, + 'castingMode': 'safe' + }, + { + 'name': 'sumSquaredDist', + 'description': 'sum of squared distances from cluster centroids', + 'type': dtype, + 'length': k, + 'castingMode': 'mostly-safe' + }, + { + 'name': 'meanSquaredDist', + 'description': 'mean squared distance from cluster centroids', + 'type': dtype, + 'length': k, + 'castingMode': 'mostly-safe' + }, + { + 'name': 'stdevSquaredDist', + 'description': 'standard deviation of squared distances from cluster centroids', + 'type': dtype, + 'length': k, + 'castingMode': 'mostly-safe' + } + ]; + return struct( schema ); +} + + +// EXPORTS // + +module.exports = factory; diff --git a/lib/node_modules/@stdlib/ml/base/kmeans/stats/struct-factory/package.json b/lib/node_modules/@stdlib/ml/base/kmeans/stats/struct-factory/package.json new file mode 100644 index 000000000000..0bb630b7b4e9 --- /dev/null +++ b/lib/node_modules/@stdlib/ml/base/kmeans/stats/struct-factory/package.json @@ -0,0 +1,65 @@ +{ + "name": "@stdlib/ml/base/kmeans/stats/struct-factory", + "version": "0.0.0", + "description": "Create a new struct constructor tailored to a specified floating-point data type.", + "license": "Apache-2.0", + "author": { + "name": "The Stdlib Authors", + "url": "https://github.com/stdlib-js/stdlib/graphs/contributors" + }, + "contributors": [ + { + "name": "The Stdlib Authors", + "url": "https://github.com/stdlib-js/stdlib/graphs/contributors" + } + ], + "main": "./lib", + "directories": { + "benchmark": "./benchmark", + "doc": "./docs", + "example": "./examples", + "lib": "./lib", + "test": "./test" + }, + "types": "./docs/types", + "scripts": {}, + "homepage": "https://github.com/stdlib-js/stdlib", + "repository": { + "type": "git", + "url": "git://github.com/stdlib-js/stdlib.git" + }, + "bugs": { + "url": "https://github.com/stdlib-js/stdlib/issues" + }, + "dependencies": {}, + "devDependencies": {}, + "engines": { + "node": ">=0.10.0", + "npm": ">2.7.0" + }, + "os": [ + "aix", + "darwin", + "freebsd", + "linux", + "macos", + "openbsd", + "sunos", + "win32", + "windows" + ], + "keywords": [ + "stdlib", + "stats", + "ml", + "machine learning", + "kmeans", + "utilities", + "utility", + "utils", + "util", + "struct", + "statistics" + ], + "__stdlib__": {} +} diff --git a/lib/node_modules/@stdlib/ml/base/kmeans/stats/struct-factory/test/test.js b/lib/node_modules/@stdlib/ml/base/kmeans/stats/struct-factory/test/test.js new file mode 100644 index 000000000000..6306b0937740 --- /dev/null +++ b/lib/node_modules/@stdlib/ml/base/kmeans/stats/struct-factory/test/test.js @@ -0,0 +1,159 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2026 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var tape = require( 'tape' ); +var isSameFloat64Array = require( '@stdlib/assert/is-same-float64array' ); +var isSameFloat32Array = require( '@stdlib/assert/is-same-float32array' ); +var isEqualInt32Array = require( '@stdlib/assert/is-equal-int32array' ); +var Float64Array = require( '@stdlib/array/float64' ); +var Float32Array = require( '@stdlib/array/float32' ); +var Int32Array = require( '@stdlib/array/int32' ); +var structFactory = require( './../lib' ); + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof structFactory, 'function', 'main export is a function' ); + t.end(); +}); + +tape( 'the function throws an error if provided a first argument which is not a supported data type', function test( t ) { + var values; + var k; + var i; + + k = 5; + values = [ + '5', + 5, + NaN, + true, + false, + null, + void 0, + [], + {}, + function noop() {} + ]; + for ( i = 0; i < values.length; i++ ) { + t.throws( badValue( values[ i ], k ), TypeError, 'throws an error when provided ' + values[ i ] ); + } + t.end(); + + function badValue( value, k ) { + return function badValue() { + structFactory( value, k ); + }; + } +}); + +tape( 'the function throws an error if provided a second argument which is not a non negative integer', function test( t ) { + var values; + var dtype; + var i; + + dtype = 'float64'; + values = [ + '5', + -5, + NaN, + true, + false, + null, + void 0, + [], + {}, + function noop() {} + ]; + for ( i = 0; i < values.length; i++ ) { + t.throws( badValue( dtype, values[ i ] ), TypeError, 'throws an error when provided ' + values[ i ] ); + } + t.end(); + + function badValue( dtype, value ) { + return function badValue() { + structFactory( dtype, value ); + }; + } +}); + +tape( 'the function returns a constructor for creating a fixed-width results object (dtype=float64)', function test( t ) { + var expected; + var actual; + var Struct; + + Struct = structFactory( 'float64', 2 ); + t.strictEqual( typeof Struct, 'function', 'returns expected value' ); + + actual = new Struct({ + 'nObs': new Int32Array( [ 3, 2 ] ), + 'sumSquaredDist': new Float64Array( [ 9.998, 11.412 ] ), + 'meanSquaredDist': new Float64Array( [ 4.353, 2.897 ] ), + 'stdevSquaredDist': new Float64Array( [ 1.232, 8.913 ] ) + }); + + expected = { + 'nObs': new Int32Array( [ 3, 2 ] ), + 'sumSquaredDist': new Float64Array( [ 9.998, 11.412 ] ), + 'meanSquaredDist': new Float64Array( [ 4.353, 2.897 ] ), + 'stdevSquaredDist': new Float64Array( [ 1.232, 8.913 ] ) + }; + + t.strictEqual( actual instanceof Struct, true, 'returns expected value' ); + t.strictEqual( isEqualInt32Array( actual.nObs, expected.nObs ), true, 'returns expected value' ); + t.strictEqual( isSameFloat64Array( actual.sumSquaredDist, expected.sumSquaredDist ), true, 'returns expected value' ); + t.strictEqual( isSameFloat64Array( actual.meanSquaredDist, expected.meanSquaredDist ), true, 'returns expected value' ); + t.strictEqual( isSameFloat64Array( actual.stdevSquaredDist, expected.stdevSquaredDist ), true, 'returns expected value' ); + t.end(); +}); + +tape( 'the function returns a constructor for creating a fixed-width results object (dtype=float32)', function test( t ) { + var expected; + var actual; + var Struct; + + Struct = structFactory( 'float32', 2 ); + t.strictEqual( typeof Struct, 'function', 'returns expected value' ); + + actual = new Struct({ + 'nObs': new Int32Array( [ 3, 2 ] ), + 'sumSquaredDist': new Float32Array( [ 9.998, 11.412 ] ), + 'meanSquaredDist': new Float32Array( [ 4.353, 2.897 ] ), + 'stdevSquaredDist': new Float32Array( [ 1.232, 8.913 ] ) + }); + + expected = { + 'nObs': new Int32Array( [ 3, 2 ] ), + 'sumSquaredDist': new Float32Array( [ 9.998, 11.412 ] ), + 'meanSquaredDist': new Float32Array( [ 4.353, 2.897 ] ), + 'stdevSquaredDist': new Float32Array( [ 1.232, 8.913 ] ) + }; + + t.strictEqual( actual instanceof Struct, true, 'returns expected value' ); + t.strictEqual( isEqualInt32Array( actual.nObs, expected.nObs ), true, 'returns expected value' ); + t.strictEqual( isSameFloat32Array( actual.sumSquaredDist, expected.sumSquaredDist ), true, 'returns expected value' ); + t.strictEqual( isSameFloat32Array( actual.meanSquaredDist, expected.meanSquaredDist ), true, 'returns expected value' ); + t.strictEqual( isSameFloat32Array( actual.stdevSquaredDist, expected.stdevSquaredDist ), true, 'returns expected value' ); + t.end(); +});