Auto-generated commit

Author: stdlib-bot

.github/.keepalive

@@ -176,3 +176,8 @@ acs-*.bib
 #################
 .vscode/
 jsconfig.json
+
+# Sublime Text #
+################
+*.sublime-workspace
+*.sublime-project

.gitignore

@@ -25,6 +25,6 @@ Ricky Reusser <rsreusser@gmail.com>
 Ryan Seal <splrk@users.noreply.github.com>
 Seyyed Parsa Neshaei <spneshaei@users.noreply.github.com>
 Shraddheya Shendre <shendreshraddheya@gmail.com>
-Stephannie Jimenez Gacha <steff456@users.noreply.github.com>
+Stephannie Jiménez Gacha <steff456@hotmail.com>
 dorrin-sot <59933477+dorrin-sot@users.noreply.github.com>
 rei2hu <rei2hu@users.noreply.github.com>

CONTRIBUTORS

@@ -239,7 +239,7 @@ JAVASCRIPT_TEST ?= $(NODE_MODULES)/tape/bin/tape
 JAVASCRIPT_TEST_FLAGS ?=
 
 # Define the path to the executable for parsing TAP output:
-TAP_REPORTER ?= $(BIN_DIR)/tap-spec
+TAP_REPORTER ?= $(BIN_DIR)/tap-min
 
 # Define the path to the Istanbul executable:
 ISTANBUL ?= $(BIN_DIR)/istanbul

Makefile

@@ -62,7 +62,7 @@ var callbacks = require( '@stdlib/strided-base-binary-signature-callbacks' );
 
 #### callbacks( table, signatures )
 
-Assigns callbacks to binary interfaces according to type type [promotion rules][@stdlib/ndarray/promotion-rules].
+Assigns callbacks to binary interfaces according to type [promotion rules][@stdlib/ndarray/promotion-rules].
 
 ```javascript
 var signatures = require( '@stdlib/strided-base-binary-dtype-signatures' );
@@ -93,7 +93,7 @@ var list = callbacks( table, sigs );
 The function accepts the following arguments:
 
 -   **table**: callback table.
--   **signatures**: options.
+-   **signatures**: strided array containing binary interface signatures.
 
 A callback `table` should have the following properties:
 

README.md

@@ -29,7 +29,7 @@
     Examples
     --------
     > var dt = {{alias:@stdlib/strided/dtypes}}();
-    > var sigs = {{alias:@stdlib/strided/base/signatures}}( dt, dt, dt );
+    > var sigs = {{alias:@stdlib/strided/base/binary-dtype-signatures}}( dt, dt, dt );
     > var t = {
     ...     'default': {{alias:@stdlib/math/base/ops/add}},
     ...     'complex64': {{alias:@stdlib/math/base/ops/caddf}},

docs/repl.txt

@@ -52,26 +52,102 @@ var CTORS = {
 * @returns {Function} callback
 */
 function resolveCallback( table, t1, t2, t3 ) {
-	if ( t3 === C64 || t3 === C128 ) {
-		if ( t1 === t2 && t2 === t3 ) {
-			return table[ t3 ];
+	// The following branches attempt to follow type promotion rules; however, some accommodations are made for completeness...
+
+	// Signature: ??_z
+	if ( t3 === C128 ) {
+		// c?_z
+		if ( t1 === C64 ) {
+			// cz_z or cc_z
+			if ( t2 === C128 || t2 === C64 ) {
+				return table[ C128 ]; // Signature: cz_z_as_zz_z or cc_z_as_zz_z
+			}
+			// cd_z
+			return wrap( table[ C128 ], 2, CTORS[ C128 ] ); // Signature: cd_z_as_zz_z
+		}
+		// z?_z
+		if ( t1 === C128 ) {
+			// zz_z or zc_z
+			if ( t2 === C128 || t2 === C64 ) {
+				return table[ C128 ]; // Signature: zz_z or zc_z_as_zz_z
+			}
+			// zd_z
+			return wrap( table[ C128 ], 2, CTORS[ C128 ] ); // Signature: zd_z_as_zz_z
+		}
+		// dc_z, dz_z, or dd_z
+		return wrap( table[ C128 ], 2, CTORS[ C128 ] ); // Signature: dc_z_as_zz_z, dz_z_as_zz_z, or dd_z_as_zz_z
+	}
+	// Signature: ??_c
+	if ( t3 === C64 ) {
+		// z?_c
+		if ( t1 === C128 ) {
+			// zc_c or zz_c (note: according to type promotion rules `zz_c` should not happen, as `z` does not promote to `c`, but we accommodate here anyway)
+			if ( t2 === C64 || t2 === C128 ) {
+				return table[ C128 ]; // Signature: zc_c_as_zz_z or zz_c_as_zz_z
+			}
+			// zd_c (note: according to type promotion rules `zd_c` should not happen, as neither `z` nor `d` promote to `c`, but we accommodate here anyway)
+			return wrap( table[ C128 ], 2, CTORS[ C128 ] ); // Signature: zd_c_as_zz_z
+		}
+		// c?_c
+		if ( t1 === C64 ) {
+			// cz_c (note: according to type promotion rules `cz_c` should not happen, as `z` does not promote to `c`, but we accommodate here anyway)
+			if ( t2 === C128 ) {
+				return table[ C128 ]; // Signature: cz_c_as_zz_z
+			}
+			// cc_c
+			if ( t2 === C64 ) {
+				return table[ C64 ]; // Signature: cc_c
+			}
+			// cd_c (note: in JavaScript, real values are double-precision, but we downcast `d` to `c`, as, according to type promotion rules `cd_c` should not happen, as `d` does not promote to `c`, but `cf_c` can happen)
+			return wrap( table[ C64 ], 2, CTORS[ C64 ] ); // Signature: cd_c_as_cc_c (cf_c_as_cc_c)
+		}
+		// dz_c
+		if ( t2 === C128 ) {
+			// Note: according to type promotion rules `dz_c` should not happen, as neither `z` nor `d` promote to `c`, but we accommodate here anyway
+			return wrap( table[ C128 ], 2, CTORS[ C128 ] ); // Signature: zd_c_as_zz_z
+		}
+		// dc_c
+		if ( t2 === C64 ) {
+			// Note: in JavaScript, real values are double-precision, but we downcast `d` to `c`, as, according to type promotion rules `dc_c` should not happen, as `d` does not promote to `c`, but `fc_c` can happen
+			return wrap( table[ C64 ], 2, CTORS[ C64 ] ); // Signature: dc_c_as_cc_c (fc_c_as_cc_c)
 		}
-		return wrap( table[ t3 ], 2, CTORS[ t3 ] );
+		// dd_c (note: in JavaScript, real values are double-precision, but we downcast `d` to `c`, as, according to type promotion rules `dd_c` should not happen, as `d` does not promote to `c`, but `ff_c` can happen)
+		return wrap( table[ C64 ], 2, CTORS[ C64 ] ); // Signature: dd_c_as_cc_c (ff_c_as_cc_c)
 	}
+	// Signature: ??_o
 	if ( t3 === 'generic' ) {
-		if ( t1 === C128 || t2 === C128 ) {
-			if ( t1 === t2 ) {
-				return table[ t1 ];
+		// z?_o
+		if ( t1 === C128 ) {
+			// zz_o or zc_o
+			if ( t2 === C128 || t2 === C64 ) {
+				return table[ C128 ]; // Signature: zz_o_as_zz_z or zc_o_as_zz_z
 			}
-			return wrap( table[ C128 ], 2, CTORS[ C128 ] );
+			// zd_o
+			return wrap( table[ C128 ], 2, CTORS[ C128 ] ); // Signature: zd_o_as_zz_z
 		}
-		if ( t1 === C64 || t2 === C64 ) {
-			if ( t1 === t2 ) {
-				return table[ t1 ];
+		// c?_o
+		if ( t1 === C64 ) {
+			// cc_o
+			if ( t2 === C64 ) {
+				return table[ C64 ]; // Signature: cc_o_as_cc_c
 			}
-			return wrap( table[ C64 ], 2, CTORS[ C64 ] );
+			// cz_o
+			if ( t2 === C128 ) {
+				return table[ C128 ]; // Signature: cz_o_as_zz_z
+			}
+			// cd_o
+			return wrap( table[ C64 ], 2, CTORS[ C64 ] ); // Signature: cd_o_as_cc_c
+		}
+		// dz_o
+		if ( t2 === C128 ) {
+			return wrap( table[ C128 ], 2, CTORS[ C128 ] ); // Signature: dz_o_as_zz_z
+		}
+		// dc_o
+		if ( t2 === C64 ) {
+			return wrap( table[ C64 ], 2, CTORS[ C64 ] ); // Signature: dc_o_as_cc_c
 		}
-		// Fall-through...
+		// dd_o
+		return table.default;
 	}
 	return table.default;
 }

lib/main.js

@@ -58,7 +58,7 @@
     "@stdlib/strided-dtypes": "^0.0.x",
     "tape": "git+https://github.com/kgryte/tape.git#fix/globby",
     "istanbul": "^0.4.1",
-    "tap-spec": "5.x.x"
+    "tap-min": "2.x.x"
   },
   "engines": {
     "node": ">=0.10.0",