@ohos-ports/stdlib-complex-real 0.2.1-beta.0 → 0.2.1-beta.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ohos-ports/stdlib-complex-real",
-  "version": "0.2.1-beta.0",
+  "version": "0.2.1-beta.1",
   "description": "Return the real component of a double-precision complex floating-point number.",
   "license": "Apache-2.0",
   "author": {
@@ -27,7 +27,7 @@
   "repository": {
     "type": "git",
     "url": "https://github.com/ohos-ports/ohos-ports.git",
-    "directory": "ports/stdlib-complex-real/0.2.1"
+    "directory": "ports/@stdlib/complex-real/0.2.1"
   },
   "bugs": {
     "url": "https://github.com/ohos-ports/ohos-ports/issues"
@@ -36,6 +36,7 @@
     "@stdlib/complex-float64": "^0.2.1"
   },
   "devDependencies": {},
+  "bundleDependencies": true,
   "engines": {
     "node": ">=0.10.0",
     "npm": ">2.7.0"
@@ -46,11 +47,11 @@
     "freebsd",
     "linux",
     "macos",
+    "openharmony",
     "openbsd",
     "sunos",
     "win32",
-    "windows",
-    "openharmony"
+    "windows"
   ],
   "keywords": [
     "stdlib",
@@ -69,6 +70,5 @@
   "funding": {
     "type": "opencollective",
     "url": "https://opencollective.com/stdlib"
-  },
-  "bundleDependencies": true
-}
+  }
+}

package/node_modules/@stdlib/complex-float32/include/stdlib/complex/float32.h

@@ -1,148 +0,0 @@
-/**
-* @license Apache-2.0
-*
-* Copyright (c) 2021 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_COMPLEX_FLOAT32_H
-#define STDLIB_COMPLEX_FLOAT32_H
-
-#include <complex.h>
-#include <stdint.h>
-
-/*
-* If C++, prevent name mangling so that the compiler emits a binary file having undecorated names, thus mirroring the behavior of a C compiler.
-*/
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-// Check for C11 support where we can precisely define a complex number and thus avoid issues concerning infinities and NaNs as real and/or imaginary components... (TODO: revisit the following check; similar to NumPy, we may want to check for a compile time variable (e.g., STDLIB_USE_C99_COMPLEX), rather than checking for C11 support, especially if we are not using C11 functionality)
-#if defined(_Imaginary_I) && defined(CMPLXF)
-
-/**
-* An opaque type definition for a single-precision complex floating-point number.
-*/
-typedef float complex stdlib_complex64_t;
-
-// If we aren't going to use the native complex number type, we need to define a complex number as an "opaque" struct (here, "opaque" meaning type consumers should **not** be accessing the components directly, but only through dedicated functions) for storing the real and imaginary components...
-#else
-
-/**
-* An opaque type definition for a single-precision complex floating-point number.
-*
-* @example
-* stdlib_complex64_t z;
-*
-* // Set the real component:
-* z.re = 5.0f;
-*
-* // Set the imaginary component:
-* z.im = 2.0f;
-*/
-typedef struct {
-	/**
-	* Real component.
-	*/
-	float re;
-
-	/**
-	* Imaginary component.
-	*/
-	float im;
-} stdlib_complex64_t;
-
-#endif
-
-/**
-* An opaque type definition for a union for accessing the real and imaginary parts of a single-precision complex floating-point number.
-*
-* @example
-* float realf( const stdlib_complex64_t z ) {
-*     stdlib_complex64_parts_t v;
-*
-*     // Assign a single-precision complex floating-point number:
-*     v.value = z;
-*
-*     // Extract the real component:
-*     float re = v.parts[ 0 ];
-*
-*     return re;
-* }
-*
-* // ...
-*
-* // Create a complex number:
-* stdlib_complex64_t z = stdlib_complex64( 5.0f, 2.0f );
-*
-* // ...
-*
-* // Access the real component:
-* float re = realf( z );
-* // returns 5.0f
-*/
-typedef union {
-	// An opaque type for the output value (e.g., could be a `struct` or a C99 complex number):
-	stdlib_complex64_t value;
-
-	// Leverage the fact that C99 specifies that complex numbers have the same representation and alignment as a two-element array (see <https://en.cppreference.com/w/c/language/arithmetic_types#Complex_floating_types>), where the first element is the real component and the second element is the imaginary component, thus allowing us to create a complex number irrespective of its native data type (e.g., `struct` vs `float complex`):
-	float parts[ 2 ];
-} stdlib_complex64_parts_t;
-
-/**
-* Returns a single-precision complex floating-point number.
-*/
-stdlib_complex64_t stdlib_complex64( const float real, const float imag );
-
-/**
-* Converts a single-precision floating-point number to a single-precision complex floating-point number.
-*/
-stdlib_complex64_t stdlib_complex64_from_float32( const float real );
-
-/**
-* Converts a double-precision floating-point number to a single-precision complex floating-point number.
-*/
-stdlib_complex64_t stdlib_complex64_from_float64( const double real );
-
-/**
-* Converts (copies) a single-precision complex floating-point number to a single-precision complex floating-point number.
-*/
-stdlib_complex64_t stdlib_complex64_from_complex64( const stdlib_complex64_t z );
-
-/**
-* Converts a signed 8-bit integer to a single-precision complex floating-point number.
-*/
-stdlib_complex64_t stdlib_complex64_from_int8( const int8_t real );
-
-/**
-* Converts an unsigned 8-bit integer to a single-precision complex floating-point number.
-*/
-stdlib_complex64_t stdlib_complex64_from_uint8( const uint8_t real );
-
-/**
-* Converts a signed 16-bit integer to a single-precision complex floating-point number.
-*/
-stdlib_complex64_t stdlib_complex64_from_int16( const int16_t real );
-
-/**
-* Converts an unsigned 16-bit integer to a single-precision complex floating-point number.
-*/
-stdlib_complex64_t stdlib_complex64_from_uint16( const uint16_t real );
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif // !STDLIB_COMPLEX_FLOAT32_H

package/node_modules/@stdlib/complex-float32/src/main.c

@@ -1,151 +0,0 @@
-/**
-* @license Apache-2.0
-*
-* Copyright (c) 2021 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/complex/float32.h"
-#include <stdint.h>
-
-/**
-* Returns a single-precision complex floating-point number.
-*
-* @param real     real component
-* @param imag     imaginary component
-* @return         single-precision complex floating-point number
-*
-* @example
-* stdlib_complex64_t z = stdlib_complex64( 5.0f, 2.0f );
-*/
-stdlib_complex64_t stdlib_complex64( const float real, const float imag ) {
-	stdlib_complex64_parts_t z;
-	z.parts[ 0 ] = real;
-	z.parts[ 1 ] = imag; // cppcheck-suppress unreadVariable
-	return z.value;
-}
-
-/**
-* Converts a single-precision floating-point number to a single-precision complex floating-point number.
-*
-* @param real    real component
-* @return        single-precision complex floating-point number
-*
-* @example
-* stdlib_complex64_t z = stdlib_complex64_from_float32( 5.0f );
-*/
-stdlib_complex64_t stdlib_complex64_from_float32( const float real ) {
-	stdlib_complex64_parts_t z;
-	z.parts[ 0 ] = real;
-	z.parts[ 1 ] = 0.0f; // cppcheck-suppress unreadVariable
-	return z.value;
-}
-
-/**
-* Converts a double-precision floating-point number to a single-precision complex floating-point number.
-*
-* @param real    real component
-* @return        single-precision complex floating-point number
-*
-* @example
-* stdlib_complex64_t z = stdlib_complex64_from_float64( 5.0 );
-*/
-stdlib_complex64_t stdlib_complex64_from_float64( const double real ) {
-	stdlib_complex64_parts_t z;
-	z.parts[ 0 ] = (float)real;
-	z.parts[ 1 ] = 0.0f; // cppcheck-suppress unreadVariable
-	return z.value;
-}
-
-/**
-* Converts (copies) a single-precision complex floating-point number to a single-precision complex floating-point number.
-*
-* @param z       single-precision complex floating-point number
-* @return        single-precision complex floating-point number
-*
-* @example
-* stdlib_complex64_t z1 = stdlib_complex64( 5.0f, 3.0f );
-* stdlib_complex64_t z2 = stdlib_complex64_from_complex64( z1 );
-*/
-stdlib_complex64_t stdlib_complex64_from_complex64( const stdlib_complex64_t z ) {
-	stdlib_complex64_parts_t v1 = { z };
-	stdlib_complex64_parts_t v2;
-	v2.parts[ 0 ] = v1.parts[ 0 ];
-	v2.parts[ 1 ] = v1.parts[ 1 ]; // cppcheck-suppress unreadVariable
-	return v2.value;
-}
-
-/**
-* Converts a signed 8-bit integer to a single-precision complex floating-point number.
-*
-* @param real    real component
-* @return        single-precision complex floating-point number
-*
-* @example
-* stdlib_complex64_t z = stdlib_complex64_from_int8( 5 );
-*/
-stdlib_complex64_t stdlib_complex64_from_int8( const int8_t real ) {
-	stdlib_complex64_parts_t z;
-	z.parts[ 0 ] = (float)real;
-	z.parts[ 1 ] = 0.0f; // cppcheck-suppress unreadVariable
-	return z.value;
-}
-
-/**
-* Converts an unsigned 8-bit integer to a single-precision complex floating-point number.
-*
-* @param real    real component
-* @return        single-precision complex floating-point number
-*
-* @example
-* stdlib_complex64_t z = stdlib_complex64_from_uint8( 5 );
-*/
-stdlib_complex64_t stdlib_complex64_from_uint8( const uint8_t real ) {
-	stdlib_complex64_parts_t z;
-	z.parts[ 0 ] = (float)real;
-	z.parts[ 1 ] = 0.0f; // cppcheck-suppress unreadVariable
-	return z.value;
-}
-
-/**
-* Converts a signed 16-bit integer to a single-precision complex floating-point number.
-*
-* @param real    real component
-* @return        single-precision complex floating-point number
-*
-* @example
-* stdlib_complex64_t z = stdlib_complex64_from_int16( 5 );
-*/
-stdlib_complex64_t stdlib_complex64_from_int16( const int16_t real ) {
-	stdlib_complex64_parts_t z;
-	z.parts[ 0 ] = (float)real;
-	z.parts[ 1 ] = 0.0f; // cppcheck-suppress unreadVariable
-	return z.value;
-}
-
-/**
-* Converts an unsigned 16-bit integer to a single-precision complex floating-point number.
-*
-* @param real    real component
-* @return        single-precision complex floating-point number
-*
-* @example
-* stdlib_complex64_t z = stdlib_complex64_from_uint16( 5 );
-*/
-stdlib_complex64_t stdlib_complex64_from_uint16( const uint16_t real ) {
-	stdlib_complex64_parts_t z;
-	z.parts[ 0 ] = (float)real;
-	z.parts[ 1 ] = 0.0f; // cppcheck-suppress unreadVariable
-	return z.value;
-}

package/node_modules/@stdlib/complex-float64/include/stdlib/complex/float64.h

@@ -1,169 +0,0 @@
-/**
-* @license Apache-2.0
-*
-* Copyright (c) 2021 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_COMPLEX_FLOAT64_H
-#define STDLIB_COMPLEX_FLOAT64_H
-
-#include "stdlib/complex/float32.h"
-#include <complex.h>
-#include <stdint.h>
-
-/*
-* If C++, prevent name mangling so that the compiler emits a binary file having undecorated names, thus mirroring the behavior of a C compiler.
-*/
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-// Check for C11 support where we can precisely define a complex number and thus avoid issues concerning infinities and NaNs as real and/or imaginary components... (TODO: revisit the following check; similar to NumPy, we may want to check for a compile time variable (e.g., STDLIB_USE_C99_COMPLEX), rather than checking for C11 support, especially if we are not using C11 functionality)
-#if defined(_Imaginary_I) && defined(CMPLX)
-
-/**
-* An opaque type definition for a double-precision complex floating-point number.
-*/
-typedef double complex stdlib_complex128_t;
-
-// If we aren't going to use the native complex number type, we need to define a complex number as an "opaque" struct (here, "opaque" meaning type consumers should **not** be accessing the components directly, but only through dedicated functions) for storing the real and imaginary components...
-#else
-
-/**
-* An opaque type definition for a double-precision complex floating-point number.
-*
-* @example
-* stdlib_complex128_t z;
-*
-* // Set the real component:
-* z.re = 5.0;
-*
-* // Set the imaginary component:
-* z.im = 2.0;
-*/
-typedef struct {
-	/**
-	* Real component.
-	*/
-	double re;
-
-	/**
-	* Imaginary component.
-	*/
-	double im;
-} stdlib_complex128_t;
-
-#endif
-
-/**
-* An opaque type definition for a union for accessing the real and imaginary parts of a double-precision complex floating-point number.
-*
-* @example
-* double real( const stdlib_complex128_t z ) {
-*     stdlib_complex128_parts_t v;
-*
-*     // Assign a double-precision complex floating-point number:
-*     v.value = z;
-*
-*     // Extract the real component:
-*     double re = v.parts[ 0 ];
-*
-*     return re;
-* }
-*
-* // ...
-*
-* // Create a complex number:
-* stdlib_complex128_t z = stdlib_complex128( 5.0, 2.0 );
-*
-* // ...
-*
-* // Access the real component:
-* double re = real( z );
-* // returns 5.0
-*/
-typedef union {
-	// An opaque type for the output value (e.g., could be a `struct` or a C99 complex number):
-	stdlib_complex128_t value;
-
-	// Leverage the fact that C99 specifies that complex numbers have the same representation and alignment as a two-element array (see <https://en.cppreference.com/w/c/language/arithmetic_types#Complex_floating_types>), where the first element is the real component and the second element is the imaginary component, thus allowing us to create a complex number irrespective of its native data type (e.g., `struct` vs `double complex`):
-	double parts[ 2 ];
-} stdlib_complex128_parts_t;
-
-/**
-* Returns a double-precision complex floating-point number.
-*/
-stdlib_complex128_t stdlib_complex128( const double real, const double imag );
-
-/**
-* Converts a single-precision floating-point number to a double-precision complex floating-point number.
-*/
-stdlib_complex128_t stdlib_complex128_from_float32( const float real );
-
-/**
-* Converts a double-precision floating-point number to a double-precision complex floating-point number.
-*/
-stdlib_complex128_t stdlib_complex128_from_float64( const double real );
-
-/**
-* Converts a single-precision complex floating-point number to a double-precision complex floating-point number.
-*/
-stdlib_complex128_t stdlib_complex128_from_complex64( const stdlib_complex64_t z );
-
-/**
-* Converts (copies) a double-precision complex floating-point number to a double-precision complex floating-point number.
-*/
-stdlib_complex128_t stdlib_complex128_from_complex128( const stdlib_complex128_t z );
-
-/**
-* Converts a signed 8-bit integer to a double-precision complex floating-point number.
-*/
-stdlib_complex128_t stdlib_complex128_from_int8( const int8_t real );
-
-/**
-* Converts an unsigned 8-bit integer to a double-precision complex floating-point number.
-*/
-stdlib_complex128_t stdlib_complex128_from_uint8( const uint8_t real );
-
-/**
-* Converts a signed 16-bit integer to a double-precision complex floating-point number.
-*/
-stdlib_complex128_t stdlib_complex128_from_int16( const int16_t real );
-
-/**
-* Converts an unsigned 16-bit integer to a double-precision complex floating-point number.
-*/
-stdlib_complex128_t stdlib_complex128_from_uint16( const uint16_t real );
-
-/**
-* Converts a signed 32-bit integer to a double-precision complex floating-point number.
-*/
-stdlib_complex128_t stdlib_complex128_from_int32( const int32_t real );
-
-/**
-* Converts an unsigned 32-bit integer to a double-precision complex floating-point number.
-*/
-stdlib_complex128_t stdlib_complex128_from_uint32( const uint32_t real );
-
-/**
-* Converts a double-precision complex floating-point number to a single-precision complex floating-point number.
-*/
-stdlib_complex64_t stdlib_complex128_to_complex64( const stdlib_complex128_t z );
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif // !STDLIB_COMPLEX_FLOAT64_H

package/node_modules/@stdlib/complex-float64/src/main.c

@@ -1,224 +0,0 @@
-/**
-* @license Apache-2.0
-*
-* Copyright (c) 2021 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/complex/float64.h"
-#include "stdlib/complex/float32.h"
-#include <stdint.h>
-
-/**
-* Returns a double-precision complex floating-point number.
-*
-* @param real     real component
-* @param imag     imaginary component
-* @return         double-precision complex floating-point number
-*
-* @example
-* stdlib_complex128_t z = stdlib_complex128( 5.0, 2.0 );
-*/
-stdlib_complex128_t stdlib_complex128( const double real, const double imag ) {
-	stdlib_complex128_parts_t z;
-	z.parts[ 0 ] = real;
-	z.parts[ 1 ] = imag; // cppcheck-suppress unreadVariable
-	return z.value;
-}
-
-/**
-* Converts a single-precision floating-point number to a double-precision complex floating-point number.
-*
-* @param real    real component
-* @return        double-precision complex floating-point number
-*
-* @example
-* stdlib_complex128_t z = stdlib_complex128_from_float32( 5.0f );
-*/
-stdlib_complex128_t stdlib_complex128_from_float32( const float real ) {
-	stdlib_complex128_parts_t z;
-	z.parts[ 0 ] = (double)real;
-	z.parts[ 1 ] = 0.0; // cppcheck-suppress unreadVariable
-	return z.value;
-}
-
-/**
-* Converts a double-precision floating-point number to a double-precision complex floating-point number.
-*
-* @param real    real component
-* @return        double-precision complex floating-point number
-*
-* @example
-* stdlib_complex128_t z = stdlib_complex128_from_float64( 5.0 );
-*/
-stdlib_complex128_t stdlib_complex128_from_float64( const double real ) {
-	stdlib_complex128_parts_t z;
-	z.parts[ 0 ] = real;
-	z.parts[ 1 ] = 0.0; // cppcheck-suppress unreadVariable
-	return z.value;
-}
-
-/**
-* Converts a single-precision complex floating-point number to a double-precision complex floating-point number.
-*
-* @param z       single-precision complex floating-point number
-* @return        double-precision complex floating-point number
-*
-* @example
-* #include "stdlib/complex/float32.h"
-*
-* stdlib_complex64_t z1 = stdlib_complex64( 5.0f, 3.0f );
-* stdlib_complex128_t z2 = stdlib_complex128_from_complex64( z1 );
-*/
-stdlib_complex128_t stdlib_complex128_from_complex64( const stdlib_complex64_t z ) {
-	stdlib_complex64_parts_t v1 = { z };
-	stdlib_complex128_parts_t v2;
-	v2.parts[ 0 ] = (double)v1.parts[ 0 ];
-	v2.parts[ 1 ] = (double)v1.parts[ 1 ]; // cppcheck-suppress unreadVariable
-	return v2.value;
-}
-
-/**
-* Converts (copies) a double-precision complex floating-point number to a double-precision complex floating-point number.
-*
-* @param z       double-precision complex floating-point number
-* @return        double-precision complex floating-point number
-*
-* @example
-* stdlib_complex128_t z1 = stdlib_complex128( 5.0, 3.0 );
-* stdlib_complex128_t z2 = stdlib_complex128_from_complex128( z1 );
-*/
-stdlib_complex128_t stdlib_complex128_from_complex128( const stdlib_complex128_t z ) {
-	stdlib_complex128_parts_t v1 = { z };
-	stdlib_complex128_parts_t v2;
-	v2.parts[ 0 ] = v1.parts[ 0 ];
-	v2.parts[ 1 ] = v1.parts[ 1 ]; // cppcheck-suppress unreadVariable
-	return v2.value;
-}
-
-/**
-* Converts a signed 8-bit integer to a double-precision complex floating-point number.
-*
-* @param real    real component
-* @return        double-precision complex floating-point number
-*
-* @example
-* stdlib_complex128_t z = stdlib_complex128_from_int8( 5 );
-*/
-stdlib_complex128_t stdlib_complex128_from_int8( const int8_t real ) {
-	stdlib_complex128_parts_t z;
-	z.parts[ 0 ] = (double)real;
-	z.parts[ 1 ] = 0.0; // cppcheck-suppress unreadVariable
-	return z.value;
-}
-
-/**
-* Converts an unsigned 8-bit integer to a double-precision complex floating-point number.
-*
-* @param real    real component
-* @return        double-precision complex floating-point number
-*
-* @example
-* stdlib_complex128_t z = stdlib_complex128_from_uint8( 5 );
-*/
-stdlib_complex128_t stdlib_complex128_from_uint8( const uint8_t real ) {
-	stdlib_complex128_parts_t z;
-	z.parts[ 0 ] = (double)real;
-	z.parts[ 1 ] = 0.0; // cppcheck-suppress unreadVariable
-	return z.value;
-}
-
-/**
-* Converts a signed 16-bit integer to a double-precision complex floating-point number.
-*
-* @param real    real component
-* @return        double-precision complex floating-point number
-*
-* @example
-* stdlib_complex128_t z = stdlib_complex128_from_int16( 5 );
-*/
-stdlib_complex128_t stdlib_complex128_from_int16( const int16_t real ) {
-	stdlib_complex128_parts_t z;
-	z.parts[ 0 ] = (double)real;
-	z.parts[ 1 ] = 0.0; // cppcheck-suppress unreadVariable
-	return z.value;
-}
-
-/**
-* Converts an unsigned 16-bit integer to a double-precision complex floating-point number.
-*
-* @param real    real component
-* @return        double-precision complex floating-point number
-*
-* @example
-* stdlib_complex128_t z = stdlib_complex128_from_uint16( 5 );
-*/
-stdlib_complex128_t stdlib_complex128_from_uint16( const uint16_t real ) {
-	stdlib_complex128_parts_t z;
-	z.parts[ 0 ] = (double)real;
-	z.parts[ 1 ] = 0.0; // cppcheck-suppress unreadVariable
-	return z.value;
-}
-
-/**
-* Converts a signed 32-bit integer to a double-precision complex floating-point number.
-*
-* @param real    real component
-* @return        double-precision complex floating-point number
-*
-* @example
-* stdlib_complex128_t z = stdlib_complex128_from_int32( 5 );
-*/
-stdlib_complex128_t stdlib_complex128_from_int32( const int32_t real ) {
-	stdlib_complex128_parts_t z;
-	z.parts[ 0 ] = (double)real;
-	z.parts[ 1 ] = 0.0; // cppcheck-suppress unreadVariable
-	return z.value;
-}
-
-/**
-* Converts an unsigned 32-bit integer to a double-precision complex floating-point number.
-*
-* @param real    real component
-* @return        double-precision complex floating-point number
-*
-* @example
-* stdlib_complex128_t z = stdlib_complex128_from_uint32( 5 );
-*/
-stdlib_complex128_t stdlib_complex128_from_uint32( const uint32_t real ) {
-	stdlib_complex128_parts_t z;
-	z.parts[ 0 ] = (double)real;
-	z.parts[ 1 ] = 0.0; // cppcheck-suppress unreadVariable
-	return z.value;
-}
-
-/**
-* Converts a double-precision complex floating-point number to a single-precision complex floating-point number.
-*
-* @param z       double-precision complex floating-point number
-* @return        single-precision complex floating-point number
-*
-* @example
-* #include "stdlib/complex/float32.h"
-*
-* stdlib_complex128_t z1 = stdlib_complex128( 5.0, 3.0 );
-* stdlib_complex64_t z2 = stdlib_complex128_to_complex64( z1 );
-*/
-stdlib_complex64_t stdlib_complex128_to_complex64( const stdlib_complex128_t z ) {
-	stdlib_complex128_parts_t v1 = { z };
-	stdlib_complex64_parts_t v2;
-	v2.parts[ 0 ] = (float)v1.parts[ 0 ];
-	v2.parts[ 1 ] = (float)v1.parts[ 1 ]; // cppcheck-suppress unreadVariable
-	return v2.value;
-}

package/node_modules/@stdlib/constants-float64-pinf/include/stdlib/constants/float64/pinf.h

@@ -1,29 +0,0 @@
-/**
-* @license Apache-2.0
-*
-* Copyright (c) 2022 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_CONSTANTS_FLOAT64_PINF_H
-#define STDLIB_CONSTANTS_FLOAT64_PINF_H
-
-#include <math.h>
-
-/**
-* Macro for double-precision floating-point positive infinity.
-*/
-#define STDLIB_CONSTANT_FLOAT64_PINF HUGE_VAL
-
-#endif // !STDLIB_CONSTANTS_FLOAT64_PINF_H