Auto-generated commit

Author: stdlib-bot

CHANGELOG.md

@@ -10,6 +10,11 @@
 
 ### Features
 
+-   [`4b6bce8`](https://github.com/stdlib-js/stdlib/commit/4b6bce89254cfbbe7a008167ce7b4eccceaaea7e) - add support for non-string data types
+-   [`55e56f0`](https://github.com/stdlib-js/stdlib/commit/55e56f0b239268c250b9e64d46f5914d24229e1b) - add support for non-string data types
+-   [`a74c0e2`](https://github.com/stdlib-js/stdlib/commit/a74c0e2e7efd0b76b251d895f43d5c197512ba2b) - add support for non-string data types
+-   [`6dd3bf6`](https://github.com/stdlib-js/stdlib/commit/6dd3bf6252e3808803c6a5ea00925247b592bd01) - add support for non-string data types
+-   [`96ea877`](https://github.com/stdlib-js/stdlib/commit/96ea8778698f2979de10ac6d62d91b0d6bd65cae) - add support for struct and data type objects
 -   [`25164a7`](https://github.com/stdlib-js/stdlib/commit/25164a7ae8ac5285255e2d8097f3e123d9db3a38) - add support for non-string data types
 -   [`c6ce94c`](https://github.com/stdlib-js/stdlib/commit/c6ce94c5cf69a183cbe369a56411192d8d99abe1) - add support for non-string data types
 -   [`360ed63`](https://github.com/stdlib-js/stdlib/commit/360ed63a0e83c2cc4261df2b6075e1cc2c8f5dec) - add support for non-string data tpes
@@ -566,6 +571,13 @@ A total of 24 issues were closed in this release:
 
 <details>
 
+-   [`4b6bce8`](https://github.com/stdlib-js/stdlib/commit/4b6bce89254cfbbe7a008167ce7b4eccceaaea7e) - **feat:** add support for non-string data types _(by Athan Reines)_
+-   [`55e56f0`](https://github.com/stdlib-js/stdlib/commit/55e56f0b239268c250b9e64d46f5914d24229e1b) - **feat:** add support for non-string data types _(by Athan Reines)_
+-   [`a74c0e2`](https://github.com/stdlib-js/stdlib/commit/a74c0e2e7efd0b76b251d895f43d5c197512ba2b) - **feat:** add support for non-string data types _(by Athan Reines)_
+-   [`2d8848b`](https://github.com/stdlib-js/stdlib/commit/2d8848b0a7e94aca604317a6d1e83b110d82f143) - **docs:** add comment _(by Athan Reines)_
+-   [`6dd3bf6`](https://github.com/stdlib-js/stdlib/commit/6dd3bf6252e3808803c6a5ea00925247b592bd01) - **feat:** add support for non-string data types _(by Athan Reines)_
+-   [`96ea877`](https://github.com/stdlib-js/stdlib/commit/96ea8778698f2979de10ac6d62d91b0d6bd65cae) - **feat:** add support for struct and data type objects _(by Athan Reines)_
+-   [`7b1d601`](https://github.com/stdlib-js/stdlib/commit/7b1d6010a2b93231101815666acb7620185b650a) - **refactor:** use assertion utility _(by Athan Reines)_
 -   [`25164a7`](https://github.com/stdlib-js/stdlib/commit/25164a7ae8ac5285255e2d8097f3e123d9db3a38) - **feat:** add support for non-string data types _(by Athan Reines)_
 -   [`c6ce94c`](https://github.com/stdlib-js/stdlib/commit/c6ce94c5cf69a183cbe369a56411192d8d99abe1) - **feat:** add support for non-string data types _(by Athan Reines)_
 -   [`360ed63`](https://github.com/stdlib-js/stdlib/commit/360ed63a0e83c2cc4261df2b6075e1cc2c8f5dec) - **feat:** add support for non-string data tpes _(by Athan Reines)_

base/assert/is-mostly-safe-data-type-cast/README.md

@@ -42,7 +42,7 @@ var isMostlySafeCast = require( '@stdlib/ndarray/base/assert/is-mostly-safe-data
 
 #### isMostlySafeCast( from, to )
 
-Returns a `boolean` indicating whether an ndarray [data type][@stdlib/ndarray/dtypes] can be safely cast or, for floating-point data types, downcast to another ndarray [data type][@stdlib/ndarray/dtypes].
+Returns a boolean indicating whether an ndarray [data type][@stdlib/ndarray/dtypes] can be safely cast or, for floating-point data types, downcast to another ndarray [data type][@stdlib/ndarray/dtypes].
 
 ```javascript
 var bool = isMostlySafeCast( 'float32', 'float64' );

base/assert/is-mostly-safe-data-type-cast/docs/repl.txt

@@ -6,11 +6,11 @@
 
     Parameters
     ----------
-    from: string
-        ndarray data type.
+    from: string|DataType
+        Data type to cast from.
 
-    to: string
-        ndarray data type.
+    to: string|DataType
+        Data type to cast to.
 
     Returns
     -------

base/assert/is-mostly-safe-data-type-cast/docs/types/index.d.ts

@@ -18,6 +18,10 @@
 
 // TypeScript Version: 4.1
 
+/// <reference types="@stdlib/types"/>
+
+import { DataType } from '@stdlib/types/ndarray';
+
 /**
 * Returns a boolean indicating if a provided ndarray data type can be safely cast or, for floating-point data types, downcast to another ndarray data type.
 *
@@ -32,7 +36,7 @@
 * bool = isMostlySafeCast( 'float64', 'int32' );
 * // returns false
 */
-declare function isMostlySafeCast( from: string, to: string ): boolean;
+declare function isMostlySafeCast( from: DataType, to: DataType ): boolean;
 
 
 // EXPORTS //

base/assert/is-mostly-safe-data-type-cast/lib/main.js

@@ -21,6 +21,7 @@
 // MODULES //
 
 var casts = require( './../../../../mostly-safe-casts' );
+var resolveStr = require( './../../../../base/dtype-resolve-str' );
 
 
 // VARIABLES //
@@ -33,8 +34,8 @@ var TABLE = casts();
 /**
 * Returns a boolean indicating if a provided ndarray data type can be safely cast or, for floating-point data types, downcast to another ndarray data type.
 *
-* @param {string} from - ndarray data type
-* @param {string} to - ndarray data type
+* @param {*} from - ndarray data type
+* @param {*} to - ndarray data type
 * @returns {boolean} boolean indicating if a data type can be cast to another data type
 *
 * @example
@@ -45,10 +46,17 @@ var TABLE = casts();
 * // returns false
 */
 function isMostlySafeCast( from, to ) {
-	if ( from === to ) {
+	var t;
+	from = resolveStr( from );
+	to = resolveStr( to );
+	if ( from === to ) { // note: for "struct" data types, require strict equality to be considered a "mostly" safe cast
 		return true;
 	}
-	return ( TABLE[ from ][ to ] > 0 );
+	t = TABLE[ from ];
+	if ( t ) {
+		return t[ to ] > 0;
+	}
+	return false;
 }
 
 

base/assert/is-mostly-safe-data-type-cast/test/test.js

@@ -16,13 +16,18 @@
 * limitations under the License.
 */
 
+/* eslint-disable max-len */
+
 'use strict';
 
 // MODULES //
 
 var tape = require( 'tape' );
+var DataType = require( './../../../../dtype-ctor' );
+var structFactory = require( '@stdlib/dstructs/struct' );
 var dtypes = require( './../../../../dtypes' );
 var casts = require( './../../../../mostly-safe-casts' );
+var str2enum = require( './../../../../base/dtype-str2enum' );
 var isMostlySafeCast = require( './../lib' );
 
 
@@ -40,7 +45,7 @@ tape( 'main export is a function', function test( t ) {
 	t.end();
 });
 
-tape( 'the function returns a boolean indicating if an ndarray data type can be cast to another ndarray data type', function test( t ) {
+tape( 'the function returns a boolean indicating if an ndarray data type can be cast to another ndarray data type (strings)', function test( t ) {
 	var expected;
 	var actual;
 	var dt;
@@ -57,3 +62,113 @@ tape( 'the function returns a boolean indicating if an ndarray data type can be
 	}
 	t.end();
 });
+
+tape( 'the function returns a boolean indicating if an ndarray data type can be cast to another ndarray data type (enums)', function test( t ) {
+	var expected;
+	var actual;
+	var dt;
+	var i;
+	var j;
+
+	for ( i = 0; i < DTYPES.length; i++ ) {
+		dt = DTYPES[ i ];
+		for ( j = 0; j < DTYPES.length; j++ ) {
+			expected = ( CASTS[ dt ][ DTYPES[j] ] > 0 );
+			actual = isMostlySafeCast( str2enum( dt ), str2enum( DTYPES[ j ] ) );
+			t.strictEqual( actual, expected, 'returns expected value. from: '+dt+'. to: '+DTYPES[j]+'.' );
+		}
+	}
+	t.end();
+});
+
+tape( 'the function returns a boolean indicating if an ndarray data type can be cast to another ndarray data type (data type, strings)', function test( t ) {
+	var expected;
+	var actual;
+	var dt;
+	var i;
+	var j;
+
+	for ( i = 0; i < DTYPES.length; i++ ) {
+		dt = DTYPES[ i ];
+		for ( j = 0; j < DTYPES.length; j++ ) {
+			expected = ( CASTS[ dt ][ DTYPES[j] ] > 0 );
+			actual = isMostlySafeCast( new DataType( dt ), new DataType( DTYPES[ j ] ) );
+			t.strictEqual( actual, expected, 'returns expected value. from: '+dt+'. to: '+DTYPES[j]+'.' );
+		}
+	}
+	t.end();
+});
+
+tape( 'the function returns a boolean indicating if an ndarray data type can be cast to another ndarray data type (struct)', function test( t ) {
+	var schemas;
+	var values;
+	var actual;
+	var dt;
+	var i;
+
+	schemas = [
+		[
+			{
+				'name': 'foo',
+				'type': 'float64'
+			}
+		],
+		[
+			{
+				'name': 'bar',
+				'type': 'float32'
+			}
+		]
+	];
+	values = [
+		structFactory( schemas[ 0 ] ),
+		structFactory( schemas[ 1 ] )
+	];
+
+	for ( i = 0; i < values.length; i++ ) {
+		dt = values[ i ];
+		actual = isMostlySafeCast( dt, dt );
+		t.strictEqual( actual, true, 'returns expected value. from: '+dt.layout+'. to: '+dt.layout+'.' );
+	}
+	actual = isMostlySafeCast( values[ 0 ], values[ 1 ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function returns a boolean indicating if an ndarray data type can be cast to another ndarray data type (data type, struct)', function test( t ) {
+	var schemas;
+	var values;
+	var actual;
+	var dt;
+	var i;
+
+	schemas = [
+		[
+			{
+				'name': 'foo',
+				'type': 'float64'
+			}
+		],
+		[
+			{
+				'name': 'bar',
+				'type': 'float32'
+			}
+		]
+	];
+	values = [
+		structFactory( schemas[ 0 ] ),
+		structFactory( schemas[ 1 ] )
+	];
+
+	for ( i = 0; i < values.length; i++ ) {
+		dt = values[ i ];
+		actual = isMostlySafeCast( new DataType( dt ), new DataType( dt ) );
+		t.strictEqual( actual, true, 'returns expected value. from: '+dt.layout+'. to: '+dt.layout+'.' );
+	}
+	actual = isMostlySafeCast( new DataType( values[ 0 ] ), new DataType( values[ 1 ] ) );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	t.end();
+});

base/assert/is-numeric-data-type/README.md

@@ -42,7 +42,7 @@ var isNumericDataType = require( '@stdlib/ndarray/base/assert/is-numeric-data-ty
 
 #### isNumericDataType( value )
 
-Tests if an input `value` is a supported ndarray numeric data type.
+Tests if an input value is a supported ndarray numeric data type.
 
 ```javascript
 var bool = isNumericDataType( 'float32' );

base/assert/is-numeric-data-type/lib/main.js

@@ -24,13 +24,16 @@ var contains = require( '@stdlib/array/base/assert/contains' ).factory;
 var dtypes = require( './../../../../dtypes' );
 
 
+// VARIABLES //
+
+var isDataType = contains( dtypes( 'numeric' ) );
+
+
 // MAIN //
 
 /**
 * Tests whether an input value is a supported ndarray numeric data type.
 *
-* @name isNumericDataType
-* @type {Function}
 * @param {*} v - value to test
 * @returns {boolean} boolean indicating whether an input value is a supported ndarray numeric data type
 *
@@ -71,7 +74,9 @@ var dtypes = require( './../../../../dtypes' );
 * bool = isNumericDataType( 'foo' );
 * // returns false
 */
-var isNumericDataType = contains( dtypes( 'numeric' ) );
+function isNumericDataType( v ) {
+	return isDataType( String( v ) );
+}
 
 
 // EXPORTS //

base/assert/is-numeric-data-type/test/test.js

@@ -21,6 +21,7 @@
 // MODULES //
 
 var tape = require( 'tape' );
+var DataType = require( './../../../../dtype-ctor' );
 var isNumericDataType = require( './../lib' );
 
 
@@ -48,7 +49,19 @@ tape( 'the function returns `true` if provided a supported ndarray numeric data
 		'uint8c',
 		'int16',
 		'int32',
-		'int8'
+		'int8',
+
+		new DataType( 'complex64' ),
+		new DataType( 'complex128' ),
+		new DataType( 'float32' ),
+		new DataType( 'float64' ),
+		new DataType( 'uint16' ),
+		new DataType( 'uint32' ),
+		new DataType( 'uint8' ),
+		new DataType( 'uint8c' ),
+		new DataType( 'int16' ),
+		new DataType( 'int32' ),
+		new DataType( 'int8' )
 	];
 	for ( i = 0; i < values.length; i++ ) {
 		bool = isNumericDataType( values[ i ] );
@@ -67,6 +80,8 @@ tape( 'the function returns `false` if not provided a supported ndarray numeric
 		'binary',
 		'generic',
 
+		new DataType( 'binary' ),
+
 		// Unsupported dtypes:
 		'float',
 		'int',

base/assert/is-real-data-type/README.md

@@ -42,7 +42,7 @@ var isRealDataType = require( '@stdlib/ndarray/base/assert/is-real-data-type' );
 
 #### isRealDataType( value )
 
-Tests if an input `value` is a supported ndarray real-valued data type.
+Tests if an input value is a supported ndarray real-valued data type.
 
 ```javascript
 var bool = isRealDataType( 'float32' );