@stdlib/math-base-napi-binary 0.2.1 → 0.3.0

package/README.md

@@ -211,8 +211,8 @@ void stdlib_math_base_napi_ff_f( napi_env env, napi_callback_info info, float (*
 Invokes a binary function accepting and returning double-precision complex floating-point numbers.
 
 ```c
-#include "stdlib/complex/float64.h"
-#include "stdlib/complex/reim.h"
+#include "stdlib/complex/float64/ctor.h"
+#include "stdlib/complex/float64/reim.h"
 #include <node_api.h>
 
 // ...
@@ -225,8 +225,8 @@ static stdlib_complex128_t add( const stdlib_complex128_t x, const stdlib_comple
     double re;
     double im;
 
-    stdlib_reim( x, &xre, &xim );
-    stdlib_reim( y, &yre, &yim );
+    stdlib_complex128_reim( x, &xre, &xim );
+    stdlib_complex128_reim( y, &yre, &yim );
 
     re = xre + yre;
     im = xim + yim;
@@ -265,8 +265,8 @@ void stdlib_math_base_napi_zz_z( napi_env env, napi_callback_info info, stdlib_c
 Invokes a binary function accepting and returning single-precision complex floating-point numbers.
 
 ```c
-#include "stdlib/complex/float64.h"
-#include "stdlib/complex/reim.h"
+#include "stdlib/complex/float64/ctor.h"
+#include "stdlib/complex/float64/reim.h"
 #include <node_api.h>
 
 // ...
@@ -279,8 +279,8 @@ static stdlib_complex64_t add( const stdlib_complex64_t x, const stdlib_complex6
     float re;
     float im;
 
-    stdlib_reimf( x, &xre, &xim );
-    stdlib_reimf( y, &yre, &yim );
+    stdlib_complex64_reim( x, &xre, &xim );
+    stdlib_complex64_reim( y, &yre, &yim );
 
     re = xre + yre;
     im = xim + yim;
@@ -354,6 +354,86 @@ The function accepts the following arguments:
 void stdlib_math_base_napi_di_d( napi_env env, napi_callback_info info, double (*fcn)( double, int32_t ) );
 ```
 
+#### stdlib_math_base_napi_ii_i( env, info, fcn )
+
+Invokes a binary function accepting and returning signed 32-bit integers.
+
+```c
+#include <node_api.h>
+#include <stdint.h>
+
+// ...
+
+static int32_t mul( const int32_t x, const int32_t y ) {
+    return x * y;
+}
+
+// ...
+
+/**
+* Receives JavaScript callback invocation data.
+*
+* @param env    environment under which the function is invoked
+* @param info   callback data
+* @return       Node-API value
+*/
+napi_value addon( napi_env env, napi_callback_info info ) {
+    return stdlib_math_base_napi_ii_i( env, info, mul );
+}
+
+// ...
+```
+
+The function accepts the following arguments:
+
+-   **env**: `[in] napi_env` environment under which the function is invoked.
+-   **info**: `[in] napi_callback_info` callback data.
+-   **fcn**: `[in] int32_t (*fcn)( int32_t, int32_t )` binary function.
+
+```c
+void stdlib_math_base_napi_ii_i( napi_env env, napi_callback_info info, int32_t (*fcn)( int32_t, int32_t ) );
+```
+
+#### stdlib_math_base_napi_ii_d( env, info, fcn )
+
+Invokes a binary function accepting signed 32-bit integers and returning a double-precision floating-point number.
+
+```c
+#include <node_api.h>
+#include <stdint.h>
+
+// ...
+
+static double mul( const int32_t x, const int32_t y ) {
+    return x * y;
+}
+
+// ...
+
+/**
+* Receives JavaScript callback invocation data.
+*
+* @param env    environment under which the function is invoked
+* @param info   callback data
+* @return       Node-API value
+*/
+napi_value addon( napi_env env, napi_callback_info info ) {
+    return stdlib_math_base_napi_ii_d( env, info, mul );
+}
+
+// ...
+```
+
+The function accepts the following arguments:
+
+-   **env**: `[in] napi_env` environment under which the function is invoked.
+-   **info**: `[in] napi_callback_info` callback data.
+-   **fcn**: `[in] double (*fcn)( int32_t, int32_t )` binary function.
+
+```c
+void stdlib_math_base_napi_ii_d( napi_env env, napi_callback_info info, double (*fcn)( int32_t, int32_t ) );
+```
+
 #### stdlib_math_base_napi_fi_f( env, info, fcn )
 
 Invokes a binary function accepting a single-precision floating-point number and a signed 32-bit integer and returning a single-precision floating-point number.
@@ -399,8 +479,8 @@ void stdlib_math_base_napi_fi_f( napi_env env, napi_callback_info info, float (*
 Invokes a binary function accepting a double-precision complex floating-point number and a signed 32-bit integer and returning a double-precision complex floating-point number.
 
 ```c
-#include "stdlib/complex/float64.h"
-#include "stdlib/complex/reim.h"
+#include "stdlib/complex/float64/ctor.h"
+#include "stdlib/complex/float64/reim.h"
 #include <node_api.h>
 #include <stdint.h>
 
@@ -412,7 +492,7 @@ static stdlib_complex128_t mul( const stdlib_complex128_t x, const int32_t y ) {
     double re;
     double im;
 
-    stdlib_reim( x, &xre, &xim );
+    stdlib_complex128_reim( x, &xre, &xim );
 
     re = xre * y;
     im = xim * y;
@@ -451,8 +531,8 @@ void stdlib_math_base_napi_zi_z( napi_env env, napi_callback_info info, stdlib_c
 Invokes a binary function accepting a single-precision complex floating-point number and a signed 32-bit integer and returning a single-precision complex floating-point number.
 
 ```c
-#include "stdlib/complex/float64.h"
-#include "stdlib/complex/reimf.h"
+#include "stdlib/complex/float64/ctor.h"
+#include "stdlib/complex/float32/reim.h"
 #include <node_api.h>
 #include <stdint.h>
 
@@ -464,7 +544,7 @@ static stdlib_complex64_t mul( const stdlib_complex64_t x, const int32_t y ) {
     float re;
     float im;
 
-    stdlib_reimf( x, &xre, &xim );
+    stdlib_complex64_reim( x, &xre, &xim );
 
     re = xre * y;
     im = xim * y;
@@ -519,6 +599,48 @@ The macro expects the following arguments:
 
 When used, this macro should be used **instead of** `NAPI_MODULE`. The macro includes `NAPI_MODULE`, thus ensuring Node-API module registration.
 
+#### STDLIB_MATH_BASE_NAPI_MODULE_II_I( fcn )
+
+Macro for registering a Node-API module exporting an interface for invoking a binary function accepting and returning signed 32-bit integers.
+
+```c
+static int32_t add( const int32_t x, const int32_t y ) {
+    return x + y;
+}
+
+// ...
+
+// Register a Node-API module:
+STDLIB_MATH_BASE_NAPI_MODULE_II_I( add );
+```
+
+The macro expects the following arguments:
+
+-   **fcn**: `int32_t (*fcn)( int32_t, int32_t )` binary function.
+
+When used, this macro should be used **instead of** `NAPI_MODULE`. The macro includes `NAPI_MODULE`, thus ensuring Node-API module registration.
+
+#### STDLIB_MATH_BASE_NAPI_MODULE_II_D( fcn )
+
+Macro for registering a Node-API module exporting an interface for invoking a binary function accepting signed 32-bit integers and returning a double-precision floating-point number.
+
+```c
+static double add( const int32_t x, const int32_t y ) {
+    return x + y;
+}
+
+// ...
+
+// Register a Node-API module:
+STDLIB_MATH_BASE_NAPI_MODULE_II_D( add );
+```
+
+The macro expects the following arguments:
+
+-   **fcn**: `double (*fcn)( int32_t, int32_t )` binary function.
+
+When used, this macro should be used **instead of** `NAPI_MODULE`. The macro includes `NAPI_MODULE`, thus ensuring Node-API module registration.
+
 #### STDLIB_MATH_BASE_NAPI_MODULE_FF_F( fcn )
 
 Macro for registering a Node-API module exporting an interface for invoking a binary function accepting and returning single-precision floating-point numbers.
@@ -545,8 +667,8 @@ When used, this macro should be used **instead of** `NAPI_MODULE`. The macro inc
 Macro for registering a Node-API module exporting an interface for invoking a binary function accepting and returning double-precision complex floating-point numbers.
 
 ```c
-#include "stdlib/complex/float64.h"
-#include "stdlib/complex/reim.h"
+#include "stdlib/complex/float64/ctor.h"
+#include "stdlib/complex/float64/reim.h"
 
 static stdlib_complex128_t add( const stdlib_complex128_t x, const stdlib_complex128_t y ) {
     double xre;
@@ -556,8 +678,8 @@ static stdlib_complex128_t add( const stdlib_complex128_t x, const stdlib_comple
     double re;
     double im;
 
-    stdlib_reim( x, &xre, &xim );
-    stdlib_reim( y, &yre, &yim );
+    stdlib_complex128_reim( x, &xre, &xim );
+    stdlib_complex128_reim( y, &yre, &yim );
 
     re = xre + yre;
     im = xim + yim;
@@ -582,8 +704,8 @@ When used, this macro should be used **instead of** `NAPI_MODULE`. The macro inc
 Macro for registering a Node-API module exporting an interface for invoking a binary function accepting and returning single-precision complex floating-point numbers.
 
 ```c
-#include "stdlib/complex/float32.h"
-#include "stdlib/complex/reimf.h"
+#include "stdlib/complex/float32/ctor.h"
+#include "stdlib/complex/float32/reim.h"
 
 static stdlib_complex64_t add( const stdlib_complex64_t x, const stdlib_complex64_t y ) {
     float xre;
@@ -593,8 +715,8 @@ static stdlib_complex64_t add( const stdlib_complex64_t x, const stdlib_complex6
     float re;
     float im;
 
-    stdlib_reimf( x, &xre, &xim );
-    stdlib_reimf( y, &yre, &yim );
+    stdlib_complex64_reim( x, &xre, &xim );
+    stdlib_complex64_reim( y, &yre, &yim );
 
     re = xre + yre;
     im = xim + yim;
@@ -665,8 +787,8 @@ When used, this macro should be used **instead of** `NAPI_MODULE`. The macro inc
 Macro for registering a Node-API module exporting an interface invoking a binary function accepting a double-precision complex floating-point number and a signed 32-bit and returning a double-precision complex floating-point number.
 
 ```c
-#include "stdlib/complex/float64.h"
-#include "stdlib/complex/reim.h"
+#include "stdlib/complex/float64/ctor.h"
+#include "stdlib/complex/float64/reim.h"
 #include <stdint.h>
 
 static stdlib_complex128_t mul( const stdlib_complex128_t x, const int32_t y ) {
@@ -675,7 +797,7 @@ static stdlib_complex128_t mul( const stdlib_complex128_t x, const int32_t y ) {
     double re;
     double im;
 
-    stdlib_reim( x, &xre, &xim );
+    stdlib_complex128_reim( x, &xre, &xim );
 
     re = xre * y;
     im = xim * y;
@@ -700,8 +822,8 @@ When used, this macro should be used **instead of** `NAPI_MODULE`. The macro inc
 Macro for registering a Node-API module exporting an interface invoking a binary function accepting a single-precision complex floating-point number and a signed 32-bit integer and returning a single-precision complex floating-point number.
 
 ```c
-#include "stdlib/complex/float32.h"
-#include "stdlib/complex/reimf.h"
+#include "stdlib/complex/float32/ctor.h"
+#include "stdlib/complex/float32/reim.h"
 #include <stdint.h>
 
 static stdlib_complex64_t add( const stdlib_complex64_t x, const int32_t y ) {
@@ -710,7 +832,7 @@ static stdlib_complex64_t add( const stdlib_complex64_t x, const int32_t y ) {
     float re;
     float im;
 
-    stdlib_reimf( x, &xre, &xim );
+    stdlib_complex64_reim( x, &xre, &xim );
 
     re = xre * y;
     im = xim * y;
@@ -735,8 +857,8 @@ When used, this macro should be used **instead of** `NAPI_MODULE`. The macro inc
 Macro for registering a Node-API module exporting an interface invoking a binary function accepting a double-precision complex floating-point number and a double-precision floating-point number and returning a double-precision complex floating-point number.
 
 ```c
-#include "stdlib/complex/float64.h"
-#include "stdlib/complex/reim.h"
+#include "stdlib/complex/float64/ctor.h"
+#include "stdlib/complex/float64/reim.h"
 
 static stdlib_complex128_t mul( const stdlib_complex128_t x, const double y ) {
     double xre;
@@ -744,7 +866,7 @@ static stdlib_complex128_t mul( const stdlib_complex128_t x, const double y ) {
     double re;
     double im;
 
-    stdlib_reim( x, &xre, &xim );
+    stdlib_complex128_reim( x, &xre, &xim );
 
     re = xre * y;
     im = xim * y;
@@ -769,8 +891,8 @@ When used, this macro should be used **instead of** `NAPI_MODULE`. The macro inc
 Macro for registering a Node-API module exporting an interface invoking a binary function accepting a single-precision complex floating-point number and a single-precision floating-point number and returning a single-precision complex floating-point number.
 
 ```c
-#include "stdlib/complex/float32.h"
-#include "stdlib/complex/reimf.h"
+#include "stdlib/complex/float32/ctor.h"
+#include "stdlib/complex/float32/reim.h"
 
 static stdlib_complex64_t add( const stdlib_complex64_t x, const float y ) {
     float xre;
@@ -778,7 +900,7 @@ static stdlib_complex64_t add( const stdlib_complex64_t x, const float y ) {
     float re;
     float im;
 
-    stdlib_reimf( x, &xre, &xim );
+    stdlib_complex64_reim( x, &xre, &xim );
 
     re = xre * y;
     im = xim * y;
@@ -884,8 +1006,8 @@ Copyright &copy; 2016-2024. The Stdlib [Authors][stdlib-authors].
 [npm-image]: http://img.shields.io/npm/v/@stdlib/math-base-napi-binary.svg
 [npm-url]: https://npmjs.org/package/@stdlib/math-base-napi-binary
 
-[test-image]: https://github.com/stdlib-js/math-base-napi-binary/actions/workflows/test.yml/badge.svg?branch=v0.2.1
-[test-url]: https://github.com/stdlib-js/math-base-napi-binary/actions/workflows/test.yml?query=branch:v0.2.1
+[test-image]: https://github.com/stdlib-js/math-base-napi-binary/actions/workflows/test.yml/badge.svg?branch=v0.3.0
+[test-url]: https://github.com/stdlib-js/math-base-napi-binary/actions/workflows/test.yml?query=branch:v0.3.0
 
 [coverage-image]: https://img.shields.io/codecov/c/github/stdlib-js/math-base-napi-binary/main.svg
 [coverage-url]: https://codecov.io/github/stdlib-js/math-base-napi-binary?branch=main

package/include/stdlib/math/base/napi/binary.h

@@ -19,8 +19,8 @@
 #ifndef STDLIB_MATH_BASE_NAPI_BINARY_H
 #define STDLIB_MATH_BASE_NAPI_BINARY_H
 
-#include "stdlib/complex/float32.h"
-#include "stdlib/complex/float64.h"
+#include "stdlib/complex/float32/ctor.h"
+#include "stdlib/complex/float64/ctor.h"
 #include <node_api.h>
 #include <assert.h>
 
@@ -64,6 +64,86 @@
 	};                                                                         \
 	NAPI_MODULE( NODE_GYP_MODULE_NAME, stdlib_math_base_napi_dd_d_init )
 
+/**
+* Macro for registering a Node-API module exporting an interface invoking a binary function accepting and returning signed 32-bit integers.
+*
+* @param fcn   binary function
+*
+* @example
+* static int_32 add( const int_32 x, const int_32 y ) {
+*     return x + y;
+* }
+*
+* // ...
+*
+* // Register a Node-API module:
+* STDLIB_MATH_BASE_NAPI_MODULE_II_I( add );
+*/
+#define STDLIB_MATH_BASE_NAPI_MODULE_II_I( fcn )                               \
+	static napi_value stdlib_math_base_napi_ii_i_wrapper(                      \
+		napi_env env,                                                          \
+		napi_callback_info info                                                \
+	) {                                                                        \
+		return stdlib_math_base_napi_ii_i( env, info, fcn );                   \
+	};                                                                         \
+	static napi_value stdlib_math_base_napi_ii_i_init(                         \
+		napi_env env,                                                          \
+		napi_value exports                                                     \
+	) {                                                                        \
+		napi_value fcn;                                                        \
+		napi_status status = napi_create_function(                             \
+			env,                                                               \
+			"exports",                                                         \
+			NAPI_AUTO_LENGTH,                                                  \
+			stdlib_math_base_napi_ii_i_wrapper,                                \
+			NULL,                                                              \
+			&fcn                                                               \
+		);                                                                     \
+		assert( status == napi_ok );                                           \
+		return fcn;                                                            \
+	};                                                                         \
+	NAPI_MODULE( NODE_GYP_MODULE_NAME, stdlib_math_base_napi_ii_i_init )
+
+/**
+* Macro for registering a Node-API module exporting an interface invoking a binary function accepting signed 32-bit integers and returning a double-precision floating-point number.
+*
+* @param fcn   binary function
+*
+* @example
+* static double add( const int_32 x, const int_32 y ) {
+*     return x + y;
+* }
+*
+* // ...
+*
+* // Register a Node-API module:
+* STDLIB_MATH_BASE_NAPI_MODULE_II_D( add );
+*/
+#define STDLIB_MATH_BASE_NAPI_MODULE_II_D( fcn )                               \
+	static napi_value stdlib_math_base_napi_ii_d_wrapper(                      \
+		napi_env env,                                                          \
+		napi_callback_info info                                                \
+	) {                                                                        \
+		return stdlib_math_base_napi_ii_d( env, info, fcn );                   \
+	};                                                                         \
+	static napi_value stdlib_math_base_napi_ii_d_init(                         \
+		napi_env env,                                                          \
+		napi_value exports                                                     \
+	) {                                                                        \
+		napi_value fcn;                                                        \
+		napi_status status = napi_create_function(                             \
+			env,                                                               \
+			"exports",                                                         \
+			NAPI_AUTO_LENGTH,                                                  \
+			stdlib_math_base_napi_ii_d_wrapper,                                \
+			NULL,                                                              \
+			&fcn                                                               \
+		);                                                                     \
+		assert( status == napi_ok );                                           \
+		return fcn;                                                            \
+	};                                                                         \
+	NAPI_MODULE( NODE_GYP_MODULE_NAME, stdlib_math_base_napi_ii_d_init )
+
 /**
 * Macro for registering a Node-API module exporting an interface invoking a binary function accepting and returning single-precision floating-point numbers.
 *
@@ -110,8 +190,8 @@
 * @param fcn   binary function
 *
 * @example
-* #include "stdlib/complex/float64.h"
-* #include "stdlib/complex/reim.h"
+* #include "stdlib/complex/float64/ctor.h"
+* #include "stdlib/complex/float64/reim.h"
 *
 * static stdlib_complex128_t add( const stdlib_complex128_t x, const stdlib_complex128_t y ) {
 *     double xre;
@@ -121,8 +201,8 @@
 *     double re;
 *     double im;
 *
-*     stdlib_reim( x, &xre, &xim );
-*     stdlib_reim( y, &yre, &yim );
+*     stdlib_complex128_reim( x, &xre, &xim );
+*     stdlib_complex128_reim( y, &yre, &yim );
 *
 *     re = xre + yre;
 *     im = xim + yim;
@@ -166,8 +246,8 @@
 * @param fcn   binary function
 *
 * @example
-* #include "stdlib/complex/float32.h"
-* #include "stdlib/complex/reimf.h"
+* #include "stdlib/complex/float32/ctor.h"
+* #include "stdlib/complex/float32/reim.h"
 *
 * static stdlib_complex64_t add( const stdlib_complex64_t x, const stdlib_complex64_t y ) {
 *     float xre;
@@ -177,8 +257,8 @@
 *     float re;
 *     float im;
 *
-*     stdlib_reimf( x, &xre, &xim );
-*     stdlib_reimf( y, &yre, &yim );
+*     stdlib_complex64_reim( x, &xre, &xim );
+*     stdlib_complex64_reim( y, &yre, &yim );
 *
 *     re = xre + yre;
 *     im = xim + yim;
@@ -306,15 +386,15 @@
 * @param fcn   binary function
 *
 * @example
-* #include "stdlib/complex/float64.h"
-* #include "stdlib/complex/reim.h"
+* #include "stdlib/complex/float64/ctor.h"
+* #include "stdlib/complex/float64/reim.h"
 * #include <stdint.h>
 *
 * static stdlib_complex128_t mul( const stdlib_complex128_t x, const int32_t n ) {
 *     double re;
 *     double im;
 *
-*     stdlib_reim( x, &re, &im );
+*     stdlib_complex128_reim( x, &re, &im );
 *     return stdlib_complex128( re*n, im*n );
 * }
 *
@@ -354,15 +434,15 @@
 * @param fcn   binary function
 *
 * @example
-* #include "stdlib/complex/float32.h"
-* #include "stdlib/complex/reimf.h"
+* #include "stdlib/complex/float32/ctor.h"
+* #include "stdlib/complex/float32/reim.h"
 * #include <stdint.h>
 *
 * static stdlib_complex64_t mul( const stdlib_complex64_t x, const int32_t n ) {
 *     float re;
 *     float im;
 *
-*     stdlib_reimf( x, &re, &im );
+*     stdlib_complex64_reim( x, &re, &im );
 *     return stdlib_complex64( re*n, im*n );
 * }
 *
@@ -402,14 +482,14 @@
 * @param fcn   binary function
 *
 * @example
-* #include "stdlib/complex/float64.h"
-* #include "stdlib/complex/reim.h"
+* #include "stdlib/complex/float64/ctor.h"
+* #include "stdlib/complex/float64/reim.h"
 *
 * static stdlib_complex128_t mul( const stdlib_complex128_t x, const double n ) {
 *     double re;
 *     double im;
 *
-*     stdlib_reim( x, &re, &im );
+*     stdlib_complex128_reim( x, &re, &im );
 *     return stdlib_complex128( re*n, im*n );
 * }
 *
@@ -449,14 +529,14 @@
 * @param fcn   binary function
 *
 * @example
-* #include "stdlib/complex/float32.h"
-* #include "stdlib/complex/reimf.h"
+* #include "stdlib/complex/float32/ctor.h"
+* #include "stdlib/complex/float32/reim.h"
 *
 * static stdlib_complex64_t mul( const stdlib_complex64_t x, const float n ) {
 *     float re;
 *     float im;
 *
-*     stdlib_reimf( x, &re, &im );
+*     stdlib_complex64_reim( x, &re, &im );
 *     return stdlib_complex64( re*n, im*n );
 * }
 *
@@ -522,6 +602,16 @@ napi_value stdlib_math_base_napi_cc_c( napi_env env, napi_callback_info info, st
 */
 napi_value stdlib_math_base_napi_di_d( napi_env env, napi_callback_info info, double (*fcn)( double, int32_t ) );
 
+/**
+* Invokes a binary function accepting signed 32-bit integers and returning a double-precision floating-point number.
+*/
+napi_value stdlib_math_base_napi_ii_d( napi_env env, napi_callback_info info, double (*fcn)( int32_t, int32_t ) );
+
+/**
+* Invokes a binary function accepting and returning signed 32-bit integers.
+*/
+napi_value stdlib_math_base_napi_ii_i( napi_env env, napi_callback_info info, int32_t (*fcn)( int32_t, int32_t ) );
+
 /**
 * Invokes a binary function accepting a single-precision floating-point number and a signed 32-bit integer and returning a single-precision floating-point number.
 */

package/manifest.json

@@ -33,10 +33,10 @@
 			"libraries": [],
 			"libpath": [],
 			"dependencies": [
-        "@stdlib/complex-float32",
-        "@stdlib/complex-float64",
-        "@stdlib/complex-reim",
-        "@stdlib/complex-reimf"
+        "@stdlib/complex-float32-ctor",
+        "@stdlib/complex-float64-ctor",
+        "@stdlib/complex-float64-reim",
+        "@stdlib/complex-float32-reim"
       ]
 		}
 	]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stdlib/math-base-napi-binary",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "description": "C APIs for registering a Node-API module exporting an interface for invoking a binary numerical function.",
   "license": "Apache-2.0",
   "author": {
@@ -34,11 +34,11 @@
     "url": "https://github.com/stdlib-js/stdlib/issues"
   },
   "dependencies": {
-    "@stdlib/complex-float32": "^0.2.1",
-    "@stdlib/complex-float64": "^0.2.1",
-    "@stdlib/complex-reim": "^0.2.1",
-    "@stdlib/complex-reimf": "^0.2.1",
-    "@stdlib/utils-library-manifest": "^0.2.1"
+    "@stdlib/complex-float32-ctor": "^0.0.2",
+    "@stdlib/complex-float32-reim": "^0.1.2",
+    "@stdlib/complex-float64-ctor": "^0.0.3",
+    "@stdlib/complex-float64-reim": "^0.1.2",
+    "@stdlib/utils-library-manifest": "^0.2.2"
   },
   "devDependencies": {},
   "engines": {

package/src/main.c

@@ -17,10 +17,10 @@
 */
 
 #include "stdlib/math/base/napi/binary.h"
-#include "stdlib/complex/float64.h"
-#include "stdlib/complex/float32.h"
-#include "stdlib/complex/reim.h"
-#include "stdlib/complex/reimf.h"
+#include "stdlib/complex/float64/ctor.h"
+#include "stdlib/complex/float32/ctor.h"
+#include "stdlib/complex/float64/reim.h"
+#include "stdlib/complex/float32/reim.h"
 #include <node_api.h>
 #include <stdint.h>
 #include <assert.h>
@@ -283,7 +283,7 @@ napi_value stdlib_math_base_napi_zz_z( napi_env env, napi_callback_info info, st
 	stdlib_complex128_t v = fcn( stdlib_complex128( re0, im0 ), stdlib_complex128( re1, im1 ) );
 	double re;
 	double im;
-	stdlib_reim( v, &re, &im );
+	stdlib_complex128_reim( v, &re, &im );
 
 	napi_value obj;
 	status = napi_create_object( env, &obj );
@@ -439,7 +439,7 @@ napi_value stdlib_math_base_napi_cc_c( napi_env env, napi_callback_info info, st
 	stdlib_complex64_t v = fcn( stdlib_complex64( (float)re0, (float)im0 ), stdlib_complex64( (float)re1, (float)im1 ) );
 	float re;
 	float im;
-	stdlib_reimf( v, &re, &im );
+	stdlib_complex64_reim( v, &re, &im );
 
 	napi_value obj;
 	status = napi_create_object( env, &obj );
@@ -524,6 +524,130 @@ napi_value stdlib_math_base_napi_di_d( napi_env env, napi_callback_info info, do
 	return v;
 }
 
+/**
+* Invokes a binary function accepting signed 32-bit integers and returning a double-precision floating-point number.
+*
+* ## Notes
+*
+* -   This function expects that the callback `info` argument provides access to the following JavaScript arguments:
+*
+*     -   `x`: input value.
+*     -   `y`: input value.
+*
+* @param env    environment under which the function is invoked
+* @param info   callback data
+* @param fcn    binary function
+* @return       function return value as a Node-API double-precision floating-point number
+*/
+napi_value stdlib_math_base_napi_ii_d( napi_env env, napi_callback_info info, double (*fcn)( int32_t, int32_t ) ) {
+	napi_status status;
+
+	size_t argc = 2;
+	napi_value argv[ 2 ];
+	status = napi_get_cb_info( env, info, &argc, argv, NULL, NULL );
+	assert( status == napi_ok );
+
+	if ( argc < 2 ) {
+		status = napi_throw_error( env, NULL, "invalid invocation. Must provide two numbers." );
+		assert( status == napi_ok );
+		return NULL;
+	}
+
+	napi_valuetype vtype0;
+	status = napi_typeof( env, argv[ 0 ], &vtype0 );
+	assert( status == napi_ok );
+	if ( vtype0 != napi_number ) {
+		status = napi_throw_type_error( env, NULL, "invalid argument. First argument must be a number." );
+		assert( status == napi_ok );
+		return NULL;
+	}
+
+	napi_valuetype vtype1;
+	status = napi_typeof( env, argv[ 1 ], &vtype1 );
+	assert( status == napi_ok );
+	if ( vtype1 != napi_number ) {
+		status = napi_throw_type_error( env, NULL, "invalid argument. Second argument must be a number." );
+		assert( status == napi_ok );
+		return NULL;
+	}
+
+	int32_t x;
+	status = napi_get_value_int32( env, argv[ 0 ], &x );
+	assert( status == napi_ok );
+
+	int32_t y;
+	status = napi_get_value_int32( env, argv[ 1 ], &y );
+	assert( status == napi_ok );
+
+	napi_value v;
+	status = napi_create_double( env, fcn( x, y ), &v );
+	assert( status == napi_ok );
+
+	return v;
+}
+
+/**
+* Invokes a binary function accepting and returning signed 32-bit integers.
+*
+* ## Notes
+*
+* -   This function expects that the callback `info` argument provides access to the following JavaScript arguments:
+*
+*     -   `x`: input value.
+*     -   `y`: input value.
+*
+* @param env    environment under which the function is invoked
+* @param info   callback data
+* @param fcn    binary function
+* @return       function return value as a Node-API signed 32-bit integer
+*/
+napi_value stdlib_math_base_napi_ii_i( napi_env env, napi_callback_info info, int32_t (*fcn)( int32_t, int32_t ) ) {
+	napi_status status;
+
+	size_t argc = 2;
+	napi_value argv[ 2 ];
+	status = napi_get_cb_info( env, info, &argc, argv, NULL, NULL );
+	assert( status == napi_ok );
+
+	if ( argc < 2 ) {
+		status = napi_throw_error( env, NULL, "invalid invocation. Must provide two numbers." );
+		assert( status == napi_ok );
+		return NULL;
+	}
+
+	napi_valuetype vtype0;
+	status = napi_typeof( env, argv[ 0 ], &vtype0 );
+	assert( status == napi_ok );
+	if ( vtype0 != napi_number ) {
+		status = napi_throw_type_error( env, NULL, "invalid argument. First argument must be a number." );
+		assert( status == napi_ok );
+		return NULL;
+	}
+
+	napi_valuetype vtype1;
+	status = napi_typeof( env, argv[ 1 ], &vtype1 );
+	assert( status == napi_ok );
+	if ( vtype1 != napi_number ) {
+		status = napi_throw_type_error( env, NULL, "invalid argument. Second argument must be a number." );
+		assert( status == napi_ok );
+		return NULL;
+	}
+
+	int32_t x;
+	status = napi_get_value_int32( env, argv[ 0 ], &x );
+	assert( status == napi_ok );
+
+	int32_t y;
+	status = napi_get_value_int32( env, argv[ 1 ], &y );
+	assert( status == napi_ok );
+
+	napi_value v;
+	status = napi_create_int32( env, fcn( x, y ), &v );
+	assert( status == napi_ok );
+
+	return v;
+}
+
 /**
 * Invokes a binary function accepting a single-precision floating-point number and a signed 32-bit integer and returning a single-precision floating-point number.
 *
@@ -682,7 +806,7 @@ napi_value stdlib_math_base_napi_zi_z( napi_env env, napi_callback_info info, st
 	stdlib_complex128_t v = fcn( stdlib_complex128( re0, im0 ), y );
 	double re;
 	double im;
-	stdlib_reim( v, &re, &im );
+	stdlib_complex128_reim( v, &re, &im );
 
 	napi_value obj;
 	status = napi_create_object( env, &obj );
@@ -801,7 +925,7 @@ napi_value stdlib_math_base_napi_ci_c( napi_env env, napi_callback_info info, st
 	stdlib_complex64_t v = fcn( stdlib_complex64( (float)re0, (float)im0 ), y );
 	float re;
 	float im;
-	stdlib_reimf( v, &re, &im );
+	stdlib_complex64_reim( v, &re, &im );
 
 	napi_value obj;
 	status = napi_create_object( env, &obj );
@@ -920,7 +1044,7 @@ napi_value stdlib_math_base_napi_zd_z( napi_env env, napi_callback_info info, st
 	stdlib_complex128_t v = fcn( stdlib_complex128( re0, im0 ), y );
 	double re;
 	double im;
-	stdlib_reim( v, &re, &im );
+	stdlib_complex128_reim( v, &re, &im );
 
 	napi_value obj;
 	status = napi_create_object( env, &obj );
@@ -1039,7 +1163,7 @@ napi_value stdlib_math_base_napi_cf_c( napi_env env, napi_callback_info info, st
 	stdlib_complex64_t v = fcn( stdlib_complex64( (float)re0, (float)im0 ), (float)y );
 	float re;
 	float im;
-	stdlib_reimf( v, &re, &im );
+	stdlib_complex64_reim( v, &re, &im );
 
 	napi_value obj;
 	status = napi_create_object( env, &obj );

package/include.gypi

@@ -1,53 +0,0 @@
-# @license Apache-2.0
-#
-# Copyright (c) 2020 The Stdlib Authors.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#    http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-# A GYP include file for building a Node.js native add-on.
-#
-# Main documentation:
-#
-# [1]: https://gyp.gsrc.io/docs/InputFormatReference.md
-# [2]: https://gyp.gsrc.io/docs/UserDocumentation.md
-{
-  # Define variables to be used throughout the configuration for all targets:
-  'variables': {
-    # Source directory:
-    'src_dir': './src',
-
-    # Include directories:
-    'include_dirs': [
-      '<!@(node -e "var arr = require(\'@stdlib/utils-library-manifest\')(\'./manifest.json\',{},{\'basedir\':process.cwd(),\'paths\':\'posix\'}).include; for ( var i = 0; i < arr.length; i++ ) { console.log( arr[ i ] ); }")',
-    ],
-
-    # Add-on destination directory:
-    'addon_output_dir': './src',
-
-    # Source files:
-    'src_files': [
-      '<(src_dir)/addon.c',
-      '<!@(node -e "var arr = require(\'@stdlib/utils-library-manifest\')(\'./manifest.json\',{},{\'basedir\':process.cwd(),\'paths\':\'posix\'}).src; for ( var i = 0; i < arr.length; i++ ) { console.log( arr[ i ] ); }")',
-    ],
-
-    # Library dependencies:
-    'libraries': [
-      '<!@(node -e "var arr = require(\'@stdlib/utils-library-manifest\')(\'./manifest.json\',{},{\'basedir\':process.cwd(),\'paths\':\'posix\'}).libraries; for ( var i = 0; i < arr.length; i++ ) { console.log( arr[ i ] ); }")',
-    ],
-
-    # Library directories:
-    'library_dirs': [
-      '<!@(node -e "var arr = require(\'@stdlib/utils-library-manifest\')(\'./manifest.json\',{},{\'basedir\':process.cwd(),\'paths\':\'posix\'}).libpath; for ( var i = 0; i < arr.length; i++ ) { console.log( arr[ i ] ); }")',
-    ],
-  }, # end variables
-}