@stdlib/complex-float32 0.0.3 → 0.0.7

package/NOTICE

@@ -1 +1 @@
-Copyright (c) 2016-2021 The Stdlib Authors.
+Copyright (c) 2016-2022 The Stdlib Authors.

package/README.md

@@ -20,7 +20,7 @@ limitations under the License.
 
 # Complex64
 
-[![NPM version][npm-image]][npm-url] [![Build Status][test-image]][test-url] [![Coverage Status][coverage-image]][coverage-url] [![dependencies][dependencies-image]][dependencies-url]
+[![NPM version][npm-image]][npm-url] [![Build Status][test-image]][test-url] [![Coverage Status][coverage-image]][coverage-url] <!-- [![dependencies][dependencies-image]][dependencies-url] -->
 
 > 64-bit complex number.
 
@@ -197,25 +197,311 @@ var Complex64 = require( '@stdlib/complex-float32' );
 var z = new Complex64( 3.0, -2.0 );
 
 console.log( 'type: %s', typeof z );
-// => type: object
+// => 'type: object'
 
 console.log( 'str: %s', z );
-// => str: 3 - 2i
+// => 'str: 3 - 2i'
 
 console.log( 'real: %d', z.re );
-// => real: 3.0
+// => 'real: 3'
 
 console.log( 'imag: %d', z.im );
-// => imag: -2.0
+// => 'imag: -2'
 
 console.log( 'JSON: %s', JSON.stringify( z ) );
-// => JSON: {"type":"Complex64","re":3,"im":-2}
+// => 'JSON: {"type":"Complex64","re":3,"im":-2}'
 ```
 
 </section>
 
 <!-- /.examples -->
 
+<!-- C interface documentation. -->
+
+* * *
+
+<section class="c">
+
+## C APIs
+
+<!-- Section to include introductory text. Make sure to keep an empty line after the intro `section` element and another before the `/section` close. -->
+
+<section class="intro">
+
+</section>
+
+<!-- /.intro -->
+
+<!-- C usage documentation. -->
+
+<section class="usage">
+
+### Usage
+
+```c
+#include "stdlib/complex/float32.h"
+```
+
+#### stdlib_complex64_t
+
+An opaque type definition for a single-precision complex floating-point number.
+
+```c
+stdlib_complex64_t z = stdlib_complex64( 5.0f, 2.0f );
+```
+
+#### stdlib_complex64_parts_t
+
+An opaque type definition for a union for accessing the real and imaginary parts of a single-precision complex floating-point number.
+
+```c
+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
+```
+
+The union has the following members:
+
+-   **value**: `stdlib_complex64_t` single-precision complex floating-point number.
+
+-   **parts**: `float[]` array having the following elements:
+
+    -   **0**: `float` real component.
+    -   **1**: `float` imaginary component.
+
+#### stdlib_complex64( real, imag )
+
+Returns a single-precision complex floating-point number.
+
+```c
+stdlib_complex64_t z = stdlib_complex64( 5.0f, 2.0f );
+```
+
+The function accepts the following arguments:
+
+-   **real**: `[in] float` real component.
+-   **imag**: `[in] float` imaginary component.
+
+```c
+stdlib_complex64_t stdlib_complex64( const float real, const float imag );
+```
+
+#### stdlib_complex64_from_float32( real )
+
+Converts a single-precision floating-point number to a single-precision complex floating-point number.
+
+```c
+stdlib_complex64_t z = stdlib_complex64_from_float32( 5.0f );
+```
+
+The function accepts the following arguments:
+
+-   **real**: `[in] float` real component.
+
+```c
+stdlib_complex64_t stdlib_complex64_from_float32( const float real );
+```
+
+#### stdlib_complex64_from_float64( real )
+
+Converts a double-precision floating-point number to a single-precision complex floating-point number.
+
+```c
+stdlib_complex64_t z = stdlib_complex64_from_float64( 5.0 );
+```
+
+The function accepts the following arguments:
+
+-   **real**: `[in] double` real component.
+
+```c
+stdlib_complex64_t stdlib_complex64_from_float64( const double real );
+```
+
+#### stdlib_complex64_from_complex64( z )
+
+Converts (copies) a single-precision complex floating-point number to a single-precision complex floating-point number.
+
+```c
+stdlib_complex64_t z1 = stdlib_complex64( 5.0f, 3.0f );
+stdlib_complex64_t z2 = stdlib_complex64_from_complex64( z1 );
+```
+
+The function accepts the following arguments:
+
+-   **z**: `[in] stdlib_complex64_t` single-precision complex floating-point number.
+
+```c
+stdlib_complex64_t stdlib_complex64_from_complex64( const stdlib_complex64_t z );
+```
+
+#### stdlib_complex64_from_int8( real )
+
+Converts a signed 8-bit integer to a single-precision complex floating-point number.
+
+```c
+stdlib_complex64_t z = stdlib_complex64_from_int8( 5 );
+```
+
+The function accepts the following arguments:
+
+-   **real**: `[in] int8_t` real component.
+
+```c
+stdlib_complex64_t stdlib_complex64_from_int8( const int8_t real );
+```
+
+#### stdlib_complex64_from_uint8( real )
+
+Converts an unsigned 8-bit integer to a single-precision complex floating-point number.
+
+```c
+stdlib_complex64_t z = stdlib_complex64_from_uint8( 5 );
+```
+
+The function accepts the following arguments:
+
+-   **real**: `[in] uint8_t` real component.
+
+```c
+stdlib_complex64_t stdlib_complex64_from_uint8( const uint8_t real );
+```
+
+#### stdlib_complex64_from_int16( real )
+
+Converts a signed 16-bit integer to a single-precision complex floating-point number.
+
+```c
+stdlib_complex64_t z = stdlib_complex64_from_int16( 5 );
+```
+
+The function accepts the following arguments:
+
+-   **real**: `[in] int16_t` real component.
+
+```c
+stdlib_complex64_t stdlib_complex64_from_int16( const int16_t real );
+```
+
+#### stdlib_complex64_from_uint16( real )
+
+Converts an unsigned 16-bit integer to a single-precision complex floating-point number.
+
+```c
+stdlib_complex64_t z = stdlib_complex64_from_uint16( 5 );
+```
+
+The function accepts the following arguments:
+
+-   **real**: `[in] uint16_t` real component.
+
+```c
+stdlib_complex64_t stdlib_complex64_from_uint16( const uint16_t real );
+```
+
+</section>
+
+<!-- /.usage -->
+
+<!-- C API usage notes. Make sure to keep an empty line after the `section` element and another before the `/section` close. -->
+
+<section class="notes">
+
+</section>
+
+<!-- /.notes -->
+
+<!-- C API usage examples. -->
+
+<section class="examples">
+
+### Examples
+
+```c
+#include "stdlib/complex/float32.h"
+#include <stdint.h>
+#include <stdio.h>
+
+/**
+* Return the real component of a single-precision complex floating-point number.
+*
+* @param z    complex number
+* @return     real component
+*/
+static float real( 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;
+}
+
+/**
+* Return the imaginary component of a single-precision complex floating-point number.
+*
+* @param z    complex number
+* @return     imaginary component
+*/
+static float imag( const stdlib_complex64_t z ) {
+    stdlib_complex64_parts_t v;
+
+    // Assign a single-precision complex floating-point number:
+    v.value = z;
+
+    // Extract the imaginary component:
+    float im = v.parts[ 1 ];
+
+    return im;
+}
+
+int main() {
+    stdlib_complex64_t x[] = {
+        stdlib_complex64( 5.0f, 2.0f ),
+        stdlib_complex64( -2.0f, 1.0f ),
+        stdlib_complex64( 0.0f, -0.0f ),
+        stdlib_complex64( 0.0f/0.0f, 0.0f/0.0f )
+    };
+
+    stdlib_complex64_t v;
+    int i;
+    for ( i = 0; i < 4; i++ ) {
+        v = x[ i ];
+        printf( "%f + %fi\n", real( v ), imag( v ) );
+    }
+}
+```
+
+</section>
+
+<!-- /.examples -->
+
+</section>
+
+<!-- /.c -->
+
 <!-- Section to include cited references. If references are included, add a horizontal rule *before* the section. Make sure to keep an empty line after the `section` element and another before the `/section` close. -->
 
 <section class="references">
@@ -224,6 +510,21 @@ console.log( 'JSON: %s', JSON.stringify( z ) );
 
 <!-- /.references -->
 
+<!-- Section for related `stdlib` packages. Do not manually edit this section, as it is automatically populated. -->
+
+<section class="related">
+
+* * *
+
+## See Also
+
+-   <span class="package-name">[`@stdlib/complex/cmplx`][@stdlib/complex/cmplx]</span><span class="delimiter">: </span><span class="description">create a complex number.</span>
+-   <span class="package-name">[`@stdlib/complex/float64`][@stdlib/complex/float64]</span><span class="delimiter">: </span><span class="description">128-bit complex number.</span>
+
+</section>
+
+<!-- /.related -->
+
 <!-- Section for all links. Make sure to keep an empty line after the `section` element and another before the `/section` close. -->
 
 
@@ -250,7 +551,7 @@ See [LICENSE][stdlib-license].
 
 ## Copyright
 
-Copyright &copy; 2016-2021. The Stdlib [Authors][stdlib-authors].
+Copyright &copy; 2016-2022. The Stdlib [Authors][stdlib-authors].
 
 </section>
 
@@ -269,9 +570,20 @@ Copyright &copy; 2016-2021. The Stdlib [Authors][stdlib-authors].
 [coverage-image]: https://img.shields.io/codecov/c/github/stdlib-js/complex-float32/main.svg
 [coverage-url]: https://codecov.io/github/stdlib-js/complex-float32?branch=main
 
+<!--
+
 [dependencies-image]: https://img.shields.io/david/stdlib-js/complex-float32.svg
 [dependencies-url]: https://david-dm.org/stdlib-js/complex-float32/main
 
+-->
+
+[umd]: https://github.com/umdjs/umd
+[es-module]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Modules
+
+[deno-url]: https://github.com/stdlib-js/complex-float32/tree/deno
+[umd-url]: https://github.com/stdlib-js/complex-float32/tree/umd
+[esm-url]: https://github.com/stdlib-js/complex-float32/tree/esm
+
 [chat-image]: https://img.shields.io/gitter/room/stdlib-js/stdlib.svg
 [chat-url]: https://gitter.im/stdlib-js/stdlib/
 
@@ -287,7 +599,15 @@ Copyright &copy; 2016-2021. The Stdlib [Authors][stdlib-authors].
 
 [mdn-json-parse]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/parse
 
-[@stdlib/complex/reviver-float32]: https://github.com/stdlib-js/complex-reviver-float32
+[@stdlib/complex/reviver-float32]: https://www.npmjs.com/package/@stdlib/complex-reviver-float32
+
+<!-- <related-links> -->
+
+[@stdlib/complex/cmplx]: https://www.npmjs.com/package/@stdlib/complex-cmplx
+
+[@stdlib/complex/float64]: https://www.npmjs.com/package/@stdlib/complex-float64
+
+<!-- </related-links> -->
 
 </section>
 

package/docs/types/index.d.ts

@@ -58,7 +58,7 @@ declare class Complex64 {
 	* var nbytes = Complex64.BYTES_PER_ELEMENT;
 	* // returns 4
 	*/
-	readonly BYTES_PER_ELEMENT: number;
+	readonly BYTES_PER_ELEMENT: 4;
 
 	/**
 	* Length (in bytes) of a complex number.
@@ -71,7 +71,7 @@ declare class Complex64 {
 	* var nbytes = z.byteLength;
 	* // returns 8
 	*/
-	readonly byteLength: number;
+	readonly byteLength: 8;
 
 	/**
 	* Serializes a complex number as a string.

package/docs/types/test.ts

@@ -32,10 +32,10 @@ import Complex64 = require( './index' );
 	x.re; // $ExpectType number
 
 	// tslint:disable-next-line:no-unused-expression
-	x.BYTES_PER_ELEMENT; // $ExpectType number
+	x.BYTES_PER_ELEMENT; // $ExpectType 4
 
 	// tslint:disable-next-line:no-unused-expression
-	x.byteLength; // $ExpectType number
+	x.byteLength; // $ExpectType 8
 }
 
 // 64-bit complex number comes with a `toString` method to serialize a complex number as a string...

package/include/stdlib/complex/float32.h

@@ -0,0 +1,148 @@
+/**
+* @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/lib/index.js

@@ -32,9 +32,9 @@
 
 // MODULES //
 
-var Complex64 = require( './complex64.js' );
+var main = require( './main.js' );
 
 
 // EXPORTS //
 
-module.exports = Complex64;
+module.exports = main;

package/lib/{complex64.js → main.js}

@@ -23,8 +23,8 @@
 var isNumber = require( '@stdlib/assert-is-number' ).isPrimitive;
 var defineProperty = require( '@stdlib/utils-define-property' );
 var setReadOnly = require( '@stdlib/utils-define-nonenumerable-read-only-property' );
-var Float32Array = require( '@stdlib/array-float32' );
-var toString = require( './tostring.js' ); // eslint-disable-line stdlib/no-redeclare
+var float64ToFloat32 = require( '@stdlib/number-float64-base-to-float32' );
+var toStr = require( './tostring.js' );
 var toJSON = require( './tojson.js' );
 
 
@@ -46,7 +46,6 @@ var toJSON = require( './tojson.js' );
 * // returns <Complex64>
 */
 function Complex64( real, imag ) {
-	var view;
 	if ( !( this instanceof Complex64 ) ) {
 		throw new TypeError( 'invalid invocation. Constructor must be called with the `new` keyword.' );
 	}
@@ -59,39 +58,16 @@ function Complex64( real, imag ) {
 	defineProperty( this, 're', {
 		'configurable': false,
 		'enumerable': true,
-		'get': getReal
+		'writable': false,
+		'value': float64ToFloat32( real )
 	});
-
 	defineProperty( this, 'im', {
 		'configurable': false,
 		'enumerable': true,
-		'get': getImag
+		'writable': false,
+		'value': float64ToFloat32( imag )
 	});
-	view = new Float32Array( 2 );
-	view[ 0 ] = real;
-	view[ 1 ] = imag;
-
 	return this;
-
-	/**
-	* Returns a real component.
-	*
-	* @private
-	* @returns {number} real component
-	*/
-	function getReal() {
-		return view[ 0 ];
-	}
-
-	/**
-	* Returns an imaginary component.
-	*
-	* @private
-	* @returns {number} imaginary component
-	*/
-	function getImag() {
-		return view[ 1 ];
-	}
 }
 
 /**
@@ -154,7 +130,7 @@ setReadOnly( Complex64.prototype, 'byteLength', 8 );
 * var str = z.toString();
 * // returns '5 + 3i'
 */
-setReadOnly( Complex64.prototype, 'toString', toString );
+setReadOnly( Complex64.prototype, 'toString', toStr );
 
 /**
 * Serializes a complex number as a JSON object.

package/manifest.json

@@ -0,0 +1,38 @@
+{
+	"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": []
+		}
+	]
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stdlib/complex-float32",
-  "version": "0.0.3",
+  "version": "0.0.7",
   "description": "64-bit complex number.",
   "license": "Apache-2.0",
   "author": {
@@ -37,10 +37,11 @@
     "url": "https://github.com/stdlib-js/stdlib/issues"
   },
   "dependencies": {
-    "@stdlib/array-float32": "^0.0.x",
     "@stdlib/assert-is-number": "^0.0.x",
+    "@stdlib/number-float64-base-to-float32": "^0.0.x",
     "@stdlib/utils-define-nonenumerable-read-only-property": "^0.0.x",
-    "@stdlib/utils-define-property": "^0.0.x"
+    "@stdlib/utils-define-property": "^0.0.x",
+    "@stdlib/utils-library-manifest": "^0.0.x"
   },
   "devDependencies": {
     "@stdlib/assert-has-own-property": "^0.0.x",

package/src/main.c

@@ -0,0 +1,151 @@
+/**
+* @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/CHANGELOG.md

@@ -1,5 +0,0 @@
-# CHANGELOG
-
-> Package changelog.
-
-See [GitHub Releases](https://github.com/stdlib-js/complex-float32/releases) for the changelog.