@stdlib/math-base-napi-quinary 0.2.2 → 0.2.4

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/quinary.h"
 ```
 
+<!-- NOTE: keep in alphabetical order according to the suffix XXXXX_X -->
+
+#### STDLIB_MATH_BASE_NAPI_MODULE_DDDDD_D( fcn )
+
+Macro for registering a Node-API module exporting an interface for invoking a quinary 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, const double u ) {
+    return x + y + z + w + u;
+}
+
+// ...
+
+// Register a Node-API module:
+STDLIB_MATH_BASE_NAPI_MODULE_DDDDD_D( add );
+```
+
+The macro expects the following arguments:
+
+-   **fcn**: `double (*fcn)( double, double, double, double, double )` quinary 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_ddddd_d( env, info, fcn )
 
 Invokes a quinary function accepting and returning double-precision floating-point numbers.
@@ -166,6 +189,27 @@ The function accepts the following arguments:
 void stdlib_math_base_napi_ddddd_d( napi_env env, napi_callback_info info, double (*fcn)( double, double, double, double, double ) );
 ```
 
+#### STDLIB_MATH_BASE_NAPI_MODULE_FFFFF_F( fcn )
+
+Macro for registering a Node-API module exporting an interface for invoking a quinary function accepting and returning single-precision floating-point numbers.
+
+```c
+static float addf( const float x, const float y, const float z, const float w, const float u ) {
+    return x + y + z + w + u;
+}
+
+// ...
+
+// Register a Node-API module:
+STDLIB_MATH_BASE_NAPI_MODULE_FFFFF_F( addf );
+```
+
+The macro expects the following arguments:
+
+-   **fcn**: `float (*fcn)( float, float, float, float, float )` quinary 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_fffff_f( env, info, fcn )
 
 Invokes a quinary function accepting and returning single-precision floating-point numbers.
@@ -205,48 +249,6 @@ The function accepts the following arguments:
 void stdlib_math_base_napi_fffff_f( napi_env env, napi_callback_info info, float (*fcn)( float, float, float, float, float ) );
 ```
 
-#### STDLIB_MATH_BASE_NAPI_MODULE_DDDDD_D( fcn )
-
-Macro for registering a Node-API module exporting an interface for invoking a quinary 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, const double u ) {
-    return x + y + z + w + u;
-}
-
-// ...
-
-// Register a Node-API module:
-STDLIB_MATH_BASE_NAPI_MODULE_DDDDD_D( add );
-```
-
-The macro expects the following arguments:
-
--   **fcn**: `double (*fcn)( double, double, double, double, double )` quinary 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_FFFFF_F( fcn )
-
-Macro for registering a Node-API module exporting an interface for invoking a quinary function accepting and returning single-precision floating-point numbers.
-
-```c
-static float addf( const float x, const float y, const float z, const float w, const float u ) {
-    return x + y + z + w + u;
-}
-
-// ...
-
-// Register a Node-API module:
-STDLIB_MATH_BASE_NAPI_MODULE_FFFFF_F( addf );
-```
-
-The macro expects the following arguments:
-
--   **fcn**: `float (*fcn)( float, float, float, float, float )` quinary function.
-
-When used, this macro should be used **instead of** `NAPI_MODULE`. The macro includes `NAPI_MODULE`, thus ensuring Node-API module registration.
-
 </section>
 
 <!-- /.usage -->
@@ -323,7 +325,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>
 
@@ -336,8 +338,8 @@ Copyright &copy; 2016-2024. The Stdlib [Authors][stdlib-authors].
 [npm-image]: http://img.shields.io/npm/v/@stdlib/math-base-napi-quinary.svg
 [npm-url]: https://npmjs.org/package/@stdlib/math-base-napi-quinary
 
-[test-image]: https://github.com/stdlib-js/math-base-napi-quinary/actions/workflows/test.yml/badge.svg?branch=v0.2.2
-[test-url]: https://github.com/stdlib-js/math-base-napi-quinary/actions/workflows/test.yml?query=branch:v0.2.2
+[test-image]: https://github.com/stdlib-js/math-base-napi-quinary/actions/workflows/test.yml/badge.svg?branch=v0.2.4
+[test-url]: https://github.com/stdlib-js/math-base-napi-quinary/actions/workflows/test.yml?query=branch:v0.2.4
 
 [coverage-image]: https://img.shields.io/codecov/c/github/stdlib-js/math-base-napi-quinary/main.svg
 [coverage-url]: https://codecov.io/github/stdlib-js/math-base-napi-quinary?branch=main
@@ -349,8 +351,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/quinary/ddddd_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_QUINARY_DDDDD_D_H
+#define STDLIB_MATH_BASE_NAPI_QUINARY_DDDDD_D_H
+
+#include <node_api.h>
+#include <assert.h>
+
+/**
+* Macro for registering a Node-API module exporting an interface invoking a quinary function accepting and returning double-precision floating-point numbers.
+*
+* @param fcn   quinary function
+*
+* @example
+* static double add( const double x, const double y, const double z, const double w, const double u ) {
+*     return x + y + z + w + u;
+* }
+*
+* // ...
+*
+* // Register a Node-API module:
+* STDLIB_MATH_BASE_NAPI_MODULE_DDDDD_D( add );
+*/
+#define STDLIB_MATH_BASE_NAPI_MODULE_DDDDD_D( fcn )                            \
+	static napi_value stdlib_math_base_napi_ddddd_d_wrapper(                   \
+		napi_env env,                                                          \
+		napi_callback_info info                                                \
+	) {                                                                        \
+		return stdlib_math_base_napi_ddddd_d( env, info, fcn );                \
+	};                                                                         \
+	static napi_value stdlib_math_base_napi_ddddd_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_ddddd_d_wrapper,                             \
+			NULL,                                                              \
+			&f                                                                 \
+		);                                                                     \
+		assert( status == napi_ok );                                           \
+		return f;                                                              \
+	};                                                                         \
+	NAPI_MODULE( NODE_GYP_MODULE_NAME, stdlib_math_base_napi_ddddd_d_init )
+
+/*
+* If C++, prevent name mangling so that the compiler emits a quinary file having undecorated names, thus mirroring the behavior of a C compiler.
+*/
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+* Invokes a quinary function accepting and returning double-precision floating-point numbers.
+*/
+napi_value stdlib_math_base_napi_ddddd_d( napi_env env, napi_callback_info info, double (*fcn)( double, double, double, double, double ) );
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // !STDLIB_MATH_BASE_NAPI_QUINARY_DDDDD_D_H

package/include/stdlib/math/base/napi/quinary/fffff_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_QUINARY_FFFFF_F_H
+#define STDLIB_MATH_BASE_NAPI_QUINARY_FFFFF_F_H
+
+#include <node_api.h>
+#include <assert.h>
+
+/**
+* Macro for registering a Node-API module exporting an interface invoking a quinary function accepting and returning single-precision floating-point numbers.
+*
+* @param fcn   quinary function
+*
+* @example
+* static float addf( const float x, const float y, const float z, const float w, const float u ) {
+*     return x + y + z + w + u;
+* }
+*
+* // ...
+*
+* // Register a Node-API module:
+* STDLIB_MATH_BASE_NAPI_MODULE_FFFFF_F( addf );
+*/
+#define STDLIB_MATH_BASE_NAPI_MODULE_FFFFF_F( fcn )                            \
+	static napi_value stdlib_math_base_napi_fffff_f_wrapper(                   \
+		napi_env env,                                                          \
+		napi_callback_info info                                                \
+	) {                                                                        \
+		return stdlib_math_base_napi_fffff_f( env, info, fcn );                \
+	};                                                                         \
+	static napi_value stdlib_math_base_napi_fffff_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_fffff_f_wrapper,                             \
+			NULL,                                                              \
+			&f                                                                 \
+		);                                                                     \
+		assert( status == napi_ok );                                           \
+		return f;                                                              \
+	};                                                                         \
+	NAPI_MODULE( NODE_GYP_MODULE_NAME, stdlib_math_base_napi_fffff_f_init )
+
+/*
+* If C++, prevent name mangling so that the compiler emits a quinary file having undecorated names, thus mirroring the behavior of a C compiler.
+*/
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+* Invokes a quinary function accepting and returning single-precision floating-point numbers.
+*/
+napi_value stdlib_math_base_napi_fffff_f( napi_env env, napi_callback_info info, float (*fcn)( float, float, float, float, float ) );
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // !STDLIB_MATH_BASE_NAPI_QUINARY_FFFFF_F_H

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

@@ -22,105 +22,8 @@
 #include <node_api.h>
 #include <assert.h>
 
-/**
-* Macro for registering a Node-API module exporting an interface invoking a quinary function accepting and returning double-precision floating-point numbers.
-*
-* @param fcn   quinary function
-*
-* @example
-* static double add( const double x, const double y, const double z, const double w, const double u ) {
-*     return x + y + z + w + u;
-* }
-*
-* // ...
-*
-* // Register a Node-API module:
-* STDLIB_MATH_BASE_NAPI_MODULE_DDDDD_D( add );
-*/
-#define STDLIB_MATH_BASE_NAPI_MODULE_DDDDD_D( fcn )                            \
-	static napi_value stdlib_math_base_napi_ddddd_d_wrapper(                   \
-		napi_env env,                                                          \
-		napi_callback_info info                                                \
-	) {                                                                        \
-		return stdlib_math_base_napi_ddddd_d( env, info, fcn );                \
-	};                                                                         \
-	static napi_value stdlib_math_base_napi_ddddd_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_ddddd_d_wrapper,                             \
-			NULL,                                                              \
-			&fcn                                                               \
-		);                                                                     \
-		assert( status == napi_ok );                                           \
-		return fcn;                                                            \
-	};                                                                         \
-	NAPI_MODULE( NODE_GYP_MODULE_NAME, stdlib_math_base_napi_ddddd_d_init )
-
-/**
-* Macro for registering a Node-API module exporting an interface invoking a quinary function accepting and returning single-precision floating-point numbers.
-*
-* @param fcn   quinary function
-*
-* @example
-* static float addf( const float x, const float y, const float z, const float w, const float u ) {
-*     return x + y + z + w + u;
-* }
-*
-* // ...
-*
-* // Register a Node-API module:
-* STDLIB_MATH_BASE_NAPI_MODULE_FFFFF_F( addf );
-*/
-#define STDLIB_MATH_BASE_NAPI_MODULE_FFFFF_F( fcn )                            \
-	static napi_value stdlib_math_base_napi_fffff_f_wrapper(                   \
-		napi_env env,                                                          \
-		napi_callback_info info                                                \
-	) {                                                                        \
-		return stdlib_math_base_napi_fffff_f( env, info, fcn );                \
-	};                                                                         \
-	static napi_value stdlib_math_base_napi_fffff_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_fffff_f_wrapper,                             \
-			NULL,                                                              \
-			&fcn                                                               \
-		);                                                                     \
-		assert( status == napi_ok );                                           \
-		return fcn;                                                            \
-	};                                                                         \
-	NAPI_MODULE( NODE_GYP_MODULE_NAME, stdlib_math_base_napi_fffff_f_init )
-
-/*
-* If C++, prevent name mangling so that the compiler emits a quinary file having undecorated names, thus mirroring the behavior of a C compiler.
-*/
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
-* Invokes a quinary function accepting and returning double-precision floating-point numbers.
-*/
-napi_value stdlib_math_base_napi_ddddd_d( napi_env env, napi_callback_info info, double (*fcn)( double, double, double, double, double ) );
-
-/**
-* Invokes a quinary function accepting and returning single-precision floating-point numbers.
-*/
-napi_value stdlib_math_base_napi_fffff_f( napi_env env, napi_callback_info info, float (*fcn)( float, float, float, float, float ) );
-
-#ifdef __cplusplus
-}
-#endif
+// NOTE: keep in alphabetical order...
+#include "stdlib/math/base/napi/quinary/ddddd_d.h"
+#include "stdlib/math/base/napi/quinary/fffff_f.h"
 
 #endif // !STDLIB_MATH_BASE_NAPI_QUINARY_H

package/manifest.json

@@ -1,38 +1,39 @@
 {
-	"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/ddddd_d.c",
+        "./src/fffff_f.c"
+      ],
+      "include": [
+        "./include"
+      ],
+      "libraries": [],
+      "libpath": [],
+      "dependencies": []
+    }
+  ]
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stdlib/math-base-napi-quinary",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "description": "C APIs for registering a Node-API module exporting an interface for invoking a quinary 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.3"
   },
   "devDependencies": {},
   "engines": {
@@ -65,11 +65,6 @@
     "map",
     "transform"
   ],
-  "__stdlib__": {
-    "envs": {
-      "browser": false
-    }
-  },
   "funding": {
     "type": "opencollective",
     "url": "https://opencollective.com/stdlib"

package/src/addon.c

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

package/src/ddddd_d.c

@@ -0,0 +1,125 @@
+/**
+* @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/quinary/ddddd_d.h"
+#include <node_api.h>
+#include <assert.h>
+
+/**
+* Invokes a quinary 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.
+*     -   `u`: input value.
+*
+* @param env    environment under which the function is invoked
+* @param info   callback data
+* @param fcn    quinary function
+* @return       function return value as a Node-API double-precision floating-point number
+*/
+napi_value stdlib_math_base_napi_ddddd_d( napi_env env, napi_callback_info info, double (*fcn)( double, double, double, double, double ) ) {
+	napi_status status;
+
+	size_t argc = 5;
+	napi_value argv[ 5 ];
+	status = napi_get_cb_info( env, info, &argc, argv, NULL, NULL );
+	assert( status == napi_ok );
+
+	if ( argc < 5 ) {
+		status = napi_throw_error( env, NULL, "invalid invocation. Must provide five 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;
+	}
+
+	napi_valuetype vtype4;
+	status = napi_typeof( env, argv[ 4 ], &vtype4 );
+	assert( status == napi_ok );
+	if ( vtype4 != napi_number ) {
+		status = napi_throw_type_error( env, NULL, "invalid argument. Fifth 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 );
+
+	double u;
+	status = napi_get_value_double( env, argv[ 4 ], &u );
+	assert( status == napi_ok );
+
+	napi_value v;
+	status = napi_create_double( env, fcn( x, y, z, w, u ), &v );
+	assert( status == napi_ok );
+
+	return v;
+}

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

@@ -1,7 +1,7 @@
 /**
 * @license Apache-2.0
 *
-* Copyright (c) 2023 The Stdlib Authors.
+* 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.
@@ -16,115 +16,10 @@
 * limitations under the License.
 */
 
-#include "stdlib/math/base/napi/quinary.h"
+#include "stdlib/math/base/napi/quinary/fffff_f.h"
 #include <node_api.h>
-#include <stdint.h>
 #include <assert.h>
 
-/**
-* Invokes a quinary 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.
-*     -   `u`: input value.
-*
-* @param env    environment under which the function is invoked
-* @param info   callback data
-* @param fcn    quinary function
-* @return       function return value as a Node-API double-precision floating-point number
-*/
-napi_value stdlib_math_base_napi_ddddd_d( napi_env env, napi_callback_info info, double (*fcn)( double, double, double, double, double ) ) {
-	napi_status status;
-
-	size_t argc = 5;
-	napi_value argv[ 5 ];
-	status = napi_get_cb_info( env, info, &argc, argv, NULL, NULL );
-	assert( status == napi_ok );
-
-	if ( argc < 5 ) {
-		status = napi_throw_error( env, NULL, "invalid invocation. Must provide five 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;
-	}
-
-	napi_valuetype vtype4;
-	status = napi_typeof( env, argv[ 4 ], &vtype4 );
-	assert( status == napi_ok );
-	if ( vtype4 != napi_number ) {
-		status = napi_throw_type_error( env, NULL, "invalid argument. Fifth 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 );
-
-	double u;
-	status = napi_get_value_double( env, argv[ 4 ], &u );
-	assert( status == napi_ok );
-
-	napi_value v;
-	status = napi_create_double( env, fcn( x, y, z, w, u ), &v );
-	assert( status == napi_ok );
-
-	return v;
-}
-
 /**
 * Invokes a quinary function accepting and returning single-precision floating-point numbers.
 *