Merge branch 'develop' into array/base-toFilled

Author: headlessNode

lib/node_modules/@stdlib/_tools/eslint/rules/eol-open-bracket-spacing/lib/main.js

@@ -79,44 +79,49 @@ function main( context ) {
 		var prevToken;
 		var elem;
 		var args;
+		var v;
 
 		if (
 			( node.type === 'CallExpression' || node.type === 'NewExpression' ) &&
 			node.arguments.length > 0
 		) {
 			args = node.arguments;
+			v = args[ 0 ];
 			if (
-				args[ 0 ].type === 'ObjectExpression' &&
-				args[ 0 ].properties.length > 0
+				v &&
+				v.type === 'ObjectExpression' &&
+				v.properties.length > 0
 			) {
-				prevToken = source.getTokenBefore( args[ 0 ] );
-				tokenAfter = source.getFirstToken( args[ 0 ] );
+				prevToken = source.getTokenBefore( v );
+				tokenAfter = source.getFirstToken( v );
 				if (
 					prevToken.loc.end.line === tokenAfter.loc.end.line &&
 					source.isSpaceBetween( prevToken, tokenAfter )
 				) {
 					report( node, prevToken, tokenAfter );
 				}
 			} else if (
-				args[ 0 ].type === 'ArrayExpression' &&
-				args[ 0 ].elements.length > 0
+				v &&
+				v.type === 'ArrayExpression' &&
+				v.elements.length > 0
 			) {
-				elem = args[ 0 ].elements[ 0 ];
+				elem = v.elements[ 0 ];
 				if (
+					elem &&
 					elem.type === 'ObjectExpression' &&
 					elem.properties.length > 0
 				) {
-					prevToken = source.getTokenBefore( args[ 0 ] );
-					tokenAfter = source.getFirstToken( args[ 0 ] );
+					prevToken = source.getTokenBefore( v );
+					tokenAfter = source.getFirstToken( v );
 					if (
 						prevToken.loc.end.line === tokenAfter.loc.end.line &&
 						source.isSpaceBetween( prevToken, tokenAfter )
 					) {
 						report( node, prevToken, tokenAfter );
 					}
 				} else {
-					prevToken = source.getTokenBefore( args[ 0 ] );
-					tokenAfter = source.getFirstToken( args[ 0 ] );
+					prevToken = source.getTokenBefore( v );
+					tokenAfter = source.getFirstToken( v );
 					nextToken = source.getTokenAfter( tokenAfter );
 					if (
 						tokenAfter.loc.end.line !== nextToken.loc.end.line &&
@@ -135,6 +140,7 @@ function main( context ) {
 		) {
 			elem = node.elements[ 0 ];
 			if (
+				elem &&
 				elem.type === 'ObjectExpression' &&
 				elem.properties.length > 0
 			) {

lib/node_modules/@stdlib/_tools/eslint/rules/line-closing-bracket-spacing/lib/main.js

@@ -86,8 +86,9 @@ function main( context ) {
 			node.arguments.length > 0
 		) {
 			args = node.arguments;
-			lastElem = args[ args.length - 1 ];
+			lastElem = args[ args.length-1 ];
 			if (
+				lastElem &&
 				lastElem.type === 'ObjectExpression' &&
 				lastElem.properties.length > 0
 			) {
@@ -100,11 +101,13 @@ function main( context ) {
 					report( node, prevToken, tokenAfter );
 				}
 			} else if (
+				lastElem &&
 				lastElem.type === 'ArrayExpression' &&
 				lastElem.elements.length > 0
 			) {
-				elem = lastElem.elements[ lastElem.elements.length - 1 ];
+				elem = lastElem.elements[ lastElem.elements.length-1 ];
 				if (
+					elem &&
 					elem.type === 'ObjectExpression' &&
 					elem.properties.length > 0
 				) {
@@ -135,8 +138,9 @@ function main( context ) {
 			node.type === 'ArrayExpression' &&
 			node.elements.length > 0
 		) {
-			elem = node.elements[ node.elements.length - 1 ];
+			elem = node.elements[ node.elements.length-1 ];
 			if (
+				elem &&
 				elem.type === 'ObjectExpression' &&
 				elem.properties.length > 0
 			) {

lib/node_modules/@stdlib/blas/base/README.md

@@ -46,11 +46,11 @@ var o = blas;
 <div class="namespace-toc">
 
 -   <span class="signature">[`caxpy( N, alpha, x, strideX, y, strideY )`][@stdlib/blas/base/caxpy]</span><span class="delimiter">: </span><span class="description">scale a single-precision complex floating-point vector by a single-precision complex floating-point constant and add the result to a single-precision complex floating-point vector.</span>
--   <span class="signature">[`ccopy( N, x, strideX, y, strideY )`][@stdlib/blas/base/ccopy]</span><span class="delimiter">: </span><span class="description">copy values from one complex single-precision floating-point vector to another complex single-precision floating-point vector.</span>
+-   <span class="signature">[`ccopy( N, x, strideX, y, strideY )`][@stdlib/blas/base/ccopy]</span><span class="delimiter">: </span><span class="description">copy values from one single-precision complex floating-point vector to another single-precision complex floating-point vector.</span>
 -   <span class="signature">[`cscal( N, alpha, x, strideX )`][@stdlib/blas/base/cscal]</span><span class="delimiter">: </span><span class="description">scales a single-precision complex floating-point vector by a single-precision complex floating-point constant.</span>
 -   <span class="signature">[`csrot( N, x, strideX, y, strideY, c, s )`][@stdlib/blas/base/csrot]</span><span class="delimiter">: </span><span class="description">apply a plane rotation.</span>
 -   <span class="signature">[`csscal( N, alpha, x, strideX )`][@stdlib/blas/base/csscal]</span><span class="delimiter">: </span><span class="description">scale a single-precision complex floating-point vector by a single-precision floating-point constant.</span>
--   <span class="signature">[`cswap( N, x, strideX, y, strideY )`][@stdlib/blas/base/cswap]</span><span class="delimiter">: </span><span class="description">interchange two complex single-precision floating-point vectors.</span>
+-   <span class="signature">[`cswap( N, x, strideX, y, strideY )`][@stdlib/blas/base/cswap]</span><span class="delimiter">: </span><span class="description">interchange two single-precision complex floating-point vectors.</span>
 -   <span class="signature">[`dasum( N, x, stride )`][@stdlib/blas/base/dasum]</span><span class="delimiter">: </span><span class="description">compute the sum of absolute values (_L1_ norm).</span>
 -   <span class="signature">[`daxpy( N, alpha, x, strideX, y, strideY )`][@stdlib/blas/base/daxpy]</span><span class="delimiter">: </span><span class="description">multiply a vector `x` by a constant `alpha` and add the result to `y`.</span>
 -   <span class="signature">[`dcopy( N, x, strideX, y, strideY )`][@stdlib/blas/base/dcopy]</span><span class="delimiter">: </span><span class="description">copy values from `x` into `y`.</span>
@@ -62,7 +62,7 @@ var o = blas;
 -   <span class="signature">[`dscal( N, alpha, x, stride )`][@stdlib/blas/base/dscal]</span><span class="delimiter">: </span><span class="description">multiply a double-precision floating-point vector `x` by a constant `alpha`.</span>
 -   <span class="signature">[`dsdot( N, x, strideX, y, strideY )`][@stdlib/blas/base/dsdot]</span><span class="delimiter">: </span><span class="description">calculate the dot product with extended accumulation and result of two single-precision floating-point vectors.</span>
 -   <span class="signature">[`dswap( N, x, strideX, y, strideY )`][@stdlib/blas/base/dswap]</span><span class="delimiter">: </span><span class="description">interchange two double-precision floating-point vectors.</span>
--   <span class="signature">[`dznrm2( N, x, strideX )`][@stdlib/blas/base/dznrm2]</span><span class="delimiter">: </span><span class="description">compute the L2-norm of a complex double-precision floating-point vector.</span>
+-   <span class="signature">[`dznrm2( N, x, strideX )`][@stdlib/blas/base/dznrm2]</span><span class="delimiter">: </span><span class="description">compute the L2-norm of a double-precision complex floating-point vector.</span>
 -   <span class="signature">[`gasum( N, x, stride )`][@stdlib/blas/base/gasum]</span><span class="delimiter">: </span><span class="description">compute the sum of absolute values (_L1_ norm).</span>
 -   <span class="signature">[`gaxpy( N, alpha, x, strideX, y, strideY )`][@stdlib/blas/base/gaxpy]</span><span class="delimiter">: </span><span class="description">multiply `x` by a constant `alpha` and add the result to `y`.</span>
 -   <span class="signature">[`gcopy( N, x, strideX, y, strideY )`][@stdlib/blas/base/gcopy]</span><span class="delimiter">: </span><span class="description">copy values from `x` into `y`.</span>
@@ -76,7 +76,7 @@ var o = blas;
 -   <span class="signature">[`sasum( N, x, stride )`][@stdlib/blas/base/sasum]</span><span class="delimiter">: </span><span class="description">compute the sum of absolute values (_L1_ norm).</span>
 -   <span class="signature">[`saxpy( N, alpha, x, strideX, y, strideY )`][@stdlib/blas/base/saxpy]</span><span class="delimiter">: </span><span class="description">multiply a vector `x` by a constant `alpha` and add the result to `y`.</span>
 -   <span class="signature">[`scasum( N, x, strideX )`][@stdlib/blas/base/scasum]</span><span class="delimiter">: </span><span class="description">compute the sum of the absolute values of the real and imaginary components of a single-precision complex floating-point vector.</span>
--   <span class="signature">[`scnrm2( N, x, strideX )`][@stdlib/blas/base/scnrm2]</span><span class="delimiter">: </span><span class="description">compute the L2-norm of a complex single-precision floating-point vector.</span>
+-   <span class="signature">[`scnrm2( N, x, strideX )`][@stdlib/blas/base/scnrm2]</span><span class="delimiter">: </span><span class="description">compute the L2-norm of a single-precision complex floating-point vector.</span>
 -   <span class="signature">[`scopy( N, x, strideX, y, strideY )`][@stdlib/blas/base/scopy]</span><span class="delimiter">: </span><span class="description">copy values from `x` into `y`.</span>
 -   <span class="signature">[`sdot( N, x, strideX, y, strideY )`][@stdlib/blas/base/sdot]</span><span class="delimiter">: </span><span class="description">calculate the dot product of two single-precision floating-point vectors.</span>
 -   <span class="signature">[`sdsdot( N, scalar, x, strideX, y, strideY )`][@stdlib/blas/base/sdsdot]</span><span class="delimiter">: </span><span class="description">calculate the dot product of two single-precision floating-point vectors with extended accumulation.</span>
@@ -87,11 +87,11 @@ var o = blas;
 -   <span class="signature">[`sscal( N, alpha, x, stride )`][@stdlib/blas/base/sscal]</span><span class="delimiter">: </span><span class="description">multiply a single-precision floating-point vector `x` by a constant `alpha`.</span>
 -   <span class="signature">[`sswap( N, x, strideX, y, strideY )`][@stdlib/blas/base/sswap]</span><span class="delimiter">: </span><span class="description">interchange two single-precision floating-point vectors.</span>
 -   <span class="signature">[`zaxpy( N, alpha, x, strideX, y, strideY )`][@stdlib/blas/base/zaxpy]</span><span class="delimiter">: </span><span class="description">scale a double-precision complex floating-point vector by a double-precision complex floating-point constant and add the result to a double-precision complex floating-point vector.</span>
--   <span class="signature">[`zcopy( N, x, strideX, y, strideY )`][@stdlib/blas/base/zcopy]</span><span class="delimiter">: </span><span class="description">copy values from one complex double-precision floating-point vector to another complex double-precision floating-point vector.</span>
+-   <span class="signature">[`zcopy( N, x, strideX, y, strideY )`][@stdlib/blas/base/zcopy]</span><span class="delimiter">: </span><span class="description">copy values from one double-precision complex floating-point vector to another double-precision complex floating-point vector.</span>
 -   <span class="signature">[`zdrot( N, x, strideX, y, strideY, c, s )`][@stdlib/blas/base/zdrot]</span><span class="delimiter">: </span><span class="description">apply a plane rotation.</span>
 -   <span class="signature">[`zdscal( N, alpha, x, strideX )`][@stdlib/blas/base/zdscal]</span><span class="delimiter">: </span><span class="description">scale a double-precision complex floating-point vector by a double-precision floating-point constant.</span>
 -   <span class="signature">[`zscal( N, alpha, x, strideX )`][@stdlib/blas/base/zscal]</span><span class="delimiter">: </span><span class="description">scales a double-precision complex floating-point vector by a double-precision complex floating-point constant.</span>
--   <span class="signature">[`zswap( N, x, strideX, y, strideY )`][@stdlib/blas/base/zswap]</span><span class="delimiter">: </span><span class="description">interchange two complex double-precision floating-point vectors.</span>
+-   <span class="signature">[`zswap( N, x, strideX, y, strideY )`][@stdlib/blas/base/zswap]</span><span class="delimiter">: </span><span class="description">interchange two double-precision complex floating-point vectors.</span>
 
 </div>
 

lib/node_modules/@stdlib/blas/base/ccopy/README.md

@@ -20,7 +20,7 @@ limitations under the License.
 
 # ccopy
 
-> Copy values from one complex single-precision floating-point vector to another complex single-precision floating-point vector.
+> Copy values from one single-precision complex floating-point vector to another single-precision complex floating-point vector.
 
 <section class="usage">
 
@@ -303,7 +303,7 @@ int main( void ) {
 
 ## See Also
 
--   <span class="package-name">[`@stdlib/blas/base/cswap`][@stdlib/blas/base/cswap]</span><span class="delimiter">: </span><span class="description">interchange two complex single-precision floating-point vectors.</span>
+-   <span class="package-name">[`@stdlib/blas/base/cswap`][@stdlib/blas/base/cswap]</span><span class="delimiter">: </span><span class="description">interchange two single-precision complex floating-point vectors.</span>
 
 </section>
 

lib/node_modules/@stdlib/blas/base/ccopy/docs/repl.txt

@@ -1,7 +1,7 @@
 
 {{alias}}( N, x, strideX, y, strideY )
-    Copies values from one complex single-precision floating-point vector to
-    another complex single-precision floating-point vector.
+    Copies values from one single-precision complex floating-point vector to
+    another single-precision complex floating-point vector.
 
     The `N` and stride parameters determine how values from `x` are copied into
     `y`.
@@ -59,8 +59,8 @@
 
 
 {{alias}}.ndarray( N, x, strideX, offsetX, y, strideY, offsetY )
-    Copies values from one complex single-precision floating-point vector to
-    another complex single-precision floating-point vector using alternative
+    Copies values from one single-precision complex floating-point vector to
+    another single-precision complex floating-point vector using alternative
     indexing semantics.
 
     While typed array views mandate a view offset based on the underlying

lib/node_modules/@stdlib/blas/base/ccopy/docs/types/index.d.ts

@@ -27,7 +27,7 @@ import { Complex64Array } from '@stdlib/types/array';
 */
 interface Routine {
 	/**
-	* Copies values from one complex single-precision floating-point vector to another complex single-precision floating-point vector.
+	* Copies values from one single-precision complex floating-point vector to another single-precision complex floating-point vector.
 	*
 	* @param N - number of indexed elements
 	* @param x - input array
@@ -48,7 +48,7 @@ interface Routine {
 	( N: number, x: Complex64Array, strideX: number, y: Complex64Array, strideY: number ): Complex64Array;
 
 	/**
-	* Copies values from one complex single-precision floating-point vector to another complex single-precision floating-point vector using alternative indexing semantics.
+	* Copies values from one single-precision complex floating-point vector to another single-precision complex floating-point vector using alternative indexing semantics.
 	*
 	* @param N - number of indexed elements
 	* @param x - input array
@@ -72,7 +72,7 @@ interface Routine {
 }
 
 /**
-* Copies values from one complex single-precision floating-point vector to another complex single-precision floating-point vector.
+* Copies values from one single-precision complex floating-point vector to another single-precision complex floating-point vector.
 *
 * @param N - number of indexed elements
 * @param x - input array

lib/node_modules/@stdlib/blas/base/ccopy/include/stdlib/blas/base/ccopy.h

@@ -32,12 +32,12 @@ extern "C" {
 #endif
 
 /**
-* Copies values from one complex single-precision floating-point vector to another complex single-precision floating-point vector.
+* Copies values from one single-precision complex floating-point vector to another single-precision complex floating-point vector.
 */
 void API_SUFFIX(c_ccopy)( const CBLAS_INT N, const void *X, const CBLAS_INT strideX, void *Y, const CBLAS_INT strideY );
 
 /**
-* Copies values from one complex single-precision floating-point vector to another complex single-precision floating-point vector using alternative indexing semantics.
+* Copies values from one single-precision complex floating-point vector to another single-precision complex floating-point vector using alternative indexing semantics.
 */
 void API_SUFFIX(c_ccopy_ndarray)( const CBLAS_INT N, const void *X, const CBLAS_INT strideX, const CBLAS_INT offsetX, void *Y, const CBLAS_INT strideY, const CBLAS_INT offsetY );
 

lib/node_modules/@stdlib/blas/base/ccopy/include/stdlib/blas/base/ccopy_cblas.h

@@ -32,7 +32,7 @@ extern "C" {
 #endif
 
 /**
-* Copies values from one complex single-precision floating-point vector to another complex single-precision floating-point vector.
+* Copies values from one single-precision complex floating-point vector to another single-precision complex floating-point vector.
 */
 void API_SUFFIX(cblas_ccopy)( const CBLAS_INT N, const void *X, const CBLAS_INT strideX, void *Y, const CBLAS_INT strideY );
 

lib/node_modules/@stdlib/blas/base/ccopy/include/stdlib/blas/base/ccopy_fortran.h

@@ -30,7 +30,7 @@ extern "C" {
 #endif
 
 /**
-* Copies values from one complex single-precision floating-point vector to another complex single-precision floating-point vector.
+* Copies values from one single-precision complex floating-point vector to another single-precision complex floating-point vector.
 */
 void ccopy( const CBLAS_INT *, const void *, const CBLAS_INT *, void *, const CBLAS_INT * );
 

lib/node_modules/@stdlib/blas/base/ccopy/lib/ccopy.js

@@ -27,7 +27,7 @@ var ndarray = require( './ndarray.js' );
 // MAIN //
 
 /**
-* Copies values from one complex single-precision floating-point vector to another complex single-precision floating-point vector.
+* Copies values from one single-precision complex floating-point vector to another single-precision complex floating-point vector.
 *
 * @param {PositiveInteger} N - number of indexed elements
 * @param {Complex64Array} x - input array