@stdlib/math-base-napi-ternary 0.3.0 → 0.3.2

package/NOTICE

@@ -1 +1 @@
-Copyright (c) 2016-2024 The Stdlib Authors.
+Copyright (c) 2016-2026 The Stdlib Authors.

package/README.md

@@ -127,6 +127,126 @@ console.log( headerDir );
 #include "stdlib/math/base/napi/ternary.h"
 ```
 
+<!-- NOTE: keep in alphabetical order according to the suffix XXX_X -->
+
+#### STDLIB_MATH_BASE_NAPI_MODULE_CCC_C( fcn )
+
+Macro for registering a Node-API module exporting an interface for invoking a ternary function accepting and returning single-precision complex floating-point numbers.
+
+```c
+#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, const stdlib_complex64_t z ) {
+    float xre;
+    float xim;
+    float yre;
+    float yim;
+    float zre;
+    float zim;
+    float re;
+    float im;
+
+    stdlib_complex64_reim( x, &xre, &xim );
+    stdlib_complex64_reim( y, &yre, &yim );
+    stdlib_complex64_reim( z, &zre, &zim );
+
+    re = xre + yre + zre;
+    im = xim + yim + zim;
+
+    return stdlib_complex64( re, im );
+}
+
+// ...
+
+// Register a Node-API module:
+STDLIB_MATH_BASE_NAPI_MODULE_CCC_C( add );
+```
+
+The macro expects the following arguments:
+
+-   **fcn**: `stdlib_complex64_t (*fcn)( stdlib_complex64_t, stdlib_complex64_t, stdlib_complex64_t )` ternary 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_ccc_c( env, info, fcn )
+
+Invokes a ternary function accepting and returning single-precision complex floating-point numbers.
+
+```c
+#include "stdlib/complex/float32/ctor.h"
+#include "stdlib/complex/float32/reim.h"
+#include <node_api.h>
+
+// ...
+
+static stdlib_complex64_t add( const stdlib_complex64_t x, const stdlib_complex64_t y, const stdlib_complex64_t z ) {
+    float xre;
+    float xim;
+    float yre;
+    float yim;
+    float zre;
+    float zim;
+    float re;
+    float im;
+
+    stdlib_complex64_reim( x, &xre, &xim );
+    stdlib_complex64_reim( y, &yre, &yim );
+    stdlib_complex64_reim( z, &zre, &zim );
+
+    re = xre + yre + zre;
+    im = xim + yim + zim;
+
+    return stdlib_complex64( re, im );
+}
+
+// ...
+
+/**
+* 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_ccc_c( env, info, add );
+}
+
+// ...
+```
+
+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] stdlib_complex64_t (*fcn)( stdlib_complex64_t, stdlib_complex64_t, stdlib_complex64_t )` ternary function.
+
+```c
+void stdlib_math_base_napi_ccc_c( napi_env env, napi_callback_info info, stdlib_complex64_t (*fcn)( stdlib_complex64_t, stdlib_complex64_t, stdlib_complex64_t ) );
+```
+
+#### STDLIB_MATH_BASE_NAPI_MODULE_DDD_D( fcn )
+
+Macro for registering a Node-API module exporting an interface for invoking a ternary function accepting and returning double-precision floating-point numbers.
+
+```c
+static double add( const double x, const double y, const double z ) {
+    return x + y + z;
+}
+
+// ...
+
+// Register a Node-API module:
+STDLIB_MATH_BASE_NAPI_MODULE_DDD_D( add );
+```
+
+The macro expects the following arguments:
+
+-   **fcn**: `double (*fcn)( double, double, double )` ternary 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_ddd_d( env, info, fcn )
 
 Invokes a ternary function accepting and returning double-precision floating-point numbers.
@@ -166,17 +286,41 @@ The function accepts the following arguments:
 void stdlib_math_base_napi_ddd_d( napi_env env, napi_callback_info info, double (*fcn)( double, double, double ) );
 ```
 
-#### stdlib_math_base_napi_fff_f( env, info, fcn )
+#### STDLIB_MATH_BASE_NAPI_MODULE_DID_D( fcn )
 
-Invokes a ternary function accepting and returning single-precision floating-point numbers.
+Macro for registering a Node-API module exporting an interface for invoking a ternary function accepting a double-precision floating-point number, a signed 32-bit integer, and a double-precision floating-point number and returning a double-precision floating-point number.
+
+```c
+#include <stdint.h>
+
+static double fcn( const double x, const int32_t y, const double z ) {
+    // ...
+}
+
+// ...
+
+// Register a Node-API module:
+STDLIB_MATH_BASE_NAPI_MODULE_DID_D( fcn );
+```
+
+The macro expects the following arguments:
+
+-   **fcn**: `double (*fcn)( double, int32_t, double )` ternary 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_did_d( env, info, fcn )
+
+Invokes a ternary function accepting a double-precision floating-point number, a signed 32-bit integer, and a double-precision floating-point number and returning a double-precision floating-point number.
 
 ```c
 #include <node_api.h>
+#include <stdint.h>
 
 // ...
 
-static float addf( const float x, const float y, const float z ) {
-    return x + y + z;
+static double fcn( const double x, const int32_t y, const double z ) {
+    // ...
 }
 
 // ...
@@ -189,7 +333,7 @@ static float addf( const float x, const float y, const float z ) {
 * @return       Node-API value
 */
 napi_value addon( napi_env env, napi_callback_info info ) {
-    return stdlib_math_base_napi_fff_f( env, info, addf );
+    return stdlib_math_base_napi_did_d( env, info, fcn );
 }
 
 // ...
@@ -199,12 +343,35 @@ 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] float (*fcn)( float, float, float )` ternary function.
+-   **fcn**: `[in] double (*fcn)( double, int32_t, double )` ternary function.
 
 ```c
-void stdlib_math_base_napi_fff_f( napi_env env, napi_callback_info info, float (*fcn)( float, float, float ) );
+void stdlib_math_base_napi_did_d( napi_env env, napi_callback_info info, double (*fcn)( double, int32_t, double ) );
+```
+
+#### STDLIB_MATH_BASE_NAPI_MODULE_DII_D( fcn )
+
+Macro for registering a Node-API module exporting an interface for invoking a ternary function accepting a double-precision floating-point number and two signed 32-bit integers and returning a double-precision floating-point number.
+
+```c
+#include <stdint.h>
+
+static double fcn( const double x, const int32_t y, const int32_t z ) {
+    // ...
+}
+
+// ...
+
+// Register a Node-API module:
+STDLIB_MATH_BASE_NAPI_MODULE_DII_D( fcn );
 ```
 
+The macro expects the following arguments:
+
+-   **fcn**: `double (*fcn)( double, int32_t, int32_t )` ternary 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_dii_d( env, info, fcn )
 
 Invokes a ternary function accepting a double-precision floating-point number and two signed 32-bit integers and returning a double-precision floating-point number.
@@ -245,71 +412,415 @@ The function accepts the following arguments:
 void stdlib_math_base_napi_dii_d( napi_env env, napi_callback_info info, double (*fcn)( double, int32_t, int32_t ) );
 ```
 
-#### STDLIB_MATH_BASE_NAPI_MODULE_DDD_D( fcn )
+#### STDLIB_MATH_BASE_NAPI_MODULE_FFF_F( fcn )
 
-Macro for registering a Node-API module exporting an interface for invoking a ternary function accepting and returning double-precision floating-point numbers.
+Macro for registering a Node-API module exporting an interface for invoking a ternary function accepting and returning single-precision floating-point numbers.
 
 ```c
-static double add( const double x, const double y, const double z ) {
+static float addf( const float x, const float y, const float z ) {
     return x + y + z;
 }
 
 // ...
 
 // Register a Node-API module:
-STDLIB_MATH_BASE_NAPI_MODULE_DDD_D( add );
+STDLIB_MATH_BASE_NAPI_MODULE_FFF_F( addf );
 ```
 
 The macro expects the following arguments:
 
--   **fcn**: `double (*fcn)( double, double, double )` ternary function.
+-   **fcn**: `float (*fcn)( float, float, float )` ternary 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_FFF_F( fcn )
+#### stdlib_math_base_napi_fff_f( env, info, fcn )
 
-Macro for registering a Node-API module exporting an interface for invoking a ternary function accepting and returning single-precision floating-point numbers.
+Invokes a ternary function accepting and returning single-precision floating-point numbers.
 
 ```c
+#include <node_api.h>
+
+// ...
+
 static float addf( const float x, const float y, const float z ) {
     return x + y + z;
 }
 
 // ...
 
+/**
+* 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_fff_f( env, info, addf );
+}
+
+// ...
+```
+
+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] float (*fcn)( float, float, float )` ternary function.
+
+```c
+void stdlib_math_base_napi_fff_f( napi_env env, napi_callback_info info, float (*fcn)( float, float, float ) );
+```
+
+#### STDLIB_MATH_BASE_NAPI_MODULE_FIF_F( fcn )
+
+Macro for registering a Node-API module exporting an interface for invoking a ternary function accepting a single-precision floating-point number, a signed 32-bit integer, and a single-precision floating-point number and returning a single-precision floating-point number.
+
+```c
+#include <stdint.h>
+
+static float fcn( const float x, const int32_t y, const float z ) {
+    // ...
+}
+
+// ...
+
 // Register a Node-API module:
-STDLIB_MATH_BASE_NAPI_MODULE_FFF_F( addf );
+STDLIB_MATH_BASE_NAPI_MODULE_FIF_F( fcn );
 ```
 
 The macro expects the following arguments:
 
--   **fcn**: `float (*fcn)( float, float, float )` ternary function.
+-   **fcn**: `float (*fcn)( float, int32_t, float )` ternary 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_DII_D( fcn )
+#### stdlib_math_base_napi_fif_f( env, info, fcn )
 
-Macro for registering a Node-API module exporting an interface for invoking a ternary function accepting a double-precision floating-point number and two signed 32-bit integers and returning a double-precision floating-point number.
+Invokes a ternary function accepting a single-precision floating-point number, a signed 32-bit integer, and a single-precision floating-point number and returning a single-precision floating-point number.
 
 ```c
+#include <node_api.h>
 #include <stdint.h>
 
-static double fcn( const double x, const int32_t y, const int32_t z ) {
+// ...
+
+static float fcn( const float x, const int32_t y, const float z ) {
+    // ...
+}
+
+// ...
+
+/**
+* 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_fif_f( env, info, fcn );
+}
+
+// ...
+```
+
+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] float (*fcn)( float, int32_t, float )` ternary function.
+
+```c
+void stdlib_math_base_napi_fif_f( napi_env env, napi_callback_info info, float (*fcn)( float, int32_t, float ) );
+```
+
+#### STDLIB_MATH_BASE_NAPI_MODULE_FII_F( fcn )
+
+Macro for registering a Node-API module exporting an interface for invoking a ternary function accepting a single-precision floating-point number and two signed 32-bit integers and returning a single-precision floating-point number.
+
+```c
+#include <stdint.h>
+
+static float fcn( const float x, const int32_t y, const int32_t z ) {
     // ...
 }
 
 // ...
 
 // Register a Node-API module:
-STDLIB_MATH_BASE_NAPI_MODULE_DII_D( fcn );
+STDLIB_MATH_BASE_NAPI_MODULE_FII_F( fcn );
 ```
 
 The macro expects the following arguments:
 
--   **fcn**: `double (*fcn)( double, int32_t, int32_t )` ternary function.
+-   **fcn**: `float (*fcn)( float, int32_t, int32_t )` ternary 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_fii_f( env, info, fcn )
+
+Invokes a ternary function accepting a single-precision floating-point number and two signed 32-bit integers and returning a single-precision floating-point number.
+
+```c
+#include <node_api.h>
+#include <stdint.h>
+
+// ...
+
+static float fcn( const float x, const int32_t y, const int32_t z ) {
+    // ...
+}
+
+// ...
+
+/**
+* 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_fii_f( env, info, fcn );
+}
+
+// ...
+```
+
+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] float (*fcn)( float, int32_t, int32_t )` ternary function.
+
+```c
+void stdlib_math_base_napi_fii_f( napi_env env, napi_callback_info info, float (*fcn)( float, int32_t, int32_t ) );
+```
+
+#### STDLIB_MATH_BASE_NAPI_MODULE_IID_D( fcn )
+
+Macro for registering a Node-API module exporting an interface for invoking a ternary function accepting two signed 32-bit integers and a double-precision floating-point number and returning a double-precision floating-point number.
+
+```c
+#include <stdint.h>
+
+static double fcn( const int32_t x, const int32_t y, const double z ) {
+    // ...
+}
+
+// ...
+
+// Register a Node-API module:
+STDLIB_MATH_BASE_NAPI_MODULE_IID_D( fcn );
+```
+
+The macro expects the following arguments:
+
+-   **fcn**: `double (*fcn)( int32_t, int32_t, double )` ternary 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_iid_d( env, info, fcn )
+
+Invokes a ternary function accepting two signed 32-bit integers and a double-precision floating-point number and returning a double-precision floating-point number.
+
+```c
+#include <node_api.h>
+#include <stdint.h>
+
+// ...
+
+static double fcn( const int32_t x, const int32_t y, const double z ) {
+    // ...
+}
+
+// ...
+
+/**
+* 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_iid_d( env, info, fcn );
+}
+
+// ...
+```
+
+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, double )` ternary function.
+
+```c
+void stdlib_math_base_napi_iid_d( napi_env env, napi_callback_info info, double (*fcn)( int32_t, int32_t, double ) );
+```
+
+#### STDLIB_MATH_BASE_NAPI_MODULE_III_D( fcn )
+
+Macro for registering a Node-API module exporting an interface for invoking a ternary function accepting three signed 32-bit integers and returning a double-precision floating-point number.
+
+```c
+#include <stdint.h>
+
+static double fcn( const int32_t x, const int32_t y, const int32_t z ) {
+    // ...
+}
+
+// ...
+
+// Register a Node-API module:
+STDLIB_MATH_BASE_NAPI_MODULE_III_D( fcn );
+```
+
+The macro expects the following arguments:
+
+-   **fcn**: `double (*fcn)( int32_t, int32_t, int32_t )` ternary 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_iii_d( env, info, fcn )
+
+Invokes a ternary function accepting three signed 32-bit integers and returning a double-precision floating-point number.
+
+```c
+#include <node_api.h>
+#include <stdint.h>
+
+// ...
+
+static double fcn( const int32_t x, const int32_t y, const int32_t z ) {
+    // ...
+}
+
+// ...
+
+/**
+* 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_iii_d( env, info, fcn );
+}
+
+// ...
+```
+
+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, int32_t )` ternary function.
+
+```c
+void stdlib_math_base_napi_iii_d( napi_env env, napi_callback_info info, double (*fcn)( int32_t, int32_t, int32_t ) );
+```
+
+#### STDLIB_MATH_BASE_NAPI_MODULE_ZZZ_Z( fcn )
+
+Macro for registering a Node-API module exporting an interface for invoking a ternary function accepting and returning double-precision complex floating-point numbers.
+
+```c
+#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, const stdlib_complex128_t z ) {
+    double xre;
+    double xim;
+    double yre;
+    double yim;
+    double zre;
+    double zim;
+    double re;
+    double im;
+
+    stdlib_complex128_reim( x, &xre, &xim );
+    stdlib_complex128_reim( y, &yre, &yim );
+    stdlib_complex128_reim( z, &zre, &zim );
+
+    re = xre + yre + zre;
+    im = xim + yim + zim;
+
+    return stdlib_complex128( re, im );
+}
+
+// ...
+
+// Register a Node-API module:
+STDLIB_MATH_BASE_NAPI_MODULE_ZZZ_Z( add );
+```
+
+The macro expects the following arguments:
+
+-   **fcn**: `stdlib_complex128_t (*fcn)( stdlib_complex128_t, stdlib_complex128_t, stdlib_complex128_t )` ternary 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_zzz_z( env, info, fcn )
+
+Invokes a ternary function accepting and returning double-precision complex floating-point numbers.
+
+```c
+#include "stdlib/complex/float64/ctor.h"
+#include "stdlib/complex/float64/reim.h"
+#include <node_api.h>
+
+// ...
+
+static stdlib_complex128_t add( const stdlib_complex128_t x, const stdlib_complex128_t y, const stdlib_complex128_t z ) {
+    double xre;
+    double xim;
+    double yre;
+    double yim;
+    double zre;
+    double zim;
+    double re;
+    double im;
+
+    stdlib_complex128_reim( x, &xre, &xim );
+    stdlib_complex128_reim( y, &yre, &yim );
+    stdlib_complex128_reim( z, &zre, &zim );
+
+    re = xre + yre + zre;
+    im = xim + yim + zim;
+
+    return stdlib_complex128( re, im );
+}
+
+// ...
+
+/**
+* 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_zzz_z( env, info, add );
+}
+
+// ...
+```
+
+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] stdlib_complex128_t (*fcn)( stdlib_complex128_t, stdlib_complex128_t, stdlib_complex128_t )` ternary function.
+
+```c
+void stdlib_math_base_napi_zzz_z( napi_env env, napi_callback_info info, stdlib_complex128_t (*fcn)( stdlib_complex128_t, stdlib_complex128_t, stdlib_complex128_t ) );
+```
+
 </section>
 
 <!-- /.usage -->
@@ -384,7 +895,7 @@ See [LICENSE][stdlib-license].
 
 ## Copyright
 
-Copyright &copy; 2016-2024. The Stdlib [Authors][stdlib-authors].
+Copyright &copy; 2016-2026. The Stdlib [Authors][stdlib-authors].
 
 </section>
 
@@ -397,8 +908,8 @@ Copyright &copy; 2016-2024. The Stdlib [Authors][stdlib-authors].
 [npm-image]: http://img.shields.io/npm/v/@stdlib/math-base-napi-ternary.svg
 [npm-url]: https://npmjs.org/package/@stdlib/math-base-napi-ternary
 
-[test-image]: https://github.com/stdlib-js/math-base-napi-ternary/actions/workflows/test.yml/badge.svg?branch=v0.3.0
-[test-url]: https://github.com/stdlib-js/math-base-napi-ternary/actions/workflows/test.yml?query=branch:v0.3.0
+[test-image]: https://github.com/stdlib-js/math-base-napi-ternary/actions/workflows/test.yml/badge.svg?branch=v0.3.2
+[test-url]: https://github.com/stdlib-js/math-base-napi-ternary/actions/workflows/test.yml?query=branch:v0.3.2
 
 [coverage-image]: https://img.shields.io/codecov/c/github/stdlib-js/math-base-napi-ternary/main.svg
 [coverage-url]: https://codecov.io/github/stdlib-js/math-base-napi-ternary?branch=main
@@ -410,8 +921,8 @@ Copyright &copy; 2016-2024. The Stdlib [Authors][stdlib-authors].
 
 -->
 
-[chat-image]: https://img.shields.io/gitter/room/stdlib-js/stdlib.svg
-[chat-url]: https://app.gitter.im/#/room/#stdlib-js_stdlib:gitter.im
+[chat-image]: https://img.shields.io/badge/zulip-join_chat-brightgreen.svg
+[chat-url]: https://stdlib.zulipchat.com
 
 [stdlib]: https://github.com/stdlib-js/stdlib