refactor: accommodate known array types for increased performance

---
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: na
  - task: lint_package_json
    status: na
  - task: lint_repl_help
    status: na
  - task: lint_javascript_src
    status: passed
  - task: lint_javascript_cli
    status: na
  - task: lint_javascript_examples
    status: na
  - task: lint_javascript_tests
    status: na
  - 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: na
  - task: lint_typescript_tests
    status: na
  - task: lint_license_headers
    status: passed
---

Author: kgryte

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

@@ -22,11 +22,16 @@
 
 var isComplexDataType = require( '@stdlib/ndarray/base/assert/is-complex-floating-point-data-type' );
 var isRealDataType = require( '@stdlib/ndarray/base/assert/is-real-data-type' );
+var isComplexArray = require( '@stdlib/array/base/assert/is-complex-typed-array' );
+var isBooleanArray = require( '@stdlib/array/base/assert/is-booleanarray' );
 var iterationOrder = require( '@stdlib/ndarray/base/iteration-order' );
 var castReturn = require( '@stdlib/complex/base/cast-return' );
 var complexCtors = require( '@stdlib/complex/ctors' );
 var minmaxViewBufferIndex = require( '@stdlib/ndarray/base/minmax-view-buffer-index' );
 var ndarray2object = require( '@stdlib/ndarray/base/ndarraylike2object' );
+var reinterpretComplex = require( '@stdlib/strided/base/reinterpret-complex' );
+var reinterpretBoolean = require( '@stdlib/strided/base/reinterpret-boolean' );
+var gscal = require( '@stdlib/blas/base/gscal' );
 var blockedaccessorassign2d = require( './2d_blocked_accessors.js' );
 var blockedaccessorassign3d = require( './3d_blocked_accessors.js' );
 var blockedaccessorassign4d = require( './4d_blocked_accessors.js' );
@@ -123,6 +128,57 @@ var BLOCKED_ACCESSOR_ASSIGN = [
 ];
 var MAX_DIMS = ASSIGN.length - 1;
 
+// TODO: consider adding a package utility for mapping a complex dtype to its complementary real-valued counterpart
+var COMPLEX_TO_REAL = { // WARNING: this table needs to be manually updated if we add support for additional complex number dtypes
+	'complex128': 'float64',
+	'complex64': 'float32'
+};
+
+
+// FUNCTIONS //
+
+/**
+* Converts a boolean ndarray to an 8-bit unsigned integer ndarray.
+*
+* ## Notes
+*
+* -   The function mutates the input ndarray object.
+*
+* @private
+* @param {Object} x - input ndarray object
+* @returns {Object} output ndarray object
+*/
+function boolean2uint8( x ) {
+	x.data = reinterpretBoolean( x.data, 0 );
+	x.accessorProtocol = false;
+	return x;
+}
+
+/**
+* Converts a complex-valued floating-point ndarray to a real-valued floating-point ndarray.
+*
+* ## Notes
+*
+* -   The function mutates the input ndarray object.
+*
+* @private
+* @param {Object} x - input ndarray object
+* @returns {Object} output ndarray object
+*/
+function complex2real( x ) {
+	x.data = reinterpretComplex( x.data, 0 );
+	x.accessorProtocol = false;
+	x.dtype = COMPLEX_TO_REAL[ x.dtype ];
+	x.strides = gscal( x.shape.length, 2, x.strides, 1 );
+	x.offset *= 2;
+
+	// Append a trailing dimension where each element is the real and imaginary component for a corresponding element in the original input ndarray (note: this means that a two-dimensional complex-valued ndarray becomes a three-dimensional real-valued ndarray; while this does entail additional loop overhead, it is still significantly faster than sending complex-valued ndarrays down the accessor path):
+	x.shape.push( 2 ); // real and imaginary components
+	x.strides.push( 1 ); // real and imaginary components are assumed to be adjacent in memory
+
+	return x;
+}
+
 
 // MAIN //
 
@@ -210,8 +266,16 @@ function assign( arrays ) {
 	x = ndarray2object( arrays[ 0 ] );
 	y = ndarray2object( arrays[ 1 ] );
 
+	// Check for known array types which can be reinterpreted for better iteration performance...
+	if ( isBooleanArray( x.data ) && isBooleanArray( y.data ) ) {
+		x = boolean2uint8( x );
+		y = boolean2uint8( y );
+	} else if ( isComplexArray( x.data ) && isComplexArray( y.data ) ) {
+		x = complex2real( x );
+		y = complex2real( y );
+	}
 	// Determine whether we are casting a real data type to a complex data type and we need to use a specialized accessor (note: we don't support the other way, complex-to-real, as this is not an allowed (mostly) safe cast)...
-	if ( isRealDataType( x.dtype ) && isComplexDataType( y.dtype ) ) {
+	else if ( isRealDataType( x.dtype ) && isComplexDataType( y.dtype ) ) {
 		x.accessorProtocol = true;
 		x.accessors[ 0 ] = castReturn( x.accessors[ 0 ], 2, complexCtors( y.dtype ) ); // eslint-disable-line max-len
 	}