@stdlib/stats-base-ndarray-dminabs 0.1.0 → 0.1.1

package/README.md

@@ -118,6 +118,153 @@ console.log( v );
 
 <!-- /.examples -->
 
+<!-- C interface documentation. -->
+
+* * *
+
+<section class="c">
+
+## C APIs
+
+<!-- Section to include introductory text. Make sure to keep an empty line after the intro `section` element and another before the `/section` close. -->
+
+<section class="intro">
+
+</section>
+
+<!-- /.intro -->
+
+<!-- C usage documentation. -->
+
+<section class="usage">
+
+### Usage
+
+```c
+#include "stdlib/stats/base/ndarray/dminabs.h"
+```
+
+#### stdlib_stats_dminabs( arrays )
+
+Computes the minimum absolute value of a one-dimensional double-precision floating-point ndarray.
+
+```c
+#include "stdlib/ndarray/ctor.h"
+#include "stdlib/ndarray/dtypes.h"
+#include "stdlib/ndarray/index_modes.h"
+#include "stdlib/ndarray/orders.h"
+#include "stdlib/ndarray/base/bytes_per_element.h"
+#include <stdint.h>
+
+// Create an ndarray:
+const double data[] = { 1.0, 2.0, 3.0, 4.0 };
+int64_t shape[] = { 4 };
+int64_t strides[] = { STDLIB_NDARRAY_FLOAT64_BYTES_PER_ELEMENT };
+int8_t submodes[] = { STDLIB_NDARRAY_INDEX_ERROR };
+
+struct ndarray *x = stdlib_ndarray_allocate( STDLIB_NDARRAY_FLOAT64, (uint8_t *)data, 1, shape, strides, 0, STDLIB_NDARRAY_ROW_MAJOR, STDLIB_NDARRAY_INDEX_ERROR, 1, submodes );
+
+// Compute the minimum absolute value:
+const struct ndarray *arrays[] = { x };
+double v = stdlib_stats_dminabs( arrays );
+// returns 1.0
+
+// Free allocated memory:
+stdlib_ndarray_free( x );
+```
+
+The function accepts the following arguments:
+
+-   **arrays**: `[in] struct ndarray**` list containing a one-dimensional input ndarray.
+
+```c
+double stdlib_stats_dminabs( const struct ndarray *arrays[] );
+```
+
+</section>
+
+<!-- /.usage -->
+
+<!-- C API usage notes. Make sure to keep an empty line after the `section` element and another before the `/section` close. -->
+
+<section class="notes">
+
+</section>
+
+<!-- /.notes -->
+
+<!-- C API usage examples. -->
+
+<section class="examples">
+
+### Examples
+
+```c
+#include "stdlib/stats/base/ndarray/dminabs.h"
+#include "stdlib/ndarray/ctor.h"
+#include "stdlib/ndarray/dtypes.h"
+#include "stdlib/ndarray/index_modes.h"
+#include "stdlib/ndarray/orders.h"
+#include "stdlib/ndarray/base/bytes_per_element.h"
+#include <stdint.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+int main( void ) {
+   // Create a data buffer:
+   const double data[] = { 1.0, -2.0, 3.0, -4.0, 5.0, -6.0, 7.0, -8.0 };
+
+   // Specify the number of array dimensions:
+   const int64_t ndims = 1;
+
+   // Specify the array shape:
+   int64_t shape[] = { 4 };
+
+   // Specify the array strides:
+   int64_t strides[] = { 2*STDLIB_NDARRAY_FLOAT64_BYTES_PER_ELEMENT };
+
+   // Specify the byte offset:
+   const int64_t offset = 0;
+
+   // Specify the array order:
+   const enum STDLIB_NDARRAY_ORDER order = STDLIB_NDARRAY_ROW_MAJOR;
+
+   // Specify the index mode:
+   const enum STDLIB_NDARRAY_INDEX_MODE imode = STDLIB_NDARRAY_INDEX_ERROR;
+
+   // Specify the subscript index modes:
+   int8_t submodes[] = { STDLIB_NDARRAY_INDEX_ERROR };
+   const int64_t nsubmodes = 1;
+
+   // Create an ndarray:
+   struct ndarray *x = stdlib_ndarray_allocate( STDLIB_NDARRAY_FLOAT64, (uint8_t *)data, ndims, shape, strides, offset, order, imode, nsubmodes, submodes );
+   if ( x == NULL ) {
+      fprintf( stderr, "Error allocating memory.\n" );
+      exit( 1 );
+   }
+
+   // Define a list of ndarrays:
+   const struct ndarray *arrays[] = { x };
+
+   // Compute the minimum absolute value:
+   double v = stdlib_stats_dminabs( arrays );
+
+   // Print the result:
+   printf( "min: %lf\n", v );
+
+   // Free allocated memory:
+   stdlib_ndarray_free( x );
+}
+```
+
+</section>
+
+<!-- /.examples -->
+
+</section>
+
+<!-- /.c -->
+
 <!-- Section for related `stdlib` packages. Do not manually edit this section, as it is automatically populated. -->
 
 <section class="related">
@@ -165,8 +312,8 @@ Copyright &copy; 2016-2026. The Stdlib [Authors][stdlib-authors].
 [npm-image]: http://img.shields.io/npm/v/@stdlib/stats-base-ndarray-dminabs.svg
 [npm-url]: https://npmjs.org/package/@stdlib/stats-base-ndarray-dminabs
 
-[test-image]: https://github.com/stdlib-js/stats-base-ndarray-dminabs/actions/workflows/test.yml/badge.svg?branch=v0.1.0
-[test-url]: https://github.com/stdlib-js/stats-base-ndarray-dminabs/actions/workflows/test.yml?query=branch:v0.1.0
+[test-image]: https://github.com/stdlib-js/stats-base-ndarray-dminabs/actions/workflows/test.yml/badge.svg?branch=v0.1.1
+[test-url]: https://github.com/stdlib-js/stats-base-ndarray-dminabs/actions/workflows/test.yml?query=branch:v0.1.1
 
 [coverage-image]: https://img.shields.io/codecov/c/github/stdlib-js/stats-base-ndarray-dminabs/main.svg
 [coverage-url]: https://codecov.io/github/stdlib-js/stats-base-ndarray-dminabs?branch=main

package/dist/index.js

@@ -1,5 +1,5 @@
-"use strict";var a=function(e,r){return function(){return r||e((r={exports:{}}).exports,r),r.exports}};var t=a(function(c,i){
-var u=require('@stdlib/ndarray-base-numel-dimension/dist'),s=require('@stdlib/ndarray-base-stride/dist'),n=require('@stdlib/ndarray-base-offset/dist'),v=require('@stdlib/ndarray-base-data-buffer/dist'),q=require('@stdlib/stats-strided-dminabs/dist').ndarray;function d(e){var r=e[0];return q(u(r,0),v(r),s(r,0),n(r))}i.exports=d
-});var m=t();module.exports=m;
+"use strict";var n=function(e,r){return function(){return r||e((r={exports:{}}).exports,r),r.exports}};var t=n(function(x,a){
+var s=require('@stdlib/ndarray-base-numel-dimension/dist'),v=require('@stdlib/ndarray-base-stride/dist'),q=require('@stdlib/ndarray-base-offset/dist'),d=require('@stdlib/ndarray-base-data-buffer/dist'),m=require('@stdlib/stats-strided-dminabs/dist').ndarray;function o(e){var r=e[0];return m(s(r,0),d(r),v(r,0),q(r))}a.exports=o
+});var f=require("path").join,c=require('@stdlib/utils-try-require/dist'),g=require('@stdlib/assert-is-error/dist'),j=t(),i,u=c(f(__dirname,"./native.js"));g(u)?i=j:i=u;module.exports=i;
 /** @license Apache-2.0 */
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../lib/main.js", "../lib/index.js"],
-  "sourcesContent": ["/**\n* @license Apache-2.0\n*\n* Copyright (c) 2025 The Stdlib Authors.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*    http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n'use strict';\n\n// MODULES //\n\nvar numelDimension = require( '@stdlib/ndarray-base-numel-dimension' );\nvar getStride = require( '@stdlib/ndarray-base-stride' );\nvar getOffset = require( '@stdlib/ndarray-base-offset' );\nvar getData = require( '@stdlib/ndarray-base-data-buffer' );\nvar strided = require( '@stdlib/stats-strided-dminabs' ).ndarray;\n\n\n// MAIN //\n\n/**\n* Computes the minimum absolute value of a one-dimensional double-precision floating-point ndarray.\n*\n* @param {ArrayLikeObject<Object>} arrays - array-like object containing an input ndarray\n* @returns {number} minimum absolute value\n*\n* @example\n* var Float64Array = require( '@stdlib/array-float64' );\n* var ndarray = require( '@stdlib/ndarray-base-ctor' );\n*\n* var xbuf = new Float64Array( [ -1.0, 3.0, -4.0, 2.0 ] );\n* var x = new ndarray( 'float64', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );\n*\n* var v = dminabs( [ x ] );\n* // returns 1.0\n*/\nfunction dminabs( arrays ) {\n\tvar x = arrays[ 0 ];\n\treturn strided( numelDimension( x, 0 ), getData( x ), getStride( x, 0 ), getOffset( x ) ); // eslint-disable-line max-len\n}\n\n\n// EXPORTS //\n\nmodule.exports = dminabs;\n", "/**\n* @license Apache-2.0\n*\n* Copyright (c) 2025 The Stdlib Authors.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*    http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n'use strict';\n\n/**\n* Compute the minimum absolute value of a one-dimensional double-precision floating-point ndarray.\n*\n* @module @stdlib/stats-base-ndarray-dminabs\n*\n* @example\n* var Float64Array = require( '@stdlib/array-float64' );\n* var ndarray = require( '@stdlib/ndarray-base-ctor' );\n* var dminabs = require( '@stdlib/stats-base-ndarray-dminabs' );\n*\n* var xbuf = new Float64Array( [ -1.0, 3.0, -4.0, 2.0 ] );\n* var x = new ndarray( 'float64', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );\n*\n* var v = dminabs( [ x ] );\n* // returns 1.0\n*/\n\n// MODULES //\n\nvar main = require( './main.js' );\n\n\n// EXPORTS //\n\nmodule.exports = main;\n"],
-  "mappings": "uGAAA,IAAAA,EAAAC,EAAA,SAAAC,EAAAC,EAAA,cAsBA,IAAIC,EAAiB,QAAS,sCAAuC,EACjEC,EAAY,QAAS,6BAA8B,EACnDC,EAAY,QAAS,6BAA8B,EACnDC,EAAU,QAAS,kCAAmC,EACtDC,EAAU,QAAS,+BAAgC,EAAE,QAqBzD,SAASC,EAASC,EAAS,CAC1B,IAAIC,EAAID,EAAQ,CAAE,EAClB,OAAOF,EAASJ,EAAgBO,EAAG,CAAE,EAAGJ,EAASI,CAAE,EAAGN,EAAWM,EAAG,CAAE,EAAGL,EAAWK,CAAE,CAAE,CACzF,CAKAR,EAAO,QAAUM,IChBjB,IAAIG,EAAO,IAKX,OAAO,QAAUA",
-  "names": ["require_main", "__commonJSMin", "exports", "module", "numelDimension", "getStride", "getOffset", "getData", "strided", "dminabs", "arrays", "x", "main"]
+  "sourcesContent": ["/**\n* @license Apache-2.0\n*\n* Copyright (c) 2025 The Stdlib Authors.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*    http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n'use strict';\n\n// MODULES //\n\nvar numelDimension = require( '@stdlib/ndarray-base-numel-dimension' );\nvar getStride = require( '@stdlib/ndarray-base-stride' );\nvar getOffset = require( '@stdlib/ndarray-base-offset' );\nvar getData = require( '@stdlib/ndarray-base-data-buffer' );\nvar strided = require( '@stdlib/stats-strided-dminabs' ).ndarray;\n\n\n// MAIN //\n\n/**\n* Computes the minimum absolute value of a one-dimensional double-precision floating-point ndarray.\n*\n* @param {ArrayLikeObject<Object>} arrays - array-like object containing an input ndarray\n* @returns {number} minimum absolute value\n*\n* @example\n* var Float64Array = require( '@stdlib/array-float64' );\n* var ndarray = require( '@stdlib/ndarray-base-ctor' );\n*\n* var xbuf = new Float64Array( [ -1.0, 3.0, -4.0, 2.0 ] );\n* var x = new ndarray( 'float64', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );\n*\n* var v = dminabs( [ x ] );\n* // returns 1.0\n*/\nfunction dminabs( arrays ) {\n\tvar x = arrays[ 0 ];\n\treturn strided( numelDimension( x, 0 ), getData( x ), getStride( x, 0 ), getOffset( x ) ); // eslint-disable-line max-len\n}\n\n\n// EXPORTS //\n\nmodule.exports = dminabs;\n", "/**\n* @license Apache-2.0\n*\n* Copyright (c) 2025 The Stdlib Authors.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*    http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n'use strict';\n\n/**\n* Compute the minimum absolute value of a one-dimensional double-precision floating-point ndarray.\n*\n* @module @stdlib/stats-base-ndarray-dminabs\n*\n* @example\n* var Float64Array = require( '@stdlib/array-float64' );\n* var ndarray = require( '@stdlib/ndarray-base-ctor' );\n* var dminabs = require( '@stdlib/stats-base-ndarray-dminabs' );\n*\n* var xbuf = new Float64Array( [ -1.0, 3.0, -4.0, 2.0 ] );\n* var x = new ndarray( 'float64', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );\n*\n* var v = dminabs( [ x ] );\n* // returns 1.0\n*/\n\n// MODULES //\n\nvar join = require( 'path' ).join;\nvar tryRequire = require( '@stdlib/utils-try-require' );\nvar isError = require( '@stdlib/assert-is-error' );\nvar main = require( './main.js' );\n\n\n// MAIN //\n\nvar dminabs;\nvar tmp = tryRequire( join( __dirname, './native.js' ) );\nif ( isError( tmp ) ) {\n\tdminabs = main;\n} else {\n\tdminabs = tmp;\n}\n\n\n// EXPORTS //\n\nmodule.exports = dminabs;\n"],
+  "mappings": "uGAAA,IAAAA,EAAAC,EAAA,SAAAC,EAAAC,EAAA,cAsBA,IAAIC,EAAiB,QAAS,sCAAuC,EACjEC,EAAY,QAAS,6BAA8B,EACnDC,EAAY,QAAS,6BAA8B,EACnDC,EAAU,QAAS,kCAAmC,EACtDC,EAAU,QAAS,+BAAgC,EAAE,QAqBzD,SAASC,EAASC,EAAS,CAC1B,IAAIC,EAAID,EAAQ,CAAE,EAClB,OAAOF,EAASJ,EAAgBO,EAAG,CAAE,EAAGJ,EAASI,CAAE,EAAGN,EAAWM,EAAG,CAAE,EAAGL,EAAWK,CAAE,CAAE,CACzF,CAKAR,EAAO,QAAUM,IChBjB,IAAIG,EAAO,QAAS,MAAO,EAAE,KACzBC,EAAa,QAAS,2BAA4B,EAClDC,EAAU,QAAS,yBAA0B,EAC7CC,EAAO,IAKPC,EACAC,EAAMJ,EAAYD,EAAM,UAAW,aAAc,CAAE,EAClDE,EAASG,CAAI,EACjBD,EAAUD,EAEVC,EAAUC,EAMX,OAAO,QAAUD",
+  "names": ["require_main", "__commonJSMin", "exports", "module", "numelDimension", "getStride", "getOffset", "getData", "strided", "dminabs", "arrays", "x", "join", "tryRequire", "isError", "main", "dminabs", "tmp"]
 }

package/include/stdlib/stats/base/ndarray/dminabs.h

@@ -0,0 +1,40 @@
+/**
+* @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.
+*/
+
+#ifndef STDLIB_STATS_BASE_NDARRAY_DMINABS_H
+#define STDLIB_STATS_BASE_NDARRAY_DMINABS_H
+
+#include "stdlib/ndarray/ctor.h"
+
+/*
+* If C++, prevent name mangling so that the compiler emits a binary file having undecorated names, thus mirroring the behavior of a C compiler.
+*/
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+* Computes the minimum value of a one-dimensional double-precision floating-point ndarray.
+*/
+double stdlib_stats_dminabs( const struct ndarray *arrays[] );
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // !STDLIB_STATS_BASE_NDARRAY_DMINABS_H

package/lib/index.js

@@ -37,9 +37,23 @@
 
 // MODULES //
 
+var join = require( 'path' ).join;
+var tryRequire = require( '@stdlib/utils-try-require' );
+var isError = require( '@stdlib/assert-is-error' );
 var main = require( './main.js' );
 
 
+// MAIN //
+
+var dminabs;
+var tmp = tryRequire( join( __dirname, './native.js' ) );
+if ( isError( tmp ) ) {
+	dminabs = main;
+} else {
+	dminabs = tmp;
+}
+
+
 // EXPORTS //
 
-module.exports = main;
+module.exports = dminabs;

package/lib/native.js

@@ -0,0 +1,55 @@
+/**
+* @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 serialize = require( '@stdlib/ndarray-base-serialize-meta-data' );
+var getData = require( '@stdlib/ndarray-base-data-buffer' );
+var addon = require( './../src/addon.node' );
+
+
+// MAIN //
+
+/**
+* Computes the minimum absolute value of a one-dimensional double-precision floating-point ndarray.
+*
+* @private
+* @param {ArrayLikeObject<Object>} arrays - array-like object containing an input ndarray
+* @returns {number} minimum absolute value
+*
+* @example
+* var Float64Array = require( '@stdlib/array-float64' );
+* var ndarray = require( '@stdlib/ndarray-base-ctor' );
+*
+* var xbuf = new Float64Array( [ -1.0, 3.0, -4.0, 2.0 ] );
+* var x = new ndarray( 'float64', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );
+*
+* var v = dminabs( [ x ] );
+* // returns 1.0
+*/
+function dminabs( arrays ) {
+	var x = arrays[ 0 ];
+	return addon( getData( x ), serialize( x ) );
+}
+
+
+// EXPORTS //
+
+module.exports = dminabs;

package/manifest.json

@@ -0,0 +1,110 @@
+{
+  "options": {
+    "task": "build",
+    "wasm": false
+  },
+  "fields": [
+    {
+      "field": "src",
+      "resolve": true,
+      "relative": true
+    },
+    {
+      "field": "include",
+      "resolve": true,
+      "relative": true
+    },
+    {
+      "field": "libraries",
+      "resolve": false,
+      "relative": false
+    },
+    {
+      "field": "libpath",
+      "resolve": true,
+      "relative": false
+    }
+  ],
+  "confs": [
+    {
+      "task": "build",
+      "wasm": false,
+      "src": [
+        "./src/main.c"
+      ],
+      "include": [
+        "./include"
+      ],
+      "libraries": [],
+      "libpath": [],
+      "dependencies": [
+        "@stdlib/blas-base-shared",
+        "@stdlib/stats-strided-dminabs",
+        "@stdlib/ndarray-ctor",
+        "@stdlib/ndarray-base-napi-addon-arguments",
+        "@stdlib/napi-export",
+        "@stdlib/napi-argv",
+        "@stdlib/napi-create-double"
+      ]
+    },
+    {
+      "task": "benchmark",
+      "wasm": false,
+      "src": [
+        "./src/main.c"
+      ],
+      "include": [
+        "./include"
+      ],
+      "libraries": [],
+      "libpath": [],
+      "dependencies": [
+        "@stdlib/blas-base-shared",
+        "@stdlib/stats-strided-dminabs",
+        "@stdlib/ndarray-ctor",
+        "@stdlib/ndarray-dtypes",
+        "@stdlib/ndarray-index-modes",
+        "@stdlib/ndarray-orders",
+        "@stdlib/ndarray-base-bytes-per-element"
+      ]
+    },
+    {
+      "task": "examples",
+      "wasm": false,
+      "src": [
+        "./src/main.c"
+      ],
+      "include": [
+        "./include"
+      ],
+      "libraries": [],
+      "libpath": [],
+      "dependencies": [
+        "@stdlib/blas-base-shared",
+        "@stdlib/stats-strided-dminabs",
+        "@stdlib/ndarray-ctor",
+        "@stdlib/ndarray-dtypes",
+        "@stdlib/ndarray-index-modes",
+        "@stdlib/ndarray-orders",
+        "@stdlib/ndarray-base-bytes-per-element"
+      ]
+    },
+    {
+      "task": "",
+      "wasm": true,
+      "src": [
+        "./src/main.c"
+      ],
+      "include": [
+        "./include"
+      ],
+      "libraries": [],
+      "libpath": [],
+      "dependencies": [
+        "@stdlib/blas-base-shared",
+        "@stdlib/stats-strided-dminabs",
+        "@stdlib/ndarray-ctor"
+      ]
+    }
+  ]
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stdlib/stats-base-ndarray-dminabs",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Compute the minimum absolute value of a one-dimensional double-precision floating-point ndarray.",
   "license": "Apache-2.0",
   "author": {
@@ -14,9 +14,13 @@
     }
   ],
   "main": "./lib",
+  "browser": "./lib/main.js",
+  "gypfile": false,
   "directories": {
     "doc": "./docs",
+    "include": "./include",
     "lib": "./lib",
+    "src": "./src",
     "dist": "./dist"
   },
   "types": "./docs/types",
@@ -30,11 +34,20 @@
     "url": "https://github.com/stdlib-js/stdlib/issues"
   },
   "dependencies": {
-    "@stdlib/ndarray-base-data-buffer": "^0.2.2",
+    "@stdlib/assert-is-error": "^0.2.3",
+    "@stdlib/blas-base-shared": "^0.2.1",
+    "@stdlib/napi-argv": "^0.2.3",
+    "@stdlib/napi-create-double": "^0.0.3",
+    "@stdlib/napi-export": "^0.3.1",
+    "@stdlib/ndarray-base-data-buffer": "^0.2.3",
+    "@stdlib/ndarray-base-napi-addon-arguments": "^0.2.3",
     "@stdlib/ndarray-base-numel-dimension": "^0.3.2",
-    "@stdlib/ndarray-base-offset": "^0.2.2",
+    "@stdlib/ndarray-base-offset": "^0.2.3",
     "@stdlib/ndarray-base-stride": "^0.2.2",
-    "@stdlib/stats-strided-dminabs": "^0.1.0"
+    "@stdlib/ndarray-ctor": "^0.3.0",
+    "@stdlib/stats-strided-dminabs": "^0.1.1",
+    "@stdlib/utils-library-manifest": "^0.2.4",
+    "@stdlib/utils-try-require": "^0.2.3"
   },
   "devDependencies": {},
   "engines": {

package/src/addon.c

@@ -0,0 +1,58 @@
+/**
+* @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.
+*/
+
+#include "stdlib/stats/base/ndarray/dminabs.h"
+#include "stdlib/ndarray/ctor.h"
+#include "stdlib/ndarray/base/napi/addon_arguments.h"
+#include "stdlib/napi/export.h"
+#include "stdlib/napi/argv.h"
+#include "stdlib/napi/create_double.h"
+#include <node_api.h>
+#include <assert.h>
+
+/**
+* Receives JavaScript callback invocation data.
+*
+* @param env    environment under which the function is invoked
+* @param info   callback data
+* @return       Node-API value
+*/
+static napi_value addon( napi_env env, napi_callback_info info ) {
+	STDLIB_NAPI_ARGV( env, info, argv, argc, 2 );
+
+	// Process provided arguments:
+	struct ndarray *arrays[ 1 ];
+	napi_value err;
+	napi_status status = stdlib_ndarray_napi_addon_arguments( env, argv, 2, 1, arrays, &err );
+	assert( status == napi_ok );
+	if ( err != NULL ) {
+		status = napi_throw( env, err );
+		assert( status == napi_ok );
+		return NULL;
+	}
+	// Perform computation:
+	STDLIB_NAPI_CREATE_DOUBLE( env, stdlib_stats_dminabs( arrays ), v );
+
+	// Free allocated memory:
+	stdlib_ndarray_free( arrays[ 0 ] );
+	arrays[ 0 ] = NULL;
+
+	return v;
+}
+
+STDLIB_NAPI_MODULE_EXPORT_FCN( addon )

package/src/main.c

@@ -0,0 +1,33 @@
+/**
+* @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.
+*/
+
+#include "stdlib/stats/base/ndarray/dminabs.h"
+#include "stdlib/stats/strided/dminabs.h"
+#include "stdlib/ndarray/ctor.h"
+#include "stdlib/blas/base/shared.h"
+
+/**
+* Computes the minimum absolute value of a one-dimensional double-precision floating-point ndarray.
+*
+* @param arrays    list containing an input ndarray
+* @return          minimum value
+*/
+double stdlib_stats_dminabs( const struct ndarray *arrays[] ) {
+	const struct ndarray *x = arrays[ 0 ];
+	return API_SUFFIX(stdlib_strided_dminabs_ndarray)( stdlib_ndarray_dimension( x, 0 ), (const double *)stdlib_ndarray_data( x ), stdlib_ndarray_stride_elements( x, 0 ), stdlib_ndarray_offset_elements( x ) );
+}