@stdlib/math-base-napi-quaternary 0.2.2 → 0.2.3

package/NOTICE

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

package/README.md

@@ -127,6 +127,29 @@ console.log( headerDir );
 #include "stdlib/math/base/napi/quaternary.h"
 ```
 
+<!-- NOTE: keep in alphabetical order according to the suffix XXXX_X -->
+
+#### STDLIB_MATH_BASE_NAPI_MODULE_DDDD_D( fcn )
+
+Macro for registering a Node-API module exporting an interface for invoking a quaternary function accepting and returning double-precision floating-point numbers.
+
+```c
+static double add( const double x, const double y, const double z, const double w ) {
+    return x + y + z + w;
+}
+
+// ...
+
+// Register a Node-API module:
+STDLIB_MATH_BASE_NAPI_MODULE_DDDD_D( add );
+```
+
+The macro expects the following arguments:
+
+-   **fcn**: `double (*fcn)( double, double, double, double )` quaternary 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_dddd_d( env, info, fcn )
 
 Invokes a quaternary function accepting and returning double-precision floating-point numbers.
@@ -166,16 +189,37 @@ The function accepts the following arguments:
 void stdlib_math_base_napi_dddd_d( napi_env env, napi_callback_info info, double (*fcn)( double, double, double, double ) );
 ```
 
-#### stdlib_math_base_napi_ffff_f( env, info, fcn )
+#### STDLIB_MATH_BASE_NAPI_MODULE_DIII_D( fcn )
 
-Invokes a quaternary function accepting and returning single-precision floating-point numbers.
+Macro for registering a Node-API module exporting an interface invoking a quaternary function accepting a double-precision floating-point number and three signed 32-bit integers and returning a double-precision floating-point number.
+
+```c
+static double add( const double x, const int32_t y, const int32_t z, const int32_t w ) {
+    return x + y + z + w;
+}
+
+// ...
+
+// Register a Node-API module:
+STDLIB_MATH_BASE_NAPI_MODULE_DIII_D( add );
+```
+
+The macro expects the following arguments:
+
+-   **fcn**: `double (*fcn)( double, int32_t, int32_t, int32_t )` quaternary 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_diii_d( env, info, fcn )
+
+Invokes a quaternary function accepting a double-precision floating-point number and three signed 32-bit integers and returning a double-precision floating-point number.
 
 ```c
 #include <node_api.h>
 
 // ...
 
-static float addf( const float x, const float y, const float z, const float w ) {
+static double add( const double x, const int32_t y, const int32_t z, const int32_t w ) {
     return x + y + z + w;
 }
 
@@ -189,7 +233,7 @@ static float addf( const float x, const float y, const float z, const float w )
 * @return       Node-API value
 */
 napi_value addon( napi_env env, napi_callback_info info ) {
-    return stdlib_math_base_napi_ffff_f( env, info, addf );
+    return stdlib_math_base_napi_diii_d( env, info, add );
 }
 
 // ...
@@ -199,53 +243,71 @@ 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, float )` quaternary function.
+-   **fcn**: `[in] double (*fcn)( double, int32_t, int32_t, int32_t )` quaternary function.
 
 ```c
-void stdlib_math_base_napi_ffff_f( napi_env env, napi_callback_info info, float (*fcn)( float, float, float, float ) );
+void stdlib_math_base_napi_diii_d( napi_env env, napi_callback_info info, double (*fcn)( double, int32_t, int32_t, int32_t ) );
 ```
 
-#### STDLIB_MATH_BASE_NAPI_MODULE_DDDD_D( fcn )
+#### STDLIB_MATH_BASE_NAPI_MODULE_FFFF_F( fcn )
 
-Macro for registering a Node-API module exporting an interface for invoking a quaternary function accepting and returning double-precision floating-point numbers.
+Macro for registering a Node-API module exporting an interface for invoking a quaternary function accepting and returning single-precision floating-point numbers.
 
 ```c
-static double add( const double x, const double y, const double z, const double w ) {
+static float addf( const float x, const float y, const float z, const float w ) {
     return x + y + z + w;
 }
 
 // ...
 
 // Register a Node-API module:
-STDLIB_MATH_BASE_NAPI_MODULE_DDDD_D( add );
+STDLIB_MATH_BASE_NAPI_MODULE_FFFF_F( addf );
 ```
 
 The macro expects the following arguments:
 
--   **fcn**: `double (*fcn)( double, double, double, double )` quaternary function.
+-   **fcn**: `float (*fcn)( float, float, float, float )` quaternary 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_FFFF_F( fcn )
+#### stdlib_math_base_napi_ffff_f( env, info, fcn )
 
-Macro for registering a Node-API module exporting an interface for invoking a quaternary function accepting and returning single-precision floating-point numbers.
+Invokes a quaternary 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, const float w ) {
     return x + y + z + w;
 }
 
 // ...
 
-// Register a Node-API module:
-STDLIB_MATH_BASE_NAPI_MODULE_FFFF_F( addf );
+/**
+* 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_ffff_f( env, info, addf );
+}
+
+// ...
 ```
 
-The macro expects the following arguments:
+The function accepts the following arguments:
 
--   **fcn**: `float (*fcn)( float, float, float, float )` quaternary function.
+-   **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, float )` quaternary function.
 
-When used, this macro should be used **instead of** `NAPI_MODULE`. The macro includes `NAPI_MODULE`, thus ensuring Node-API module registration.
+```c
+void stdlib_math_base_napi_ffff_f( napi_env env, napi_callback_info info, float (*fcn)( float, float, float, float ) );
+```
 
 </section>
 
@@ -322,7 +384,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>
 
@@ -335,8 +397,8 @@ Copyright &copy; 2016-2024. The Stdlib [Authors][stdlib-authors].
 [npm-image]: http://img.shields.io/npm/v/@stdlib/math-base-napi-quaternary.svg
 [npm-url]: https://npmjs.org/package/@stdlib/math-base-napi-quaternary
 
-[test-image]: https://github.com/stdlib-js/math-base-napi-quaternary/actions/workflows/test.yml/badge.svg?branch=v0.2.2
-[test-url]: https://github.com/stdlib-js/math-base-napi-quaternary/actions/workflows/test.yml?query=branch:v0.2.2
+[test-image]: https://github.com/stdlib-js/math-base-napi-quaternary/actions/workflows/test.yml/badge.svg?branch=v0.2.3
+[test-url]: https://github.com/stdlib-js/math-base-napi-quaternary/actions/workflows/test.yml?query=branch:v0.2.3
 
 [coverage-image]: https://img.shields.io/codecov/c/github/stdlib-js/math-base-napi-quaternary/main.svg
 [coverage-url]: https://codecov.io/github/stdlib-js/math-base-napi-quaternary?branch=main
@@ -348,8 +410,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
 

package/include/stdlib/math/base/napi/quaternary/dddd_d.h

@@ -0,0 +1,81 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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.
+*/
+
+#ifndef STDLIB_MATH_BASE_NAPI_QUATERNARY_DDDD_D_H
+#define STDLIB_MATH_BASE_NAPI_QUATERNARY_DDDD_D_H
+
+#include <node_api.h>
+#include <assert.h>
+
+/**
+* Macro for registering a Node-API module exporting an interface invoking a quaternary function accepting and returning double-precision floating-point numbers.
+*
+* @param fcn   quaternary function
+*
+* @example
+* static double add( const double x, const double y, const double z, const double w ) {
+*     return x + y + z + w;
+* }
+*
+* // ...
+*
+* // Register a Node-API module:
+* STDLIB_MATH_BASE_NAPI_MODULE_DDDD_D( add );
+*/
+#define STDLIB_MATH_BASE_NAPI_MODULE_DDDD_D( fcn )                             \
+	static napi_value stdlib_math_base_napi_dddd_d_wrapper(                    \
+		napi_env env,                                                          \
+		napi_callback_info info                                                \
+	) {                                                                        \
+		return stdlib_math_base_napi_dddd_d( env, info, fcn );                 \
+	};                                                                         \
+	static napi_value stdlib_math_base_napi_dddd_d_init(                       \
+		napi_env env,                                                          \
+		napi_value exports                                                     \
+	) {                                                                        \
+		napi_value f;                                                          \
+		napi_status status = napi_create_function(                             \
+			env,                                                               \
+			"exports",                                                         \
+			NAPI_AUTO_LENGTH,                                                  \
+			stdlib_math_base_napi_dddd_d_wrapper,                              \
+			NULL,                                                              \
+			&f                                                                 \
+		);                                                                     \
+		assert( status == napi_ok );                                           \
+		return f;                                                              \
+	};                                                                         \
+	NAPI_MODULE( NODE_GYP_MODULE_NAME, stdlib_math_base_napi_dddd_d_init )
+
+/*
+* If C++, prevent name mangling so that the compiler emits a quaternary file having undecorated names, thus mirroring the behavior of a C compiler.
+*/
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+* Invokes a quaternary function accepting and returning double-precision floating-point numbers.
+*/
+napi_value stdlib_math_base_napi_dddd_d( napi_env env, napi_callback_info info, double (*fcn)( double, double, double, double ) );
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // !STDLIB_MATH_BASE_NAPI_QUATERNARY_DDDD_D_H

package/include/stdlib/math/base/napi/quaternary/diii_d.h

@@ -0,0 +1,84 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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.
+*/
+
+#ifndef STDLIB_MATH_BASE_NAPI_QUATERNARY_DIII_D_H
+#define STDLIB_MATH_BASE_NAPI_QUATERNARY_DIII_D_H
+
+#include <node_api.h>
+#include <assert.h>
+#include <stdint.h>
+
+/**
+* Macro for registering a Node-API module exporting an interface invoking a quaternary function accepting a double-precision floating-point number and three signed 32-bit integers and returning a double-precision floating-point number.
+*
+* @param fcn   quaternary function
+*
+* @example
+* #include <stdint.h>
+*
+* static double add( const double x, const int32_t y, const int32_t z, const int32_t w ) {
+*     return x + y + z + w;
+* }
+*
+* // ...
+*
+* // Register a Node-API module:
+* STDLIB_MATH_BASE_NAPI_MODULE_DIII_D( add );
+*/
+#define STDLIB_MATH_BASE_NAPI_MODULE_DIII_D( fcn )                             \
+	static napi_value stdlib_math_base_napi_diii_d_wrapper(                    \
+		napi_env env,                                                          \
+		napi_callback_info info                                                \
+	) {                                                                        \
+		return stdlib_math_base_napi_diii_d( env, info, fcn );                 \
+	};                                                                         \
+	static napi_value stdlib_math_base_napi_diii_d_init(                       \
+		napi_env env,                                                          \
+		napi_value exports                                                     \
+	) {                                                                        \
+		napi_value f;                                                          \
+		napi_status status = napi_create_function(                             \
+			env,                                                               \
+			"exports",                                                         \
+			NAPI_AUTO_LENGTH,                                                  \
+			stdlib_math_base_napi_diii_d_wrapper,                              \
+			NULL,                                                              \
+			&f                                                                 \
+		);                                                                     \
+		assert( status == napi_ok );                                           \
+		return f;                                                              \
+	};                                                                         \
+	NAPI_MODULE( NODE_GYP_MODULE_NAME, stdlib_math_base_napi_diii_d_init )
+
+/*
+* If C++, prevent name mangling so that the compiler emits a quaternary file having undecorated names, thus mirroring the behavior of a C compiler.
+*/
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+* Invokes a quaternary function accepting a double-precision floating-point number and three signed 32-bit integers and returning a double-precision floating-point number.
+*/
+napi_value stdlib_math_base_napi_diii_d( napi_env env, napi_callback_info info, double (*fcn)( double, int32_t, int32_t, int32_t ) );
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // !STDLIB_MATH_BASE_NAPI_QUATERNARY_DIII_D_H

package/include/stdlib/math/base/napi/quaternary/ffff_f.h

@@ -0,0 +1,81 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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.
+*/
+
+#ifndef STDLIB_MATH_BASE_NAPI_QUATERNARY_FFFF_F_H
+#define STDLIB_MATH_BASE_NAPI_QUATERNARY_FFFF_F_H
+
+#include <node_api.h>
+#include <assert.h>
+
+/**
+* Macro for registering a Node-API module exporting an interface invoking a quaternary function accepting and returning single-precision floating-point numbers.
+*
+* @param fcn   quaternary function
+*
+* @example
+* static float addf( const float x, const float y, const float z, const float w ) {
+*     return x + y + z + w;
+* }
+*
+* // ...
+*
+* // Register a Node-API module:
+* STDLIB_MATH_BASE_NAPI_MODULE_FFFF_F( addf );
+*/
+#define STDLIB_MATH_BASE_NAPI_MODULE_FFFF_F( fcn )                             \
+	static napi_value stdlib_math_base_napi_ffff_f_wrapper(                    \
+		napi_env env,                                                          \
+		napi_callback_info info                                                \
+	) {                                                                        \
+		return stdlib_math_base_napi_ffff_f( env, info, fcn );                 \
+	};                                                                         \
+	static napi_value stdlib_math_base_napi_ffff_f_init(                       \
+		napi_env env,                                                          \
+		napi_value exports                                                     \
+	) {                                                                        \
+		napi_value f;                                                          \
+		napi_status status = napi_create_function(                             \
+			env,                                                               \
+			"exports",                                                         \
+			NAPI_AUTO_LENGTH,                                                  \
+			stdlib_math_base_napi_ffff_f_wrapper,                              \
+			NULL,                                                              \
+			&f                                                                 \
+		);                                                                     \
+		assert( status == napi_ok );                                           \
+		return f;                                                              \
+	};                                                                         \
+	NAPI_MODULE( NODE_GYP_MODULE_NAME, stdlib_math_base_napi_ffff_f_init )
+
+/*
+* If C++, prevent name mangling so that the compiler emits a quaternary file having undecorated names, thus mirroring the behavior of a C compiler.
+*/
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+* Invokes a quaternary function accepting and returning single-precision floating-point numbers.
+*/
+napi_value stdlib_math_base_napi_ffff_f( napi_env env, napi_callback_info info, float (*fcn)( float, float, float, float ) );
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // !STDLIB_MATH_BASE_NAPI_QUATERNARY_FFFF_F_H

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

@@ -19,108 +19,9 @@
 #ifndef STDLIB_MATH_BASE_NAPI_QUATERNARY_H
 #define STDLIB_MATH_BASE_NAPI_QUATERNARY_H
 
-#include <node_api.h>
-#include <assert.h>
-
-/**
-* Macro for registering a Node-API module exporting an interface invoking a quaternary function accepting and returning double-precision floating-point numbers.
-*
-* @param fcn   quaternary function
-*
-* @example
-* static double add( const double x, const double y, const double z, const double w ) {
-*     return x + y + z + w;
-* }
-*
-* // ...
-*
-* // Register a Node-API module:
-* STDLIB_MATH_BASE_NAPI_MODULE_DDDD_D( add );
-*/
-#define STDLIB_MATH_BASE_NAPI_MODULE_DDDD_D( fcn )                             \
-	static napi_value stdlib_math_base_napi_dddd_d_wrapper(                    \
-		napi_env env,                                                          \
-		napi_callback_info info                                                \
-	) {                                                                        \
-		return stdlib_math_base_napi_dddd_d( env, info, fcn );                 \
-	};                                                                         \
-	static napi_value stdlib_math_base_napi_dddd_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_dddd_d_wrapper,                              \
-			NULL,                                                              \
-			&fcn                                                               \
-		);                                                                     \
-		assert( status == napi_ok );                                           \
-		return fcn;                                                            \
-	};                                                                         \
-	NAPI_MODULE( NODE_GYP_MODULE_NAME, stdlib_math_base_napi_dddd_d_init )
-
-/**
-* Macro for registering a Node-API module exporting an interface invoking a quaternary function accepting and returning single-precision floating-point numbers.
-*
-* @param fcn   quaternary function
-*
-* @example
-* static float addf( const float x, const float y, const float z, const float w ) {
-*     return x + y + z + w;
-* }
-*
-* // ...
-*
-* // Register a Node-API module:
-* STDLIB_MATH_BASE_NAPI_MODULE_FFFF_F( addf );
-*/
-#define STDLIB_MATH_BASE_NAPI_MODULE_FFFF_F( fcn )                             \
-	static napi_value stdlib_math_base_napi_ffff_f_wrapper(                    \
-		napi_env env,                                                          \
-		napi_callback_info info                                                \
-	) {                                                                        \
-		return stdlib_math_base_napi_ffff_f( env, info, fcn );                 \
-	};                                                                         \
-	static napi_value stdlib_math_base_napi_ffff_f_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_ffff_f_wrapper,                              \
-			NULL,                                                              \
-			&fcn                                                               \
-		);                                                                     \
-		assert( status == napi_ok );                                           \
-		return fcn;                                                            \
-	};                                                                         \
-	NAPI_MODULE( NODE_GYP_MODULE_NAME, stdlib_math_base_napi_ffff_f_init )
-
-/*
-* If C++, prevent name mangling so that the compiler emits a quaternary file having undecorated names, thus mirroring the behavior of a C compiler.
-*/
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
-* Invokes a quaternary function accepting and returning double-precision floating-point numbers.
-*/
-napi_value stdlib_math_base_napi_dddd_d( napi_env env, napi_callback_info info, double (*fcn)( double, double, double, double ) );
-
-/**
-* Invokes a quaternary function accepting and returning single-precision floating-point numbers.
-*/
-napi_value stdlib_math_base_napi_ffff_f( napi_env env, napi_callback_info info, float (*fcn)( float, float, float, float ) );
-
-#ifdef __cplusplus
-}
-#endif
+// NOTE: keep in alphabetical order...
+#include "stdlib/math/base/napi/quaternary/dddd_d.h"
+#include "stdlib/math/base/napi/quaternary/diii_d.h"
+#include "stdlib/math/base/napi/quaternary/ffff_f.h"
 
 #endif // !STDLIB_MATH_BASE_NAPI_QUATERNARY_H

package/manifest.json

@@ -1,38 +1,40 @@
 {
-	"options": {},
-	"fields": [
-		{
-			"field": "src",
-			"resolve": true,
-			"relative": true
-		},
-		{
-			"field": "include",
-			"resolve": true,
-			"relative": true
-		},
-		{
-			"field": "libraries",
-			"resolve": false,
-			"relative": false
-		},
-		{
-			"field": "libpath",
-			"resolve": true,
-			"relative": false
-		}
-	],
-	"confs": [
-		{
-			"src": [
-				"./src/main.c"
-			],
-			"include": [
-				"./include"
-			],
-			"libraries": [],
-			"libpath": [],
-			"dependencies": []
-		}
-	]
+  "options": {},
+  "fields": [
+    {
+      "field": "src",
+      "resolve": true,
+      "relative": true
+    },
+    {
+      "field": "include",
+      "resolve": true,
+      "relative": true
+    },
+    {
+      "field": "libraries",
+      "resolve": false,
+      "relative": false
+    },
+    {
+      "field": "libpath",
+      "resolve": true,
+      "relative": false
+    }
+  ],
+  "confs": [
+    {
+      "src": [
+        "./src/dddd_d.c",
+        "./src/diii_d.c",
+        "./src/ffff_f.c"
+      ],
+      "include": [
+        "./include"
+      ],
+      "libraries": [],
+      "libpath": [],
+      "dependencies": []
+    }
+  ]
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stdlib/math-base-napi-quaternary",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "description": "C APIs for registering a Node-API module exporting an interface for invoking a quaternary numerical function.",
   "license": "Apache-2.0",
   "author": {
@@ -34,7 +34,7 @@
     "url": "https://github.com/stdlib-js/stdlib/issues"
   },
   "dependencies": {
-    "@stdlib/utils-library-manifest": "^0.2.1"
+    "@stdlib/utils-library-manifest": "^0.2.2"
   },
   "devDependencies": {},
   "engines": {

package/src/addon.c

@@ -31,5 +31,4 @@ static double add( const double x, const double y, const double z, const double
 	return x + y + z + w;
 }
 
-// cppcheck-suppress shadowFunction
 STDLIB_MATH_BASE_NAPI_MODULE_DDDD_D( add )

package/src/dddd_d.c

@@ -0,0 +1,111 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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.
+*/
+
+#include "stdlib/math/base/napi/quaternary/dddd_d.h"
+#include <node_api.h>
+#include <assert.h>
+
+/**
+* Invokes a quaternary function accepting and returning double-precision floating-point numbers.
+*
+* ## Notes
+*
+* -   This function expects that the callback `info` argument provides access to the following JavaScript arguments:
+*
+*     -   `x`: input value.
+*     -   `y`: input value.
+*     -   `z`: input value.
+*     -   `w`: input value.
+*
+* @param env    environment under which the function is invoked
+* @param info   callback data
+* @param fcn    quaternary function
+* @return       function return value as a Node-API double-precision floating-point number
+*/
+napi_value stdlib_math_base_napi_dddd_d( napi_env env, napi_callback_info info, double (*fcn)( double, double, double, double ) ) {
+	napi_status status;
+
+	size_t argc = 4;
+	napi_value argv[ 4 ];
+	status = napi_get_cb_info( env, info, &argc, argv, NULL, NULL );
+	assert( status == napi_ok );
+
+	if ( argc < 4 ) {
+		status = napi_throw_error( env, NULL, "invalid invocation. Must provide four 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;
+	}
+
+	napi_valuetype vtype2;
+	status = napi_typeof( env, argv[ 2 ], &vtype2 );
+	assert( status == napi_ok );
+	if ( vtype2 != napi_number ) {
+		status = napi_throw_type_error( env, NULL, "invalid argument. Third argument must be a number." );
+		assert( status == napi_ok );
+		return NULL;
+	}
+
+	napi_valuetype vtype3;
+	status = napi_typeof( env, argv[ 3 ], &vtype3 );
+	assert( status == napi_ok );
+	if ( vtype3 != napi_number ) {
+		status = napi_throw_type_error( env, NULL, "invalid argument. Fourth argument must be a number." );
+		assert( status == napi_ok );
+		return NULL;
+	}
+
+	double x;
+	status = napi_get_value_double( env, argv[ 0 ], &x );
+	assert( status == napi_ok );
+
+	double y;
+	status = napi_get_value_double( env, argv[ 1 ], &y );
+	assert( status == napi_ok );
+
+	double z;
+	status = napi_get_value_double( env, argv[ 2 ], &z );
+	assert( status == napi_ok );
+
+	double w;
+	status = napi_get_value_double( env, argv[ 3 ], &w );
+	assert( status == napi_ok );
+
+	napi_value v;
+	status = napi_create_double( env, fcn( x, y, z, w ), &v );
+	assert( status == napi_ok );
+
+	return v;
+}

package/src/diii_d.c

@@ -0,0 +1,112 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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.
+*/
+
+#include "stdlib/math/base/napi/quaternary/diii_d.h"
+#include <node_api.h>
+#include <assert.h>
+#include <stdint.h>
+
+/**
+* Invokes a quaternary function accepting a double-precision floating-point number and three 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.
+*     -   `z`: input value.
+*     -   `w`: input value.
+*
+* @param env    environment under which the function is invoked
+* @param info   callback data
+* @param fcn    quaternary function
+* @return       function return value as a Node-API double-precision floating-point number
+*/
+napi_value stdlib_math_base_napi_diii_d( napi_env env, napi_callback_info info, double (*fcn)( double, int32_t, int32_t, int32_t ) ) {
+	napi_status status;
+
+	size_t argc = 4;
+	napi_value argv[ 4 ];
+	status = napi_get_cb_info( env, info, &argc, argv, NULL, NULL );
+	assert( status == napi_ok );
+
+	if ( argc < 4 ) {
+		status = napi_throw_error( env, NULL, "invalid invocation. Must provide four 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;
+	}
+
+	napi_valuetype vtype2;
+	status = napi_typeof( env, argv[ 2 ], &vtype2 );
+	assert( status == napi_ok );
+	if ( vtype2 != napi_number ) {
+		status = napi_throw_type_error( env, NULL, "invalid argument. Third argument must be a number." );
+		assert( status == napi_ok );
+		return NULL;
+	}
+
+	napi_valuetype vtype3;
+	status = napi_typeof( env, argv[ 3 ], &vtype3 );
+	assert( status == napi_ok );
+	if ( vtype3 != napi_number ) {
+		status = napi_throw_type_error( env, NULL, "invalid argument. Fourth argument must be a number." );
+		assert( status == napi_ok );
+		return NULL;
+	}
+
+	double x;
+	status = napi_get_value_double( env, argv[ 0 ], &x );
+	assert( status == napi_ok );
+
+	int32_t y;
+	status = napi_get_value_int32( env, argv[ 1 ], &y );
+	assert( status == napi_ok );
+
+	int32_t z;
+	status = napi_get_value_int32( env, argv[ 2 ], &z );
+	assert( status == napi_ok );
+
+	int32_t w;
+	status = napi_get_value_int32( env, argv[ 3 ], &w );
+	assert( status == napi_ok );
+
+	napi_value v;
+	status = napi_create_double( env, fcn( x, y, z, w ), &v );
+	assert( status == napi_ok );
+
+	return v;
+}

package/src/{main.c → ffff_f.c}

@@ -16,101 +16,10 @@
 * limitations under the License.
 */
 
-#include "stdlib/math/base/napi/quaternary.h"
+#include "stdlib/math/base/napi/quaternary/ffff_f.h"
 #include <node_api.h>
-#include <stdint.h>
 #include <assert.h>
 
-/**
-* Invokes a quaternary function accepting and returning double-precision floating-point numbers.
-*
-* ## Notes
-*
-* -   This function expects that the callback `info` argument provides access to the following JavaScript arguments:
-*
-*     -   `x`: input value.
-*     -   `y`: input value.
-*     -   `z`: input value.
-*     -   `w`: input value.
-*
-* @param env    environment under which the function is invoked
-* @param info   callback data
-* @param fcn    quaternary function
-* @return       function return value as a Node-API double-precision floating-point number
-*/
-napi_value stdlib_math_base_napi_dddd_d( napi_env env, napi_callback_info info, double (*fcn)( double, double, double, double ) ) {
-	napi_status status;
-
-	size_t argc = 4;
-	napi_value argv[ 4 ];
-	status = napi_get_cb_info( env, info, &argc, argv, NULL, NULL );
-	assert( status == napi_ok );
-
-	if ( argc < 4 ) {
-		status = napi_throw_error( env, NULL, "invalid invocation. Must provide four 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;
-	}
-
-	napi_valuetype vtype2;
-	status = napi_typeof( env, argv[ 2 ], &vtype2 );
-	assert( status == napi_ok );
-	if ( vtype2 != napi_number ) {
-		status = napi_throw_type_error( env, NULL, "invalid argument. Third argument must be a number." );
-		assert( status == napi_ok );
-		return NULL;
-	}
-
-	napi_valuetype vtype3;
-	status = napi_typeof( env, argv[ 3 ], &vtype3 );
-	assert( status == napi_ok );
-	if ( vtype3 != napi_number ) {
-		status = napi_throw_type_error( env, NULL, "invalid argument. Fourth argument must be a number." );
-		assert( status == napi_ok );
-		return NULL;
-	}
-
-	double x;
-	status = napi_get_value_double( env, argv[ 0 ], &x );
-	assert( status == napi_ok );
-
-	double y;
-	status = napi_get_value_double( env, argv[ 1 ], &y );
-	assert( status == napi_ok );
-
-	double z;
-	status = napi_get_value_double( env, argv[ 2 ], &z );
-	assert( status == napi_ok );
-
-	double w;
-	status = napi_get_value_double( env, argv[ 3 ], &w );
-	assert( status == napi_ok );
-
-	napi_value v;
-	status = napi_create_double( env, fcn( x, y, z, w ), &v );
-	assert( status == napi_ok );
-
-	return v;
-}
-
 /**
 * Invokes a quaternary function accepting and returning single-precision floating-point numbers.
 *