fix: apply suggestions from code review

---
type: pre_commit_static_analysis_report
description: Results of running static analysis checks when committing changes.
report:
  - task: lint_filenames
    status: passed
  - task: lint_editorconfig
    status: passed
  - task: lint_markdown
    status: passed
  - task: lint_package_json
    status: na
  - task: lint_repl_help
    status: passed
  - task: lint_javascript_src
    status: passed
  - task: lint_javascript_cli
    status: na
  - task: lint_javascript_examples
    status: na
  - task: lint_javascript_tests
    status: passed
  - task: lint_javascript_benchmarks
    status: na
  - task: lint_python
    status: na
  - task: lint_r
    status: na
  - task: lint_c_src
    status: na
  - task: lint_c_examples
    status: na
  - task: lint_c_benchmarks
    status: na
  - task: lint_c_tests_fixtures
    status: na
  - task: lint_shell
    status: na
  - task: lint_typescript_declarations
    status: passed
  - task: lint_typescript_tests
    status: passed
  - task: lint_license_headers
    status: passed
---

Author: headlessNode

lib/node_modules/@stdlib/ndarray/base/tile/README.md

@@ -64,9 +64,8 @@ var y = tile( x, [ 2, 2 ] );
 
 ## Notes
 
--   When the number of repetitions is less than the number of input dimensions, the number of repetitions is left-padded with ones until the number of repetitions matches the number of input dimensions. When the number of repetitions exceeds the number of input dimensions, the input [ndarray][@stdlib/ndarray/base/ctor] is treated as if singleton dimensions were prepended.
--   The output [ndarray][@stdlib/ndarray/base/ctor] has rank equal to the greater of the input array rank and the number of repetitions.
--   The function always returns a new [ndarray][@stdlib/ndarray/base/ctor] having a newly allocated data buffer.
+-   The number of repetitions must have at least as many elements as the number of input dimensions. When the number of repetitions exceeds the number of input dimensions, the input [ndarray][@stdlib/ndarray/base/ctor] is treated as if singleton dimensions were prepended.
+-   The function always copies data to a new [ndarray][@stdlib/ndarray/base/ctor].
 
 </section>
 

lib/node_modules/@stdlib/ndarray/base/tile/docs/repl.txt

@@ -3,17 +3,12 @@
     Returns an ndarray created by repeating the elements of an input ndarray
     a specified number of times along each dimension.
 
-    When the number of repetitions is less than the number of input dimensions,
-    the number of repetitions is left-padded with ones until the number of
-    repetitions matches the number of input dimensions. When the number of
-    repetitions exceeds the number of input dimensions, the input array is
-    treated as if singleton dimensions were prepended.
+    The number of repetitions must have at least as many elements as the number
+    of input dimensions. When the number of repetitions exceeds the number of
+    input dimensions, the input array is treated as if singleton dimensions
+    were prepended.
 
-    The output array has rank equal to the greater of the input array rank and
-    the number of repetitions.
-
-    The function always returns a new ndarray having a newly allocated data
-    buffer.
+    The function always copies data to a new ndarray.
 
     Parameters
     ----------

lib/node_modules/@stdlib/ndarray/base/tile/docs/types/index.d.ts

@@ -28,9 +28,8 @@ import { ndarray } from '@stdlib/types/ndarray';
 *
 * ## Notes
 *
-* -   When the number of repetitions is less than the number of input dimensions, the number of repetitions is left-padded with ones until the number of repetitions matches the number of input dimensions. When the number of repetitions exceeds the number of input dimensions, the input array is treated as if singleton dimensions were prepended.
-* -   The output array has rank equal to the greater of the input array rank and the number of repetitions.
-* -   The function always returns a new ndarray having a newly allocated data buffer.
+* -   The number of repetitions must have at least as many elements as the number of input dimensions. When the number of repetitions exceeds the number of input dimensions, the input array is treated as if singleton dimensions were prepended.
+* -   The function always copies data to a new ndarray.
 *
 * @param x - input array
 * @param reps - number of repetitions along each dimension
@@ -45,7 +44,7 @@ import { ndarray } from '@stdlib/types/ndarray';
 * var y = tile( x, [ 2, 2 ] );
 * // returns <ndarray>[ [ 1, 2, 1, 2 ], [ 3, 4, 3, 4 ], [ 1, 2, 1, 2 ], [ 3, 4, 3, 4 ] ]
 */
-declare function tile( x: ndarray, reps: ArrayLike<number> ): ndarray;
+declare function tile<T extends ndarray>( x: T, reps: ArrayLike<number> ): T;
 
 
 // EXPORTS //

lib/node_modules/@stdlib/ndarray/base/tile/docs/types/test.ts

@@ -16,46 +16,30 @@
 * limitations under the License.
 */
 
+/* eslint-disable space-in-parens */
+
 /// <reference types="@stdlib/types"/>
 
-import { ndarray } from '@stdlib/types/ndarray';
+import zeros = require( '@stdlib/ndarray/zeros' );
 import tile = require( './index' );
 
-/**
-* Mock function to create an ndarray-like object.
-*
-* @returns ndarray-like object
-*/
-function array(): ndarray {
-	const obj: ndarray = {
-		'byteLength': 80,
-		'BYTES_PER_ELEMENT': 8,
-		'data': new Float64Array( 10 ),
-		'dtype': 'float64',
-		'flags': {
-			'ROW_MAJOR_CONTIGUOUS': true,
-			'COLUMN_MAJOR_CONTIGUOUS': false
-		},
-		'length': 10,
-		'ndims': 1,
-		'offset': 0,
-		'order': 'row-major',
-		'shape': [ 10 ],
-		'strides': [ 1 ],
-		'get': (): number => 0,
-		'set': (): ndarray => obj
-	};
-	return obj;
-}
-
 
 // TESTS //
 
-// The function returns an ndarray...
+// The function returns an ndarray having the same type as the input ndarray...
 {
-	const x = array();
-
-	tile( x, [ 2, 2, 2 ] ); // $ExpectType ndarray
+	tile( zeros( [ 2, 2 ], { 'dtype': 'float64' } ), [ 2, 2 ] ); // $ExpectType float64ndarray
+	tile( zeros( [ 2, 2 ], { 'dtype': 'float32' } ), [ 2, 2 ] ); // $ExpectType float32ndarray
+	tile( zeros( [ 2, 2 ], { 'dtype': 'complex128' } ), [ 2, 2 ] ); // $ExpectType complex128ndarray
+	tile( zeros( [ 2, 2 ], { 'dtype': 'complex64' } ), [ 2, 2 ] ); // $ExpectType complex64ndarray
+	tile( zeros( [ 2, 2 ], { 'dtype': 'int32' } ), [ 2, 2 ] ); // $ExpectType int32ndarray
+	tile( zeros( [ 2, 2 ], { 'dtype': 'int16' } ), [ 2, 2 ] ); // $ExpectType int16ndarray
+	tile( zeros( [ 2, 2 ], { 'dtype': 'int8' } ), [ 2, 2 ] ); // $ExpectType int8ndarray
+	tile( zeros( [ 2, 2 ], { 'dtype': 'uint32' } ), [ 2, 2 ] ); // $ExpectType uint32ndarray
+	tile( zeros( [ 2, 2 ], { 'dtype': 'uint16' } ), [ 2, 2 ] ); // $ExpectType uint16ndarray
+	tile( zeros( [ 2, 2 ], { 'dtype': 'uint8' } ), [ 2, 2 ] ); // $ExpectType uint8ndarray
+	tile( zeros( [ 2, 2 ], { 'dtype': 'uint8c' } ), [ 2, 2 ] ); // $ExpectType uint8cndarray
+	tile( zeros( [ 2, 2 ], { 'dtype': 'generic' } ), [ 2, 2 ] ); // $ExpectType genericndarray<number>
 }
 
 // The compiler throws an error if the function is not provided a first argument which is an ndarray...
@@ -72,7 +56,9 @@ function array(): ndarray {
 
 // The compiler throws an error if the function is not provided a second argument which is an array-like object containing numbers...
 {
-	const x = array();
+	const x = zeros( [ 2, 2 ], {
+		'dtype': 'float64'
+	});
 
 	tile( x, '5' ); // $ExpectError
 	tile( x, 5 ); // $ExpectError
@@ -86,7 +72,9 @@ function array(): ndarray {
 
 // The compiler throws an error if the function is provided an unsupported number of arguments...
 {
-	const x = array();
+	const x = zeros( [ 2, 2 ], {
+		'dtype': 'float64'
+	});
 
 	tile(); // $ExpectError
 	tile( x ); // $ExpectError

lib/node_modules/@stdlib/ndarray/base/tile/lib/main.js

@@ -32,6 +32,7 @@ var getOffset = require( '@stdlib/ndarray/base/offset' );
 var getOrder = require( '@stdlib/ndarray/base/order' );
 var getDType = require( '@stdlib/ndarray/base/dtype' );
 var getData = require( '@stdlib/ndarray/base/data-buffer' );
+var format = require( '@stdlib/string/format' );
 var zeros = require( '@stdlib/array/base/zeros' );
 
 
@@ -42,12 +43,12 @@ var zeros = require( '@stdlib/array/base/zeros' );
 *
 * ## Notes
 *
-* -   When the number of repetitions is less than the number of input dimensions, the number of repetitions is left-padded with ones until the number of repetitions matches the number of input dimensions. When the number of repetitions exceeds the number of input dimensions, the input array is treated as if singleton dimensions were prepended.
-* -   The output array has rank equal to the greater of the input array rank and the number of repetitions.
-* -   The function always returns a new ndarray having a newly allocated data buffer.
+* -   The number of repetitions must have at least as many elements as the number of input dimensions. When the number of repetitions exceeds the number of input dimensions, the input array is treated as if singleton dimensions were prepended.
+* -   The function always copies data to a new ndarray.
 *
 * @param {ndarray} x - input array
 * @param {NonNegativeIntegerArray} reps - number of repetitions along each dimension
+* @throws {RangeError} second argument must have at least as many elements as the number of input dimensions
 * @returns {ndarray} output array
 *
 * @example
@@ -66,64 +67,63 @@ function tile( x, reps ) {
 	var sho;
 	var shi;
 	var sto;
-	var ord;
 	var buf;
 	var out;
-	var Dr;
 	var Ds;
 	var si;
 	var sx;
 	var v1;
 	var v2;
-	var K;
 	var L;
 	var M;
 	var N;
-	var r;
+	var o;
 	var s;
 	var t;
 	var i;
+	var j;
 
 	shx = getShape( x, false );
 	sx = getStrides( x, false );
 	dtype = getDType( x );
 	N = reps.length;
 	M = shx.length;
 
-	// Determine the output rank, which is the greater of the number of input dimensions and the number of repetitions. Compute the implicit left-padding amounts for the repetitions and input shape, respectively...
-	K = ( N > M ) ? N : M;
-	Dr = K - N;
-	Ds = K - M;
+	if ( N < M ) {
+		throw new RangeError( format( 'invalid argument. Second argument must have at least as many elements as the number of dimensions of the first argument. Number of input dimensions: `%u`. Number of repetitions: `%u`.', M, N ) );
+	}
+	// Compute the implicit left-padding amount for the input shape:
+	Ds = N - M;
 
-	// Infer the storage order from the input strides, falling back to the stated order when the input is non-contiguous...
-	ord = strides2order( sx );
-	if ( ord === 2 ) {
-		order = 'column-major';
-	} else if ( ord === 1 || ord === 3 ) {
+	o = strides2order( sx );
+	if ( o === 0 || o === 3 ) {
+		// Fallback to stated layout when unable to infer the underlying physical layout:
+		order = getOrder( x );
+	} else if ( o === 1 ) {
 		order = 'row-major';
 	} else {
-		order = getOrder( x );
+		order = 'column-major';
 	}
-	// Compute an interleaved 2K-D shape and strides for broadcasting the input, along with the final K-D output shape. By inserting a repetition axis next to each original axis, a contiguous 2K-D buffer can be reinterpreted as the K-D tiled output without an additional copy...
-	shi = zeros( 2*K );
-	si = zeros( 2*K );
-	sho = zeros( K );
-	for ( i = 0; i < K; i++ ) {
-		r = ( i < Dr ) ? 1 : reps[ i - Dr ];
-		s = ( i < Ds ) ? 1 : shx[ i - Ds ];
-		t = ( i < Ds ) ? 0 : sx[ i - Ds ];
-		sho[ i ] = r * s;
+	// Compute an interleaved 2N-D shape and strides for broadcasting the input, along with the final N-D output shape. By inserting a repetition axis next to each original axis, a contiguous 2N-D buffer can be reinterpreted as the N-D tiled output without an additional copy...
+	shi = zeros( 2*N );
+	si = zeros( 2*N );
+	sho = zeros( N );
+	for ( i = 0; i < N; i++ ) {
+		j = i - Ds;
+		s = ( j < 0 ) ? 1 : shx[ j ];
+		t = ( j < 0 ) ? 0 : sx[ j ];
+		sho[ i ] = reps[ i ] * s;
 		if ( order === 'row-major' ) {
-			shi[ 2*i ] = r;
+			shi[ 2*i ] = reps[ i ];
 			shi[ (2*i)+1 ] = s;
 			si[ (2*i)+1 ] = t;
 		} else {
 			shi[ 2*i ] = s;
-			shi[ (2*i)+1 ] = r;
+			shi[ (2*i)+1 ] = reps[ i ];
 			si[ 2*i ] = t;
 		}
 	}
-	if ( K > 0 ) {
+	if ( N > 0 ) {
 		L = numel( sho );
 		sto = shape2strides( sho, order );
 	} else {
@@ -133,7 +133,7 @@ function tile( x, reps ) {
 	buf = buffer( dtype, L );
 	out = new x.constructor( dtype, buf, sho, sto, 0, order );
 
-	// Assign the broadcasted input to a 2K-D view over the output data buffer...
+	// Assign the broadcasted input to a 2N-D view over the output data buffer...
 	v1 = ndarray( dtype, getData( x ), shi, si, getOffset( x ), order );
 	v2 = ndarray( dtype, buf, shi, shape2strides( shi, order ), 0, order );
 	assign( [ v1, v2 ] );