feat: add float16 dtype support to array/min-dtype

lib/node_modules/@stdlib/array/min-dtype/README.md

@@ -46,7 +46,7 @@ Returns the minimum array [data type][@stdlib/array/dtypes] of the closest "kind
 
 ```javascript
 var dt = minDataType( 3.141592653589793 );
-// returns 'float32'
+// returns 'float16'
 
 dt = minDataType( -3 );
 // returns 'int8'

lib/node_modules/@stdlib/array/min-dtype/docs/repl.txt

@@ -21,7 +21,7 @@
     Examples
     --------
     > var dt = {{alias}}( 3.141592653589793 )
-    'float32'
+    'float16'
     > dt = {{alias}}( 3 )
     'uint8'
     > dt = {{alias}}( -3 )

lib/node_modules/@stdlib/array/min-dtype/docs/types/index.d.ts

@@ -35,7 +35,7 @@
 *
 * @example
 * var dt = minDataType( 3.141592653589793 );
-* // returns 'float32'
+* // returns 'float16'
 *
 * @example
 * var dt = minDataType( 3 );
@@ -89,7 +89,7 @@
 * var dt = minDataType( 'beep' );
 * // returns 'generic'
 */
 declare function minDataType( value: any ): 'generic';
 
 
 // EXPORTS //

lib/node_modules/@stdlib/array/min-dtype/lib/index.js

@@ -27,7 +27,7 @@
 * var minDataType = require( '@stdlib/array/min-dtype' );
 *
 * var dt = minDataType( 3.141592653589793 );
-* // returns 'float32'
+* // returns 'float16'
 *
 * dt = minDataType( 3 );
 * // returns 'uint8'

lib/node_modules/@stdlib/array/min-dtype/lib/main.js

@@ -27,6 +27,10 @@ var isNegativeZero = require( '@stdlib/math/base/assert/is-negative-zero' );
 var isComplexLike = require( '@stdlib/assert/is-complex-like' );
 var PINF = require( '@stdlib/constants/float64/pinf' );
 var NINF = require( '@stdlib/constants/float64/ninf' );
+var FLOAT16_SMALLEST_SUBNORMAL = require( '@stdlib/constants/float16/smallest-subnormal' ); // eslint-disable-line id-length
+var FLOAT16_MAX_SAFE_INTEGER = require( '@stdlib/constants/float16/max-safe-integer' );
+var FLOAT16_MIN_SAFE_INTEGER = require( '@stdlib/constants/float16/min-safe-integer' );
+var FLOAT16_MAX = require( '@stdlib/constants/float16/max' );
 var FLOAT32_SMALLEST_SUBNORMAL = require( '@stdlib/constants/float32/smallest-subnormal' ); // eslint-disable-line id-length
 var FLOAT32_MAX_SAFE_INTEGER = require( '@stdlib/constants/float32/max-safe-integer' );
 var FLOAT32_MIN_SAFE_INTEGER = require( '@stdlib/constants/float32/min-safe-integer' );
@@ -49,20 +53,38 @@ var UINT32_MAX = require( '@stdlib/constants/uint32/max' );
 */
 function minFloatDataType( value ) {
 	if ( value !== value || value === PINF || value === NINF ) {
-		return 'float32';
+		return 'float16';
 	}
 	if ( isInteger( value ) ) {
-		if ( value >= FLOAT32_MIN_SAFE_INTEGER && value <= FLOAT32_MAX_SAFE_INTEGER ) { // eslint-disable-line max-len
+		if (
+			value >= FLOAT16_MIN_SAFE_INTEGER &&
+			value <= FLOAT16_MAX_SAFE_INTEGER
+		) {
+			return 'float16';
+		}
+		if (
+			value >= FLOAT32_MIN_SAFE_INTEGER &&
+			value <= FLOAT32_MAX_SAFE_INTEGER
+		) {
 			return 'float32';
 		}
 		return 'float64';
 	}
-	// Assume that if we are provided a tiny value, we don't want to underflow to zero by storing as `float32`...
+	// Assume that if we are provided a tiny value, we don't want to underflow to zero by storing in a smaller precision...
 	if (
-		value > -FLOAT32_SMALLEST_SUBNORMAL &&
-		value < FLOAT32_SMALLEST_SUBNORMAL
+		value > -FLOAT16_SMALLEST_SUBNORMAL &&
+		value < FLOAT16_SMALLEST_SUBNORMAL
 	) {
-		return 'float64';
+		if (
+			value > -FLOAT32_SMALLEST_SUBNORMAL &&
+			value < FLOAT32_SMALLEST_SUBNORMAL
+		) {
+			return 'float64';
+		}
+		return 'float32';
+	}
+	if ( value >= -FLOAT16_MAX && value <= FLOAT16_MAX ) {
+		return 'float16';
 	}
 	// Any number which reaches this point is less than the maximum single-precision floating-point number, as floating-point format supports a limited number of decimals (e.g., (1.0+EPS)*10**15 => 1000000000000000.2, which is less than ~3.4e38)...
 	return 'float32';
@@ -79,7 +101,7 @@ function minFloatDataType( value ) {
 *
 * @example
 * var dt = minDataType( 3.141592653589793 );
-* // returns 'float32'
+* // returns 'float16'
 *
 * @example
 * var dt = minDataType( 3 );
@@ -99,11 +121,11 @@ function minDataType( value ) {
 		return 'generic';
 	}
 	if ( value !== value || value === PINF || value === NINF ) {
-		return 'float32';
+		return 'float16';
 	}
 	if ( isInteger( value ) ) {
 		if ( value === 0 && isNegativeZero( value ) ) {
-			return 'float32';
+			return 'float16';
 		}
 		if ( value < 0 ) {
 			if ( value >= INT8_MIN ) {
@@ -128,12 +150,21 @@ function minDataType( value ) {
 		}
 		return 'float64';
 	}
-	// Assume that if we are provided a tiny value, we don't want to underflow to zero by storing as `float32`...
+	// Assume that if we are provided a tiny value, we don't want to underflow to zero by storing in a smaller precision...
 	if (
-		value > -FLOAT32_SMALLEST_SUBNORMAL &&
-		value < FLOAT32_SMALLEST_SUBNORMAL
+		value > -FLOAT16_SMALLEST_SUBNORMAL &&
+		value < FLOAT16_SMALLEST_SUBNORMAL
 	) {
-		return 'float64';
+		if (
+			value > -FLOAT32_SMALLEST_SUBNORMAL &&
+			value < FLOAT32_SMALLEST_SUBNORMAL
+		) {
+			return 'float64';
+		}
+		return 'float32';
+	}
+	if ( value >= -FLOAT16_MAX && value <= FLOAT16_MAX ) {
+		return 'float16';
 	}
 	// Any number which reaches this point is less than the maximum single-precision floating-point number, as floating-point format supports a limited number of decimals (e.g., (1.0+EPS)*10**15 => 1000000000000000.2, which is less than ~3.4e38)...
 	return 'float32';

lib/node_modules/@stdlib/array/min-dtype/test/test.js

@@ -36,7 +36,7 @@ tape( 'main export is a function', function test( t ) {
 	t.end();
 });
 
-tape( 'the function returns the minimum array data type of the closest "kind" necessary for storing a provided scalar value', function test( t ) {
+tape( 'the function returns the minimum array data type of the closest "kind" necessary for storing a provided real scalar value', function test( t ) {
 	var expected;
 	var actual;
 	var values;
@@ -57,8 +57,14 @@ tape( 'the function returns the minimum array data type of the closest "kind" ne
 		-4294967297,
 		3.14,
 		-3.14,
+		70000.5,
+		-70000.5,
+		1.0e20, // >10**5
+		-1.0e20,
 		1.0e40, // >10**38
 		-1.0e40,
+		-1.0e-10, // <10**-7
+		1.0e-10,
 		-1.0e-46, // <10**-45
 		1.0e-46,
 		PINF,
@@ -67,7 +73,55 @@ tape( 'the function returns the minimum array data type of the closest "kind" ne
 		{},
 		true,
 		false,
-		[],
+		[]
+	];
+	expected = [
+		'float16',
+		'uint8',
+		'uint8',
+		'float16',
+		'uint8',
+		'int8',
+		'uint16',
+		'int16',
+		'uint32',
+		'int32',
+		'float64',
+		'float64',
+		'float16',
+		'float16',
+		'float32',
+		'float32',
+		'float64',
+		'float64',
+		'float64',
+		'float64',
+		'float32',
+		'float32',
+		'float64',
+		'float64',
+		'float16',
+		'float16',
+		'generic',
+		'generic',
+		'bool',
+		'bool',
+		'generic'
+	];
+	for ( i = 0; i < values.length; i++ ) {
+		actual = minDataType( values[i] );
+		t.strictEqual( actual, expected[ i ], 'returns expected value when provided '+values[i] );
+	}
+	t.end();
+});
+
+tape( 'the function returns the minimum array data type of the closest "kind" necessary for storing a provided complex number or other value', function test( t ) {
+	var expected;
+	var actual;
+	var values;
+	var i;
+
+	values = [
 		new Complex64( 3.0, 5.0 ),
 		new Complex128( 3.0, 5.0 ),
 		new Complex64( 1.0, 1.0 ),
@@ -94,6 +148,22 @@ tape( 'the function returns the minimum array data type of the closest "kind" ne
 		new Complex128( 1.0e40, 1.0 ),
 		new Complex128( 1.0, -1.0e40 ),
 		new Complex128( 1.0, 1.0e40 ),
+		new Complex128( -1.0e10, 1.0 ),
+		new Complex128( 1.0e10, 1.0 ),
+		new Complex128( 1.0, -1.0e10 ),
+		new Complex128( 1.0, 1.0e10 ),
+		new Complex128( -1.0e-10, 1.0 ),
+		new Complex128( 1.0e-10, 1.0 ),
+		new Complex128( 1.0, -1.0e-10 ),
+		new Complex128( 1.0, 1.0e-10 ),
+		new Complex128( -70000.5, 1.0 ),
+		new Complex128( 70000.5, 1.0 ),
+		new Complex128( 1.0, -70000.5 ),
+		new Complex128( 1.0, 70000.5 ),
+		new Complex128( -30000.0, 1.0 ),
+		new Complex128( 30000.0, 1.0 ),
+		new Complex128( 1.0, -30000.0 ),
+		new Complex128( 1.0, 30000.0 ),
 
 		{
 			're': 3.0,
@@ -154,34 +224,17 @@ tape( 'the function returns the minimum array data type of the closest "kind" ne
 		{
 			're': 3.0,
 			'im': 3.14
+		},
+		{
+			're': 70000.5,
+			'im': 5.0
+		},
+		{
+			're': 3.0,
+			'im': 70000.5
 		}
 	];
 	expected = [
-		'float32',
-		'uint8',
-		'uint8',
-		'float32',
-		'uint8',
-		'int8',
-		'uint16',
-		'int16',
-		'uint32',
-		'int32',
-		'float64',
-		'float64',
-		'float32',
-		'float32',
-		'float64',
-		'float64',
-		'float64',
-		'float64',
-		'float32',
-		'float32',
-		'generic',
-		'generic',
-		'bool',
-		'bool',
-		'generic',
 		'complex64',
 		'complex64',
 		'complex64',
@@ -208,6 +261,22 @@ tape( 'the function returns the minimum array data type of the closest "kind" ne
 		'complex128',
 		'complex128',
 		'complex128',
+		'complex128',
+		'complex128',
+		'complex128',
+		'complex128',
+		'complex64',
+		'complex64',
+		'complex64',
+		'complex64',
+		'complex64',
+		'complex64',
+		'complex64',
+		'complex64',
+		'complex64',
+		'complex64',
+		'complex64',
+		'complex64',
 
 		'complex64',
 		'complex128',
@@ -223,8 +292,9 @@ tape( 'the function returns the minimum array data type of the closest "kind" ne
 		'complex64',
 		'complex64',
 		'complex64',
+		'complex64',
+		'complex64',
 		'complex64'
-
 	];
 	for ( i = 0; i < values.length; i++ ) {
 		actual = minDataType( values[i] );