added stdlib/napi/argv-complex128

Author: Utkarsh Gupta

lib/node_modules/@stdlib/napi/argv-complex128/README.md

@@ -2,7 +2,7 @@
 
 @license Apache-2.0
 
-Copyright (c) 2022 The Stdlib Authors.
+Copyright (c) 2024 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.
@@ -18,9 +18,9 @@ limitations under the License.
 
 -->
 
-# argv_complex128array
+# argv_complex128
 
-> Convert a Node-API value to a double-precision complex floating-point array.
+> Convert a Node-API value to a double-precision complex floating-point number.
 
 <!-- Section to include introductory text. Make sure to keep an empty line after the intro `section` element and another before the `/section` close. -->
 
@@ -37,7 +37,7 @@ limitations under the License.
 ## Usage
 
 ```javascript
-var headerDir = require( '@stdlib/napi/argv-complex128array' );
+var headerDir = require( '@stdlib/napi/argv-complex128' );
 ```
 
 #### headerDir
@@ -68,7 +68,7 @@ var dir = headerDir;
 ## Examples
 
 ```javascript
-var headerDir = require( '@stdlib/napi/argv-complex128array' );
+var headerDir = require( '@stdlib/napi/argv-complex128' );
 
 console.log( headerDir );
 // => <string>
@@ -101,27 +101,25 @@ console.log( headerDir );
 ### Usage
 
 ```c
-#include "stdlib/napi/argv_complex128array.h"
+#include "stdlib/napi/argv_complex128.h"
 ```
 
-#### stdlib_napi_argv_complex128array( env, value, \*\*data, \*length, \*message, \*err )
+#### stdlib_napi_argv_complex128( env, value, \*out, \*message, \*err )
 
-Converts a Node-API value to a double-precision complex floating-point array.
+Converts a Node-API value to a double-precision complex floating-point number ( stdlib_complex128_t ).
 
 ```c
-#include "stdlib/napi/argv_complex128array.h"
+#include "stdlib/napi/argv_complex128.h"
 #include <node_api.h>
-#include <stdint.h>
 
 static napi_value addon( napi_env env, napi_callback_info info ) {
     napi_value value;
 
     // ...
 
-    double *X;
-    int64_t len;
+    stdlib_complex128_t out;
     napi_value err;
-    napi_status status = stdlib_napi_argv_complex128array( env, value, &X, &len, "Must be a typed array.", &err );
+    napi_status status = stdlib_napi_argv_complex128( env, value, &out, "Must be a Complex128 instance.", &err );
     assert( status == napi_ok );
     if ( err != NULL ) {
         assert( napi_throw( env, err ) == napi_ok );
@@ -136,64 +134,49 @@ The function accepts the following arguments:
 
 -   **env**: `[in] napi_env` environment under which the function is invoked.
 -   **value**: `[in] napi_value` Node-API value.
--   **data**: `[out] double**` pointer for returning a reference to the output array.
--   **length**: `[out] int64_t*` pointer for returning the number of array elements.
+-   **out**: `[out] stdlib_complex_128_t*` destination for storing output value.
 -   **message**: `[in] char*` error message.
 -   **err**: `[out] napi_value*` pointer for storing a JavaScript error. If not provided a number, the function sets `err` with a JavaScript error; otherwise, `err` is set to `NULL`.
 
 ```c
-napi_status stdlib_napi_argv_complex128array( const napi_env env, const napi_value value, double **data, int64_t *length, const char *message, napi_value *err );
+napi_status stdlib_napi_argv_complex128( const napi_env env, const napi_value value, stdlib_complex128_t *out, const char *message, napi_value *err );
 ```
 
 The function returns a `napi_status` status code indicating success or failure (returns `napi_ok` if success).
 
-#### STDLIB_NAPI_ARGV_COMPLEX128ARRAY( env, X, len, argv, index )
+#### STDLIB_NAPI_ARGV_COMPLEX128( env, name, argv, index )
 
-Macro for converting an add-on callback argument to a double-precision complex floating-point array.
+Macro for converting an add-on callback argument to a double-precision complex floating-point number.
 
 ```c
-#include "stdlib/napi/argv_complex128array.h"
+#include "stdlib/napi/argv_complex128.h"
 #include "stdlib/napi/argv.h"
+#include "stdlib/complex/float64.h"
 #include <node_api.h>
-#include <stdint.h>
 
-static void fcn( const double *X, const int64_t xlen, double *Y, const int64_t ylen ) {
-    int64_t len;
-    int64_t i;
-
-    if ( xlen > ylen ) {
-        len = ylen;
-    } else {
-        len = xlen;
-    }
-    for ( i = 0; i < len*2; i++ ) {
-        Y[ i ] = X[ i ];
-    }
+static stdlib_complex128_t fcn( const stdlib_complex128_t v ) {
+    return v;
 }
 
 // ...
 
 static napi_value addon( napi_env env, napi_callback_info info ) {
     // Retrieve add-on callback arguments:
-    STDLIB_NAPI_ARGV( env, info, argv, argc, 2 );
+    STDLIB_NAPI_ARGV( env, info, argv, argc, 1 );
 
     // Convert the first argument to a C type:
-    STDLIB_NAPI_ARGV_COMPLEX128ARRAY( env, X, xlen, argv, 0 );
-
-    // Convert the second argument to a C type:
-    STDLIB_NAPI_ARGV_COMPLEX128ARRAY( env, Y, ylen, argv, 1 );
+    STDLIB_NAPI_ARGV_COMPLEX128( env, value, argv, 0 );
 
     // ...
 
-    fcn( X, xlen, Y, ylen );
+    stdlib_complex128_t out = fcn( value );
 }
 ```
 
 The macro expects the following arguments:
 
 -   **env**: environment under which the callback is invoked.
--   **X**: output variable name for the array.
--   **len**: output variable name for the array length.
+-   **name**: output variable name.
 -   **argv**: name of the variable containing add-on callback arguments.
 -   **index**: argument index.
 
@@ -205,10 +188,6 @@ The macro expects the following arguments:
 
 <section class="notes">
 
-## Notes
-
--   A double-precision complex floating-point array is a double-precision floating-point array having interleaved real and imaginary components, such that each element of the double-precision complex floating-point array consists of two adjacent (in memory) double-precision floating-point numbers.
-
 </section>
 
 <!-- /.notes -->

lib/node_modules/@stdlib/napi/argv-complex128/docs/types/index.d.ts

@@ -1,7 +1,7 @@
 /*
 * @license Apache-2.0
 *
-* Copyright (c) 2022 The Stdlib Authors.
+* Copyright (c) 2024 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.

lib/node_modules/@stdlib/napi/argv-complex128/docs/types/test.ts

@@ -1,7 +1,7 @@
 /*
 * @license Apache-2.0
 *
-* Copyright (c) 2022 The Stdlib Authors.
+* Copyright (c) 2024 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.

lib/node_modules/@stdlib/napi/argv-complex128/include/stdlib/napi/argv_complex128.h

@@ -1,7 +1,7 @@
 /**
 * @license Apache-2.0
 *
-* Copyright (c) 2022 The Stdlib Authors.
+* Copyright (c) 2024 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,67 +16,52 @@
 * limitations under the License.
 */
 
-#ifndef STDLIB_NAPI_ARGV_COMPLEX128ARRAY_H
-#define STDLIB_NAPI_ARGV_COMPLEX128ARRAY_H
+#ifndef STDLIB_NAPI_ARGV_COMPLEX128_H
+#define STDLIB_NAPI_ARGV_COMPLEX128_H
 
 #include "stdlib/napi/argv.h"
 #include "stdlib/assert/napi/status_ok.h"
+#include "stdlib/complex/float64.h"
 #include <node_api.h>
-#include <stdint.h>
 
 /**
-* Macro for converting an add-on callback argument to a double-precision complex floating-point array.
+* Macro for converting an add-on callback argument to a double-precision complex floating-point number.
 *
 * @param env      environment under which the function is invoked
-* @param X        output variable name for the array
-* @param len      output variable name for the array length
+* @param name     output variable name for the array
 * @param argv     name of the variable containing add-on callback arguments
 * @param index    argument index
 *
 * @example
-* #include "stdlib/napi/argv_complex128array.h"
+* #include "stdlib/napi/argv_complex128.h"
 * #include "stdlib/napi/argv.h"
+* #include "stdlib/complex/float64.h"
 * #include <node_api.h>
-* #include <stdint.h>
 *
-* static void fcn( const double *X, const int64_t xlen, double *Y, const int64_t ylen ) {
-*     int64_t len;
-*     int64_t i;
-*
-*     if ( xlen > ylen ) {
-*         len = ylen;
-*     } else {
-*         len = xlen;
-*     }
-*     for ( i = 0; i < len*2; i++ ) {
-*         Y[ i ] = X[ i ];
-*     }
+* static stdlib_complex128_t fcn( const stdlib_complex128_t ) {
+*     return v;
 * }
 *
 * // ...
 *
 * static napi_value addon( napi_env env, napi_callback_info info ) {
 *     // Retrieve add-on callback arguments:
-*     STDLIB_NAPI_ARGV( env, info, argv, argc, 2 );
+*     STDLIB_NAPI_ARGV( env, info, argv, argc, 1 );
 *
 *     // Convert the first argument to a C type:
-*     STDLIB_NAPI_ARGV_COMPLEX128ARRAY( env, X, xlen, argv, 0 );
-*
-*     // Convert the second argument to a C type:
-*     STDLIB_NAPI_ARGV_COMPLEX128ARRAY( env, Y, ylen, argv, 1 );
+*     STDLIB_NAPI_ARGV_COMPLEX128( env, value, argv, 0 );
 *
 *     // ...
 *
-*     fcn( X, xlen, Y, ylen );
+*     stdlib_complex128_t out = fcn( value );
 * }
 */
-#define STDLIB_NAPI_ARGV_COMPLEX128ARRAY( env, X, len, argv, index )           \
-	napi_value __STDLIB_NAPI_ARGV_COMPLEX128ARRAY_ERR_ ## X;                   \
-	int64_t len;                                                               \
-	double *X;                                                                 \
-	stdlib_napi_argv_complex128array( env, argv[ index ], &X, &len, "invalid argument. " STDLIB_NAPI_ARGV_INDEX2ORDINAL( index ) " argument must be a Float64Array.", &__STDLIB_NAPI_ARGV_COMPLEX128ARRAY_ERR_ ## X ); \
-	if ( __STDLIB_NAPI_ARGV_COMPLEX128ARRAY_ERR_ ## X != NULL ) {              \
-		STDLIB_ASSERT_NAPI_STATUS_OK_RET_NULL( env, napi_throw( env, __STDLIB_NAPI_ARGV_COMPLEX128ARRAY_ERR_ ## X ), "" ) \
+#define STDLIB_NAPI_ARGV_COMPLEX128( env, name, argv, index )           \
+	napi_value __STDLIB_NAPI_ARGV_COMPLEX128_ERR_ ## name;                   \
+	stdlib_complex128_t name;                                                                 \
+	stdlib_napi_argv_complex128( env, argv[ index ], &name, "invalid argument. " STDLIB_NAPI_ARGV_INDEX2ORDINAL( index ) " argument must be a Complex128 instance.", &__STDLIB_NAPI_ARGV_COMPLEX128_ERR_ ## name ); \
+	if ( __STDLIB_NAPI_ARGV_COMPLEX128_ERR_ ## name != NULL ) {              \
+		STDLIB_ASSERT_NAPI_STATUS_OK_RET_NULL( env, napi_throw( env, __STDLIB_NAPI_ARGV_COMPLEX128_ERR_ ## name ), "" ) \
 		return NULL;                                                           \
 	}
 
@@ -88,12 +73,12 @@ extern "C" {
 #endif
 
 /**
-* Converts a Node-API value to a double-precision complex floating-point array.
+* Converts a Node-API value to a double-precision complex floating-point number.
 */
-napi_status stdlib_napi_argv_complex128array( const napi_env env, const napi_value value, double **data, int64_t *length, const char *message, napi_value *err );
+napi_status stdlib_napi_argv_complex128( const napi_env env, const napi_value value, stdlib_complex128_t *out, const char *message, napi_value *err );
 
 #ifdef __cplusplus
 }
 #endif
 
-#endif // !STDLIB_NAPI_ARGV_COMPLEX128ARRAY_H
+#endif // !STDLIB_NAPI_ARGV_COMPLEX128_H

lib/node_modules/@stdlib/napi/argv-complex128/lib/native.js

@@ -1,7 +1,7 @@
 /**
 * @license Apache-2.0
 *
-* Copyright (c) 2022 The Stdlib Authors.
+* Copyright (c) 2024 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.
@@ -38,12 +38,12 @@ var addon = require( './../src/addon.node' );
 *
 * var x = new Complex128( 5.0, 3.0 );
 *
-* wrapper( x );
+* wrapper( x ); 
 */
 function wrapper( v ) {
-	// if ( isComplex128Array( v ) ) {
-	// 	v = reinterpret( v, 0 );
-	// }
+	if ( isComplex128( v ) ) {
+		v = { re: v.re, im: v.im };
+	}
 	return addon( v );
 }
 

lib/node_modules/@stdlib/napi/argv-complex128/src/Makefile

@@ -1,7 +1,7 @@
 #/
 # @license Apache-2.0
 #
-# Copyright (c) 2022 The Stdlib Authors.
+# Copyright (c) 2024 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.

lib/node_modules/@stdlib/napi/argv-complex128/src/addon.c

@@ -1,7 +1,7 @@
 /**
 * @license Apache-2.0
 *
-* Copyright (c) 2022 The Stdlib Authors.
+* Copyright (c) 2024 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,11 +16,22 @@
 * limitations under the License.
 */
 
-#include "stdlib/napi/argv_complex128array.h"
+#include "stdlib/napi/argv_complex128.h"
 #include "stdlib/napi/argv.h"
+#include "stdlib/complex/flo	at64.h"
 #include <node_api.h>
 #include <assert.h>
-#include <stdint.h>
+
+/**
+* Identity function.
+*
+* @private
+* @param v      input value
+* @return       input value
+*/
+static stdlib_complex128_t identity( const stdlib_complex128_t v ) {
+	return v;
+}
 
 /**
 * Receives JavaScript callback invocation data.
@@ -31,15 +42,21 @@
 * @return       Node-API value
 */
 static napi_value addon( napi_env env, napi_callback_info info ) {
-	int64_t i;
-
 	STDLIB_NAPI_ARGV( env, info, argv, argc, 1 )
-	STDLIB_NAPI_ARGV_COMPLEX128ARRAY( env, X, len, argv, 0 )
+	STDLIB_NAPI_ARGV_COMPLEX128( env, value, argv, 0 )
+	stdlib_complex128_t out = identity( value );
+	return out;
+	// napi_value v;
+	// napi_status status = napi_create_object(env, &v);
+	// assert(status == napi_ok);
+
+	// status = napi_set_named_property(env, v, "re", out.re);
+	// assert(status == napi_ok);
+
+	// status = napi_set_named_property(env, v, "im", out.im);
+	// assert(status == napi_ok);
 
-	for ( i = 0; i < len*2; i++ ) {
-		X[ i ] = 1.0;
-	}
-	return NULL;
+	// return v;
 }
 
 /**