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

kgryte · kgryte · commit 640d25be0a04 · 2021-05-06T22:17:05.000-07:00
diff --git a/lib/node_modules/@stdlib/_tools/scripts/create_ordered_pkg_list.js b/lib/node_modules/@stdlib/_tools/scripts/create_ordered_pkg_list.js
@@ -16,7 +16,7 @@
 * limitations under the License.
 */
 
-/* eslint-disable no-sync, no-console */
+/* eslint-disable no-console, stdlib/no-internal-require */
 
 'use strict';
 
@@ -26,13 +26,15 @@ var join = require( 'path' ).join;
 var writeFileSync = require( '@stdlib/fs/write-file' ).sync;
 var ls = require( '@stdlib/_tools/pkgs/names' ).sync;
 var namespaceDeps = require( '@stdlib/_tools/pkgs/namespace-deps' );
+var standalonePackage = require( '@stdlib/_tools/pkgs/namespace-deps/lib/standalone_package.js' ); // FIXME: avoid requiring package internals
 var CompactAdjacencyMatrix = require( '@stdlib/utils/compact-adjacency-matrix/lib/main.js' );
 var indexOf = require( '@stdlib/utils/index-of' );
 var contains = require( '@stdlib/assert/contains' );
 
 
 // VARIABLES //
 
+var standalonePkgs;
 var sorted;
 var pkgs;
 var deps;
@@ -46,15 +48,31 @@ var j;
 
 pkgs = ls();
 console.log( 'Number of stdlib packages: '+pkgs.length );
+
+standalonePkgs = new Array( pkgs.length );
+for ( i = 0; i < pkgs.length; i++ ) {
+	standalonePkgs[ i ] = standalonePackage( pkgs[ i ] );
+}
 mat = new CompactAdjacencyMatrix( pkgs.length );
 
 for ( i = 0; i < pkgs.length; i++ ) {
 	console.log( 'Processing package: '+pkgs[ i ]+' (index: '+i+')' );
+	if (
+		pkgs[ i ] === '@stdlib/process/cwd' ||
+		pkgs[ i ] === '@stdlib/process/node-version'
+	) {
+		continue;
+	}
 	try {
-		deps = namespaceDeps( pkgs[ i ] );
+		deps = namespaceDeps( pkgs[ i ], {
+			'dev': false,
+			'level': 999
+		});
 		for ( j = 0; j < deps.length; j++ ) {
-			idx = indexOf( pkgs, deps[ j ] );
-			if ( idx !== -1 && !contains( deps[ j ], '_tools' ) ) {
+			idx = indexOf( standalonePkgs, deps[ j ] );
+			if (
+				idx !== -1 && !contains( deps[ j ], '_tools' )
+			) {
 				mat.addEdge( i, idx );
 			}
 		}
@@ -63,11 +81,22 @@ for ( i = 0; i < pkgs.length; i++ ) {
 	}
 }
 
+for ( let i = 0; i < pkgs.length; i++ ) {
+	for ( let j = 0; j < pkgs.length; j++ ) {
+		if (
+			mat.hasEdge( i, j ) === mat.hasEdge( j, i ) &&
+			mat.hasEdge( j, i ) === true
+		) {
+			console.log( 'Encountered cycle: ( '+pkgs[ i ]+', '+pkgs[ j ]+')' );
+		}
+	}
+}
+
 console.log( 'Starting topological search...' );
 sorted = mat.toposort();
+
 for ( i = 0; i < sorted.length; i++ ) {
 	sorted[ i ] = pkgs[ sorted[ i ] ];
 }
 
 writeFileSync( join( __dirname, './ordered.json' ), JSON.stringify( sorted, null, '  ' ).concat( '\n' ) );
-
diff --git a/lib/node_modules/@stdlib/math/base/special/falling-factorial/lib/falling_factorial.js b/lib/node_modules/@stdlib/math/base/special/falling-factorial/lib/falling_factorial.js
@@ -40,12 +40,12 @@ var floor = require( '@stdlib/math/base/special/floor' );
 var abs = require( '@stdlib/math/base/special/abs' );
 var FLOAT64_MAX = require( '@stdlib/constants/math/float64-max' );
 var PINF = require( '@stdlib/constants/math/float64-pinf' );
+var risingFactorial = require( './rising_factorial.js' );
 
 
 // VARIABLES //
 
 var MAX_FACTORIAL = 170; // TODO: consider packaging as constant
-var risingFactorial;
 
 
 // MAIN //
@@ -88,10 +88,6 @@ function fallingFactorial( x, n ) {
 	var t1;
 	var t2;
 
-	// Lazy-load to avoid undefined reference due to circular dependency...
-	if ( !risingFactorial ) {
-		risingFactorial = require( '@stdlib/math/base/special/rising-factorial' );
-	}
 	if ( isnan( x ) || !isNonNegativeInteger( n ) ) {
 		return NaN;
 	}
diff --git a/lib/node_modules/@stdlib/math/base/special/falling-factorial/lib/rising_factorial.js b/lib/node_modules/@stdlib/math/base/special/falling-factorial/lib/rising_factorial.js
@@ -0,0 +1,121 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2018 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.
+*
+*
+* ## Notice
+*
+* The original C++ code and copyright notice are from the [Boost library]{@link http://www.boost.org/doc/libs/1_64_0/boost/math/special_functions/factorials.hpp}. The implementation has been modified for JavaScript.
+*
+* ```text
+* (C) Copyright John Maddock 2006, 2010.
+*
+* Use, modification and distribution are subject to the
+* Boost Software License, Version 1.0. (See accompanying file
+* LICENSE or copy at http://www.boost.org/LICENSE_1_0.txt)
+* ```
+*/
+
+'use strict';
+
+// MODULES //
+
+var isInteger = require( '@stdlib/math/base/assert/is-integer' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var gammaDeltaRatio = require( '@stdlib/math/base/special/gamma-delta-ratio' );
+var fallingFactorial = require( './falling_factorial.js' );
+
+
+// MAIN //
+
+/**
+* Computes the rising factorial of `x` and `n`.
+*
+* ## Notes
+*
+* -   The rising factorial is defined as
+*
+*     ```tex
+*     \operatorname{risingFactorial}(x, n) = x (x-1) (x-2) (x-3) \ldots (x-n+1)
+*     ```
+*
+*     or equivalently
+*
+*     ```tex
+*     \operatorname{risingFactorial}(x, n) = \frac{ \Gamma(x + n) }{ \Gamma(x) };
+*     ```
+*
+* @param {number} x - first function parameter
+* @param {integer} n - second function parameter
+* @returns {number} function value
+*
+* @example
+* var v = risingFactorial( 0.9, 5 );
+* // returns ~94.766
+*
+* @example
+* var v = risingFactorial( -9.0, 3 );
+* // returns -504.0
+*
+* @example
+* var v = risingFactorial( 0.0, 2 );
+* // returns 0.0
+*
+* @example
+* var v = risingFactorial( 3.0, -2 );
+* // returns 0.5
+*/
+function risingFactorial( x, n ) {
+	var result;
+	var inv;
+
+	if ( isnan( x ) || !isInteger( n ) ) {
+		return NaN;
+	}
+	if ( x < 0.0 ) {
+		// For `x < 0`, we really have a falling factorial, modulo a possible change of sign. Note that the falling factorial isn't defined for negative `n`, so we'll get rid of that case first:
+		if ( n < 0.0 ) {
+			x += n;
+			n = -n;
+			inv = true;
+		}
+		result = ( (n&1) ? -1.0 : 1.0 ) * fallingFactorial( -x, n );
+		if ( inv ) {
+			result = 1.0 / result;
+		}
+		return result;
+	}
+	if ( n === 0 ) {
+		return 1.0;
+	}
+	if ( x === 0.0 ) {
+		if ( n < 0 ) {
+			return -gammaDeltaRatio( x+1.0, -n );
+		}
+		return 0.0;
+	}
+	if ( x < 1.0 && x+n < 0.0 ) {
+		result = gammaDeltaRatio( 1.0-x, -n );
+		return ( n&1 ) ? -result : result;
+	}
+	// We don't optimize this for small `n`, because `gammaDeltaRatio` is already optimized for that use case:
+	return 1.0 / gammaDeltaRatio( x, n );
+}
+
+
+// EXPORTS //
+
+module.exports = risingFactorial;
diff --git a/lib/node_modules/@stdlib/math/base/special/rising-factorial/lib/rising_factorial.js b/lib/node_modules/@stdlib/math/base/special/rising-factorial/lib/rising_factorial.js
@@ -36,11 +36,7 @@
 var isInteger = require( '@stdlib/math/base/assert/is-integer' );
 var isnan = require( '@stdlib/math/base/assert/is-nan' );
 var gammaDeltaRatio = require( '@stdlib/math/base/special/gamma-delta-ratio' );
-
-
-// VARIABLES //
-
-var fallingFactorial;
+var fallingFactorial = require( '@stdlib/math/base/special/falling-factorial' );
 
 
 // MAIN //
@@ -86,10 +82,6 @@ function risingFactorial( x, n ) {
 	var result;
 	var inv;
 
-	// Lazy-load to avoid undefined reference due to circular dependency...
-	if ( !fallingFactorial ) {
-		fallingFactorial = require( '@stdlib/math/base/special/falling-factorial' );
-	}
 	if ( isnan( x ) || !isInteger( n ) ) {
 		return NaN;
 	}
