Merge branch 'develop' of https://github.com/stdlib-js/stdlib into develop

Author: kgryte

docs/contributing/FAQ.md

@@ -31,7 +31,6 @@ limitations under the License.
 -   [What should I do if JavaScript linting on my commits fails because my function exceeds the maximum permissible number of parameters?](#max-params)
 -   [I have opened a pull request, where can I seek feedback?](#pr-feedback)
 -   [I need to generate fixtures for my tests. How can I do that, and what are the best references for inspiration?](#generate-fixtures)
--   [I am facing a `Shadowed declaration` linting error in my C files, how can I fix it?](#shadowed-declaration)
 -   [I am facing a `Uninitialized variable` linting error in my C files, how can I fix it?](#uninitialized-variable)
 -   [I have the required packages in the expected paths, but I am still encountering an error like this while compiling the native add-on.](#compilation-error)
 -   [When should I use decimals in examples, benchmarks, and documentation, and when should I avoid them?](#decimal-usage)
@@ -145,23 +144,6 @@ Consider joining our [Gitter channel][stdlib-gitter]! We are proud to have a ver
 
 Tests are a crucial part of any standard library package. We take our goal of achieving 100% test coverage very seriously and expect your work to be backed by tests. Often, you may need to generate fixtures to validate your implementation against an existing reliable source. You can use Julia, R, Python, or other languages to generate fixtures. To see how we do this, refer to these example scripts: [Python fixture script][python-fixtures], [Julia fixture script][julia-fixtures].
 
-<a name="shadowed-declaration"></a>
-
-## I am facing a `Shadowed declaration` linting error in my C files, how can I fix it?
-
-```bash
-STDLIB_MATH_BASE_NAPI_MODULE_FF_F( stdlib_base_gcdf ) ^
-/home/runner/work/stdlib/stdlib/lib/node_modules/@stdlib/math/base/special/gcdf/include/stdlib/math/base/special/gcdf.h:32:7:
-note: Shadowed declaration float stdlib_base_gcdf( const float a, const float b );
-```
-
-You can suppress that warning by adding a `// cppcheck-suppress shadowFunction` comment above the function. For example:
-
-```c
-// cppcheck-suppress shadowFunction
-STDLIB_MATH_BASE_NAPI_MODULE_FF_F( stdlib_base_gcdf )
-```
-
 <a name="uninitialized-variable"></a>
 
 ## I am facing a `Uninitialized variable` linting error in my C files, how can I fix it?

lib/node_modules/@stdlib/math/base/special/negalucas/benchmark/benchmark.js

@@ -40,7 +40,7 @@ bench( pkg, function benchmark( b ) {
 	var y;
 	var i;
 
-	x = discreteUniform( 100, -77, 0 );
+	x = discreteUniform( 100, -76, 0 );
 
 	b.tic();
 	for ( i = 0; i < b.iterations; i++ ) {
@@ -67,7 +67,7 @@ bench( pkg+'::analytic', function benchmark( b ) {
 		return pow( -1.0, an ) * round( pow( PHI, an ) );
 	}
 
-	x = discreteUniform( 100, -77, 0 );
+	x = discreteUniform( 100, -76, 0 );
 
 	b.tic();
 	for ( i = 0; i < b.iterations; i++ ) {
@@ -89,7 +89,7 @@ bench( pkg+'::table', function benchmark( b ) {
 	var y;
 	var i;
 
-	x = discreteUniform( 100, -77, 0 );
+	x = discreteUniform( 100, -76, 0 );
 
 	b.tic();
 	for ( i = 0; i < b.iterations; i++ ) {
@@ -197,7 +197,7 @@ bench( pkg+'::naive_iterative', function benchmark( b ) {
 		return arr[ an ];
 	}
 
-	x = discreteUniform( 100, -77, 0 );
+	x = discreteUniform( 100, -76, 0 );
 
 	b.tic();
 	for ( i = 0; i < b.iterations; i++ ) {
@@ -238,7 +238,7 @@ bench( pkg+'::iterative', function benchmark( b ) {
 		return b;
 	}
 
-	x = discreteUniform( 100, -77, 0 );
+	x = discreteUniform( 100, -76, 0 );
 
 	b.tic();
 	for ( i = 0; i < b.iterations; i++ ) {
@@ -281,7 +281,7 @@ bench( pkg+'::iterative_memoized', function benchmark( b ) {
 		return arr[ an ];
 	}
 
-	x = discreteUniform( 100, -77, 0 );
+	x = discreteUniform( 100, -76, 0 );
 
 	b.tic();
 	for ( i = 0; i < b.iterations; i++ ) {

lib/node_modules/@stdlib/math/base/special/negalucas/lib/native.js

@@ -0,0 +1,70 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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 //
+
+/**
+* Computes the nth negaLucas number.
+*
+* @private
+* @param {NonPositiveInteger} n - the negaLucas number to compute
+* @returns {integer} negaLucas number
+*
+* @example
+* var y = negalucas( 0 );
+* // returns 2
+*
+* @example
+* y = negalucas( -1 );
+* // returns -1
+*
+* @example
+* y = negalucas( -2 );
+* // returns 3
+*
+* @example
+* y = negalucas( -3 );
+* // returns -4
+*
+* @example
+* y = negalucas( -4 );
+* // returns 7
+*
+* @example
+* y = negalucas( -5 );
+* // returns -11
+*
+* @example
+* y = negalucas( -6 );
+* // returns 18
+*/
+function negalucas( n ) {
+	return addon( n );
+}
+
+
+// EXPORTS //
+
+module.exports = negalucas;

lib/node_modules/@stdlib/stats/base/meanpn/README.md

@@ -2,7 +2,7 @@
 
 @license Apache-2.0
 
-Copyright (c) 2020 The Stdlib Authors.
+Copyright (c) 2025 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.
@@ -51,33 +51,28 @@ The [arithmetic mean][arithmetic-mean] is defined as
 var meanpn = require( '@stdlib/stats/base/meanpn' );
 ```
 
-#### meanpn( N, x, stride )
+#### meanpn( N, x, strideX )
 
-Computes the [arithmetic mean][arithmetic-mean] of a strided array `x` using a two-pass error correction algorithm.
+Computes the [arithmetic mean][arithmetic-mean] of a strided array using a two-pass error correction algorithm.
 
 ```javascript
 var x = [ 1.0, -2.0, 2.0 ];
-var N = x.length;
 
-var v = meanpn( N, x, 1 );
+var v = meanpn( x.length, x, 1 );
 // returns ~0.3333
 ```
 
 The function has the following parameters:
 
 -   **N**: number of indexed elements.
 -   **x**: input [`Array`][mdn-array] or [`typed array`][mdn-typed-array].
--   **stride**: index increment for `x`.
+-   **strideX**: stride length for `x`.
 
-The `N` and `stride` parameters determine which elements in `x` are accessed at runtime. For example, to compute the [arithmetic mean][arithmetic-mean] of every other element in `x`,
+The `N` and stride parameters determine which elements in the strided array are accessed at runtime. For example, to compute the [arithmetic mean][arithmetic-mean] of every other element in the input array
 
 ```javascript
-var floor = require( '@stdlib/math/base/special/floor' );
-
 var x = [ 1.0, 2.0, 2.0, -7.0, -2.0, 3.0, 4.0, 2.0 ];
-var N = floor( x.length / 2 );
-
-var v = meanpn( N, x, 2 );
+var v = meanpn( 4, x, 2 );
 // returns 1.25
 ```
 
@@ -87,42 +82,35 @@ Note that indexing is relative to the first index. To introduce an offset, use [
 
 ```javascript
 var Float64Array = require( '@stdlib/array/float64' );
-var floor = require( '@stdlib/math/base/special/floor' );
 
 var x0 = new Float64Array( [ 2.0, 1.0, 2.0, -2.0, -2.0, 2.0, 3.0, 4.0 ] );
 var x1 = new Float64Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 ); // start at 2nd element
 
-var N = floor( x0.length / 2 );
-
-var v = meanpn( N, x1, 2 );
+var v = meanpn( 4, x1, 2 );
 // returns 1.25
 ```
 
-#### meanpn.ndarray( N, x, stride, offset )
+#### meanpn.ndarray( N, x, strideX, offsetX )
 
 Computes the [arithmetic mean][arithmetic-mean] of a strided array using a two-pass error correction algorithm and alternative indexing semantics.
 
 ```javascript
 var x = [ 1.0, -2.0, 2.0 ];
-var N = x.length;
 
-var v = meanpn.ndarray( N, x, 1, 0 );
+var v = meanpn.ndarray( x.length, x, 1, 0 );
 // returns ~0.33333
 ```
 
 The function has the following additional parameters:
 
--   **offset**: starting index for `x`.
+-   **offsetX**: starting index for `x`.
 
-While [`typed array`][mdn-typed-array] views mandate a view offset based on the underlying `buffer`, the `offset` parameter supports indexing semantics based on a starting index. For example, to calculate the [arithmetic mean][arithmetic-mean] for every other value in `x` starting from the second value
+While [`typed array`][mdn-typed-array] views mandate a view offset based on the underlying buffer, the offset parameter supports indexing semantics based on a starting index. For example, to calculate the [arithmetic mean][arithmetic-mean] for every other element in the strided array starting from the second element
 
 ```javascript
-var floor = require( '@stdlib/math/base/special/floor' );
-
 var x = [ 2.0, 1.0, 2.0, -2.0, -2.0, 2.0, 3.0, 4.0 ];
-var N = floor( x.length / 2 );
 
-var v = meanpn.ndarray( N, x, 2, 1 );
+var v = meanpn.ndarray( 4, x, 2, 1 );
 // returns 1.25
 ```
 
@@ -135,6 +123,7 @@ var v = meanpn.ndarray( N, x, 2, 1 );
 ## Notes
 
 -   If `N <= 0`, both functions return `NaN`.
+-   Both functions support array-like objects having getter and setter accessors for array element access (e.g., [`@stdlib/array/base/accessor`][@stdlib/array/base/accessor]).
 -   Depending on the environment, the typed versions ([`dmeanpn`][@stdlib/stats/base/dmeanpn], [`smeanpn`][@stdlib/stats/base/smeanpn], etc.) are likely to be significantly more performant.
 
 </section>
@@ -148,18 +137,12 @@ var v = meanpn.ndarray( N, x, 2, 1 );
 <!-- eslint no-undef: "error" -->
 
 ```javascript
-var randu = require( '@stdlib/random/base/randu' );
-var round = require( '@stdlib/math/base/special/round' );
-var Float64Array = require( '@stdlib/array/float64' );
+var discreteUniform = require( '@stdlib/random/array/discrete-uniform' );
 var meanpn = require( '@stdlib/stats/base/meanpn' );
 
-var x;
-var i;
-
-x = new Float64Array( 10 );
-for ( i = 0; i < x.length; i++ ) {
-    x[ i ] = round( (randu()*100.0) - 50.0 );
-}
+var x = discreteUniform( 10, -50, 50, {
+    'dtype': 'float64'
+});
 console.log( x );
 
 var v = meanpn( x.length, x, 1 );
@@ -210,6 +193,8 @@ console.log( v );
 
 [mdn-typed-array]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray
 
+[@stdlib/array/base/accessor]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/array/base/accessor
+
 [@neely:1966a]: https://doi.org/10.1145/365719.365958
 
 [@schubert:2018a]: https://doi.org/10.1145/3221269.3223036

lib/node_modules/@stdlib/stats/base/meanpn/benchmark/benchmark.js

@@ -1,7 +1,7 @@
 /**
 * @license Apache-2.0
 *
-* Copyright (c) 2020 The Stdlib Authors.
+* Copyright (c) 2025 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.
@@ -21,11 +21,18 @@
 // MODULES //
 
 var bench = require( '@stdlib/bench' );
-var randu = require( '@stdlib/random/base/randu' );
+var uniform = require( '@stdlib/random/array/uniform' );
 var isnan = require( '@stdlib/math/base/assert/is-nan' );
 var pow = require( '@stdlib/math/base/special/pow' );
 var pkg = require( './../package.json' ).name;
-var meanpn = require( './../lib/meanpn.js' );
+var meanpn = require( './../lib/main.js' );
+
+
+// VARIABLES //
+
+var options = {
+	'dtype': 'generic'
+};
 
 
 // FUNCTIONS //
@@ -38,13 +45,7 @@ var meanpn = require( './../lib/meanpn.js' );
 * @returns {Function} benchmark function
 */
 function createBenchmark( len ) {
-	var x;
-	var i;
-
-	x = [];
-	for ( i = 0; i < len; i++ ) {
-		x.push( ( randu()*20.0 ) - 10.0 );
-	}
+	var x = uniform( len, -10, 10, options );
 	return benchmark;
 
 	function benchmark( b ) {