@stdlib/blas-ext-base-dsort 0.1.0

package/docs/types/index.d.ts

@@ -0,0 +1,95 @@
+/*
+* @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 `dsort`.
+*/
+interface Routine {
+	/**
+	* Sorts a double-precision floating-point strided array.
+	*
+	* @param N - number of indexed elements
+	* @param order - sort order
+	* @param x - input array
+	* @param strideX - stride length
+	* @returns input array
+	*
+	* @example
+	* var Float64Array = require( '@stdlib/array-float64' );
+	*
+	* var x = new Float64Array( [ 1.0, -2.0, 3.0, -4.0 ] );
+	*
+	* dsort( x.length, 1.0, x, 1 );
+	* // x => <Float64Array>[ -4.0, -2.0, 1.0, 3.0 ]
+	*/
+	( N: number, order: number, x: Float64Array, strideX: number ): Float64Array;
+
+	/**
+	* Sorts a double-precision floating-point strided array using alternative indexing semantics.
+	*
+	* @param N - number of indexed elements
+	* @param order - sort order
+	* @param x - input array
+	* @param strideX - stride length
+	* @param offsetX - starting index
+	* @returns input array
+	*
+	* @example
+	* var Float64Array = require( '@stdlib/array-float64' );
+	*
+	* var x = new Float64Array( [ 1.0, -2.0, 3.0, -4.0 ] );
+	*
+	* dsort.ndarray( x.length, 1.0, x, 1, 0 );
+	* // x => <Float64Array>[ -4.0, -2.0, 1.0, 3.0 ]
+	*/
+	ndarray( N: number, order: number, x: Float64Array, strideX: number, offsetX: number ): Float64Array;
+}
+
+/**
+* Sorts a double-precision floating-point strided array.
+*
+* @param N - number of indexed elements
+* @param order - sort order
+* @param x - input array
+* @param strideX - stride length
+* @returns input array
+*
+* @example
+* var Float64Array = require( '@stdlib/array-float64' );
+*
+* var x = new Float64Array( [ 1.0, -2.0, 3.0, -4.0 ] );
+*
+* dsort( x.length, 1.0, x, 1 );
+* // x => <Float64Array>[ -4.0, -2.0, 1.0, 3.0 ]
+*
+* @example
+* var Float64Array = require( '@stdlib/array-float64' );
+*
+* var x = new Float64Array( [ 1.0, -2.0, 3.0, -4.0 ] );
+*
+* dsort.ndarray( x.length, 1.0, x, 1, 0 );
+* // x => <Float64Array>[ -4.0, -2.0, 1.0, 3.0 ]
+*/
+declare var dsort: Routine;
+
+
+// EXPORTS //
+
+export = dsort;

package/include/stdlib/blas/ext/base/dsort.h

@@ -0,0 +1,45 @@
+/**
+* @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_BLAS_EXT_BASE_DSORT_H
+#define STDLIB_BLAS_EXT_BASE_DSORT_H
+
+#include "stdlib/blas/base/shared.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
+
+/**
+* Sorts a double-precision floating-point strided array.
+*/
+void API_SUFFIX(stdlib_strided_dsort)( const CBLAS_INT N, const double order, double *X, const CBLAS_INT strideX );
+
+/**
+* Sorts a double-precision floating-point strided array using alternative indexing semantics.
+*/
+void API_SUFFIX(stdlib_strided_dsort_ndarray)( const CBLAS_INT N, const double order, double *X, const CBLAS_INT strideX, const CBLAS_INT offsetX );
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // !STDLIB_BLAS_EXT_BASE_DSORT_H

package/lib/dsort.js

@@ -0,0 +1,53 @@
+/**
+* @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 stride2offset = require( '@stdlib/strided-base-stride2offset' );
+var ndarray = require( './ndarray.js' );
+
+
+// MAIN //
+
+/**
+* Sorts a double-precision floating-point strided array.
+*
+* @param {PositiveInteger} N - number of indexed elements
+* @param {number} order - sort order
+* @param {Float64Array} x - input array
+* @param {integer} strideX - stride length
+* @returns {Float64Array} input array
+*
+* @example
+* var Float64Array = require( '@stdlib/array-float64' );
+*
+* var x = new Float64Array( [ 1.0, -2.0, 3.0, -4.0 ] );
+*
+* dsort( x.length, 1.0, x, 1 );
+* // x => <Float64Array>[ -4.0, -2.0, 1.0, 3.0 ]
+*/
+function dsort( N, order, x, strideX ) {
+	return ndarray( N, order, x, strideX, stride2offset( N, strideX ) );
+}
+
+
+// EXPORTS //
+
+module.exports = dsort;

package/lib/dsort.native.js

@@ -0,0 +1,53 @@
+/**
+* @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 addon = require( './../src/addon.node' );
+
+
+// MAIN //
+
+/**
+* Sorts a double-precision floating-point strided array.
+*
+* @param {PositiveInteger} N - number of indexed elements
+* @param {number} order - sort order
+* @param {Float64Array} x - input array
+* @param {integer} strideX - stride length
+* @returns {Float64Array} input array
+*
+* @example
+* var Float64Array = require( '@stdlib/array-float64' );
+*
+* var x = new Float64Array( [ 1.0, -2.0, 3.0, -4.0 ] );
+*
+* dsort( x.length, 1.0, x, 1 );
+* // x => <Float64Array>[ -4.0, -2.0, 1.0, 3.0 ]
+*/
+function dsort( N, order, x, strideX ) {
+	addon( N, order, x, strideX );
+	return x;
+}
+
+
+// EXPORTS //
+
+module.exports = dsort;

package/lib/index.js

@@ -0,0 +1,68 @@
+/**
+* @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';
+
+/**
+* Sort a double-precision floating-point strided array.
+*
+* @module @stdlib/blas-ext-base-dsort
+*
+* @example
+* var Float64Array = require( '@stdlib/array-float64' );
+* var dsort = require( '@stdlib/blas-ext-base-dsort' );
+*
+* var x = new Float64Array( [ 1.0, -2.0, 3.0, -4.0 ] );
+*
+* dsort( x.length, 1.0, x, 1 );
+* // x => <Float64Array>[ -4.0, -2.0, 1.0, 3.0 ]
+*
+* @example
+* var Float64Array = require( '@stdlib/array-float64' );
+* var dsort = require( '@stdlib/blas-ext-base-dsort' );
+*
+* var x = new Float64Array( [ 1.0, -2.0, 3.0, -4.0 ] );
+*
+* dsort.ndarray( x.length, 1.0, x, 1, 0 );
+* // x => <Float64Array>[ -4.0, -2.0, 1.0, 3.0 ]
+*/
+
+// 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 dsort;
+var tmp = tryRequire( join( __dirname, './native.js' ) );
+if ( isError( tmp ) ) {
+	dsort = main;
+} else {
+	dsort = tmp;
+}
+
+
+// EXPORTS //
+
+module.exports = dsort;
+
+// exports: { "ndarray": "dsort.ndarray" }

package/lib/main.js

@@ -0,0 +1,35 @@
+/**
+* @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 setReadOnly = require( '@stdlib/utils-define-nonenumerable-read-only-property' );
+var dsort = require( './dsort.js' );
+var ndarray = require( './ndarray.js' );
+
+
+// MAIN //
+
+setReadOnly( dsort, 'ndarray', ndarray );
+
+
+// EXPORTS //
+
+module.exports = dsort;

package/lib/native.js

@@ -0,0 +1,35 @@
+/**
+* @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 setReadOnly = require( '@stdlib/utils-define-nonenumerable-read-only-property' );
+var dsort = require( './dsort.native.js' );
+var ndarray = require( './ndarray.native.js' );
+
+
+// MAIN //
+
+setReadOnly( dsort, 'ndarray', ndarray );
+
+
+// EXPORTS //
+
+module.exports = dsort;

package/lib/ndarray.js

@@ -0,0 +1,53 @@
+/**
+* @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 dsorthp = require( '@stdlib/blas-ext-base-dsorthp' ).ndarray;
+
+
+// MAIN //
+
+/**
+* Sorts a double-precision floating-point strided array.
+*
+* @param {PositiveInteger} N - number of indexed elements
+* @param {number} order - sort order
+* @param {Float64Array} x - input array
+* @param {integer} strideX - stride length
+* @param {NonNegativeInteger} offsetX - starting index
+* @returns {Float64Array} input array
+*
+* @example
+* var Float64Array = require( '@stdlib/array-float64' );
+*
+* var x = new Float64Array( [ 1.0, -2.0, 3.0, -4.0 ] );
+*
+* dsort( x.length, 1.0, x, 1, 0 );
+* // x => <Float64Array>[ -4.0, -2.0, 1.0, 3.0 ]
+*/
+function dsort( N, order, x, strideX, offsetX ) {
+	return dsorthp( N, order, x, strideX, offsetX );
+}
+
+
+// EXPORTS //
+
+module.exports = dsort;

package/lib/ndarray.native.js

@@ -0,0 +1,53 @@
+/**
+* @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 addon = require( './../src/addon.node' );
+
+
+// MAIN //
+
+/**
+* Sorts a double-precision floating-point strided array.
+*
+* @param {PositiveInteger} N - number of indexed elements
+* @param {number} order - sort order
+* @param {Float64Array} x - input array
+* @param {integer} strideX - stride length
+* @param {NonNegativeInteger} offsetX - starting index
+* @returns {Float64Array} input array
+*
+* @example
+* var Float64Array = require( '@stdlib/array-float64' );
+*
+* var x = new Float64Array( [ 1.0, -2.0, 3.0, -4.0 ] );
+*
+* dsort( x.length, 1.0, x, 1, 0 );
+*/
+function dsort( N, order, x, strideX, offsetX ) {
+	addon.ndarray( N, order, x, strideX, offsetX );
+	return x;
+}
+
+
+// EXPORTS //
+
+module.exports = dsort;

package/manifest.json

@@ -0,0 +1,82 @@
+{
+  "options": {
+    "task": "build"
+  },
+  "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",
+      "src": [
+        "./src/main.c"
+      ],
+      "include": [
+        "./include"
+      ],
+      "libraries": [],
+      "libpath": [],
+      "dependencies": [
+        "@stdlib/napi-export",
+        "@stdlib/napi-argv",
+        "@stdlib/napi-argv-int64",
+        "@stdlib/napi-argv-double",
+        "@stdlib/napi-argv-strided-float64array",
+        "@stdlib/strided-base-stride2offset",
+        "@stdlib/blas-base-shared",
+        "@stdlib/blas-ext-base-dsorthp"
+      ]
+    },
+    {
+      "task": "benchmark",
+      "src": [
+        "./src/main.c"
+      ],
+      "include": [
+        "./include"
+      ],
+      "libraries": [],
+      "libpath": [],
+      "dependencies": [
+        "@stdlib/strided-base-stride2offset",
+        "@stdlib/blas-base-shared",
+        "@stdlib/blas-ext-base-dsorthp"
+      ]
+    },
+    {
+      "task": "examples",
+      "src": [
+        "./src/main.c"
+      ],
+      "include": [
+        "./include"
+      ],
+      "libraries": [],
+      "libpath": [],
+      "dependencies": [
+        "@stdlib/strided-base-stride2offset",
+        "@stdlib/blas-base-shared",
+        "@stdlib/blas-ext-base-dsorthp"
+      ]
+    }
+  ]
+}

package/package.json

@@ -0,0 +1,88 @@
+{
+  "name": "@stdlib/blas-ext-base-dsort",
+  "version": "0.1.0",
+  "description": "Sort a double-precision floating-point strided array.",
+  "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",
+  "browser": "./lib/main.js",
+  "gypfile": false,
+  "directories": {
+    "doc": "./docs",
+    "include": "./include",
+    "lib": "./lib",
+    "src": "./src",
+    "dist": "./dist"
+  },
+  "types": "./docs/types",
+  "scripts": {},
+  "homepage": "https://stdlib.io",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/stdlib-js/blas-ext-base-dsort.git"
+  },
+  "bugs": {
+    "url": "https://github.com/stdlib-js/stdlib/issues"
+  },
+  "dependencies": {
+    "@stdlib/assert-is-error": "^0.2.2",
+    "@stdlib/blas-base-shared": "^0.1.0",
+    "@stdlib/blas-ext-base-dsorthp": "^0.3.0",
+    "@stdlib/napi-argv": "^0.2.2",
+    "@stdlib/napi-argv-double": "^0.2.1",
+    "@stdlib/napi-argv-int64": "^0.2.2",
+    "@stdlib/napi-argv-strided-float64array": "^0.2.2",
+    "@stdlib/napi-export": "^0.3.0",
+    "@stdlib/strided-base-stride2offset": "^0.1.0",
+    "@stdlib/utils-define-nonenumerable-read-only-property": "^0.2.2",
+    "@stdlib/utils-library-manifest": "^0.2.3",
+    "@stdlib/utils-try-require": "^0.2.2"
+  },
+  "devDependencies": {},
+  "engines": {
+    "node": ">=0.10.0",
+    "npm": ">2.7.0"
+  },
+  "os": [
+    "aix",
+    "darwin",
+    "freebsd",
+    "linux",
+    "macos",
+    "openbsd",
+    "sunos",
+    "win32",
+    "windows"
+  ],
+  "keywords": [
+    "stdlib",
+    "stdmath",
+    "mathematics",
+    "math",
+    "blas",
+    "extended",
+    "sort",
+    "order",
+    "arrange",
+    "permute",
+    "strided",
+    "array",
+    "ndarray",
+    "float64",
+    "double",
+    "float64array"
+  ],
+  "funding": {
+    "type": "opencollective",
+    "url": "https://opencollective.com/stdlib"
+  }
+}