@stdlib/complex-float32 0.0.6 → 0.1.0

package/README.md

@@ -18,9 +18,20 @@ limitations under the License.
 
 -->
 
+
+<details>
+  <summary>
+    About stdlib...
+  </summary>
+  <p>We believe in a future in which the web is a preferred environment for numerical computation. To help realize this future, we've built stdlib. stdlib is a standard library, with an emphasis on numerical and scientific computation, written in JavaScript (and C) for execution in browsers and in Node.js.</p>
+  <p>The library is fully decomposable, being architected in such a way that you can swap out and mix and match APIs and functionality to cater to your exact preferences and use cases.</p>
+  <p>When you use stdlib, you can be absolutely certain that you are using the most thorough, rigorous, well-written, studied, documented, tested, measured, and high-quality code out there.</p>
+  <p>To join us in bringing numerical computing to the web, get started by checking us out on <a href="https://github.com/stdlib-js/stdlib">GitHub</a>, and please consider <a href="https://opencollective.com/stdlib">financially supporting stdlib</a>. We greatly appreciate your continued support!</p>
+</details>
+
 # 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 +208,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( void ) {
+    const 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 +521,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 +562,7 @@ See [LICENSE][stdlib-license].
 
 ## Copyright
 
-Copyright &copy; 2016-2021. The Stdlib [Authors][stdlib-authors].
+Copyright &copy; 2016-2023. The Stdlib [Authors][stdlib-authors].
 
 </section>
 
@@ -263,22 +575,34 @@ Copyright &copy; 2016-2021. The Stdlib [Authors][stdlib-authors].
 [npm-image]: http://img.shields.io/npm/v/@stdlib/complex-float32.svg
 [npm-url]: https://npmjs.org/package/@stdlib/complex-float32
 
-[test-image]: https://github.com/stdlib-js/complex-float32/actions/workflows/test.yml/badge.svg
-[test-url]: https://github.com/stdlib-js/complex-float32/actions/workflows/test.yml
+[test-image]: https://github.com/stdlib-js/complex-float32/actions/workflows/test.yml/badge.svg?branch=v0.1.0
+[test-url]: https://github.com/stdlib-js/complex-float32/actions/workflows/test.yml?query=branch:v0.1.0
 
 [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
 
+-->
+
 [chat-image]: https://img.shields.io/gitter/room/stdlib-js/stdlib.svg
-[chat-url]: https://gitter.im/stdlib-js/stdlib/
+[chat-url]: https://app.gitter.im/#/room/#stdlib-js_stdlib:gitter.im
 
 [stdlib]: https://github.com/stdlib-js/stdlib
 
 [stdlib-authors]: https://github.com/stdlib-js/stdlib/graphs/contributors
 
+[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
+[branches-url]: https://github.com/stdlib-js/complex-float32/blob/main/branches.md
+
 [stdlib-license]: https://raw.githubusercontent.com/stdlib-js/complex-float32/main/LICENSE
 
 [json]: http://www.json.org/
@@ -289,6 +613,14 @@ Copyright &copy; 2016-2021. The Stdlib [Authors][stdlib-authors].
 
 [@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>
 
 <!-- /.links -->

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+/// <reference path="../docs/types/index.d.ts" />
+import Complex64 from '../docs/types/index';
+export = Complex64;

package/dist/index.js

@@ -0,0 +1,9 @@
+"use strict";var o=function(e,r){return function(){return r||e((r={exports:{}}).exports,r),r.exports}};var a=o(function(S,n){
+function c(){var e=""+this.re;return this.im<0?e+=" - "+-this.im:e+=" + "+this.im,e+="i",e}n.exports=c
+});var u=o(function(T,s){
+function b(){var e={};return e.type="Complex64",e.re=this.re,e.im=this.im,e}s.exports=b
+});var h=o(function(d,v){
+var l=require('@stdlib/assert-is-number/dist').isPrimitive,m=require('@stdlib/utils-define-property/dist'),i=require('@stdlib/utils-define-nonenumerable-read-only-property/dist'),p=require('@stdlib/number-float64-base-to-float32/dist'),f=require('@stdlib/error-tools-fmtprodmsg/dist'),y=a(),E=u();function t(e,r){if(!(this instanceof t))throw new TypeError(format('0Gp0G'));if(!l(e))throw new TypeError(f('0Gp3e',e));if(!l(r))throw new TypeError(f('0Gp3f',r));return m(this,"re",{configurable:!1,enumerable:!0,writable:!1,value:p(e)}),m(this,"im",{configurable:!1,enumerable:!0,writable:!1,value:p(r)}),this}i(t,"BYTES_PER_ELEMENT",4);i(t.prototype,"BYTES_PER_ELEMENT",4);i(t.prototype,"byteLength",8);i(t.prototype,"toString",y);i(t.prototype,"toJSON",E);v.exports=t
+});var w=h();module.exports=w;
+/** @license Apache-2.0 */
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../lib/tostring.js", "../lib/tojson.js", "../lib/main.js", "../lib/index.js"],
+  "sourcesContent": ["/**\n* @license Apache-2.0\n*\n* Copyright (c) 2018 The Stdlib Authors.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*    http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n'use strict';\n\n/**\n* Serializes a complex number as a string.\n*\n* @private\n* @returns {string} serialized complex number\n*/\nfunction toString() { // eslint-disable-line stdlib/no-redeclare\n\t/* eslint-disable no-invalid-this */\n\tvar str = '' + this.re;\n\tif ( this.im < 0 ) {\n\t\tstr += ' - ' + (-this.im);\n\t} else {\n\t\tstr += ' + ' + this.im;\n\t}\n\tstr += 'i';\n\treturn str;\n}\n\n\n// EXPORTS //\n\nmodule.exports = toString;\n", "/**\n* @license Apache-2.0\n*\n* Copyright (c) 2018 The Stdlib Authors.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*    http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n'use strict';\n\n/**\n* Serializes a complex number as a JSON object.\n*\n* @private\n* @returns {Object} JSON representation\n*/\nfunction toJSON() {\n\t/* eslint-disable no-invalid-this */\n\tvar out = {};\n\tout.type = 'Complex64';\n\tout.re = this.re;\n\tout.im = this.im;\n\treturn out;\n}\n\n\n// EXPORTS //\n\nmodule.exports = toJSON;\n", "/**\n* @license Apache-2.0\n*\n* Copyright (c) 2018 The Stdlib Authors.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*    http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n'use strict';\n\n// MODULES //\n\nvar isNumber = require( '@stdlib/assert-is-number' ).isPrimitive;\nvar defineProperty = require( '@stdlib/utils-define-property' );\nvar setReadOnly = require( '@stdlib/utils-define-nonenumerable-read-only-property' );\nvar float64ToFloat32 = require( '@stdlib/number-float64-base-to-float32' );\nvar format = require( '@stdlib/string-format' );\nvar toStr = require( './tostring.js' );\nvar toJSON = require( './tojson.js' );\n\n\n// MAIN //\n\n/**\n* 64-bit complex number constructor.\n*\n* @constructor\n* @param {number} real - real component\n* @param {number} imag - imaginary component\n* @throws {TypeError} must invoke using the `new` keyword\n* @throws {TypeError} real component must be a number\n* @throws {TypeError} imaginary component must be a number\n* @returns {Complex64} 64-bit complex number\n*\n* @example\n* var z = new Complex64( 5.0, 3.0 );\n* // returns <Complex64>\n*/\nfunction Complex64( real, imag ) {\n\tif ( !( this instanceof Complex64 ) ) {\n\t\tthrow new TypeError( 'invalid invocation. Constructor must be called with the `new` keyword.' );\n\t}\n\tif ( !isNumber( real ) ) {\n\t\tthrow new TypeError( format( 'invalid argument. Real component must be a number. Value: `%s`.', real ) );\n\t}\n\tif ( !isNumber( imag ) ) {\n\t\tthrow new TypeError( format( 'invalid argument. Imaginary component must be a number. Value: `%s`.', imag ) );\n\t}\n\tdefineProperty( this, 're', {\n\t\t'configurable': false,\n\t\t'enumerable': true,\n\t\t'writable': false,\n\t\t'value': float64ToFloat32( real )\n\t});\n\tdefineProperty( this, 'im', {\n\t\t'configurable': false,\n\t\t'enumerable': true,\n\t\t'writable': false,\n\t\t'value': float64ToFloat32( imag )\n\t});\n\treturn this;\n}\n\n/**\n* Size (in bytes) of each component.\n*\n* @name BYTES_PER_ELEMENT\n* @memberof Complex64\n* @type {integer}\n* @returns {integer} size of each component\n*\n* @example\n* var nbytes = Complex64.BYTES_PER_ELEMENT;\n* // returns 4\n*/\nsetReadOnly( Complex64, 'BYTES_PER_ELEMENT', 4 );\n\n/**\n* Size (in bytes) of each component.\n*\n* @name BYTES_PER_ELEMENT\n* @memberof Complex64.prototype\n* @type {integer}\n* @returns {integer} size of each component\n*\n* @example\n* var z = new Complex64( 5.0, 3.0 );\n*\n* var nbytes = z.BYTES_PER_ELEMENT;\n* // returns 4\n*/\nsetReadOnly( Complex64.prototype, 'BYTES_PER_ELEMENT', 4 );\n\n/**\n* Length (in bytes) of a complex number.\n*\n* @name byteLength\n* @memberof Complex64.prototype\n* @type {integer}\n* @returns {integer} byte length\n*\n* @example\n* var z = new Complex64( 5.0, 3.0 );\n*\n* var nbytes = z.byteLength;\n* // returns 8\n*/\nsetReadOnly( Complex64.prototype, 'byteLength', 8 );\n\n/**\n* Serializes a complex number as a string.\n*\n* @name toString\n* @memberof Complex64.prototype\n* @type {Function}\n* @returns {string} serialized complex number\n*\n* @example\n* var z = new Complex64( 5.0, 3.0 );\n*\n* var str = z.toString();\n* // returns '5 + 3i'\n*/\nsetReadOnly( Complex64.prototype, 'toString', toStr );\n\n/**\n* Serializes a complex number as a JSON object.\n*\n* ## Notes\n*\n* -   `JSON.stringify()` implicitly calls this method when stringifying a `Complex64` instance.\n*\n* @name toJSON\n* @memberof Complex64.prototype\n* @type {Function}\n* @returns {Object} serialized complex number\n*\n* @example\n* var z = new Complex64( 5.0, 3.0 );\n*\n* var obj = z.toJSON();\n* // returns { 'type': 'Complex64', 're': 5.0, 'im': 3.0 }\n*/\nsetReadOnly( Complex64.prototype, 'toJSON', toJSON );\n\n\n// EXPORTS //\n\nmodule.exports = Complex64;\n", "/**\n* @license Apache-2.0\n*\n* Copyright (c) 2018 The Stdlib Authors.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*    http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n'use strict';\n\n/**\n* 64-bit complex number constructor.\n*\n* @module @stdlib/complex-float32\n*\n* @example\n* var Complex64 = require( '@stdlib/complex-float32' );\n*\n* var z = new Complex64( 5.0, 3.0 );\n* // returns <Complex64>\n*/\n\n// MODULES //\n\nvar main = require( './main.js' );\n\n\n// EXPORTS //\n\nmodule.exports = main;\n"],
+  "mappings": "uGAAA,IAAAA,EAAAC,EAAA,SAAAC,EAAAC,EAAA,cA0BA,SAASC,GAAW,CAEnB,IAAIC,EAAM,GAAK,KAAK,GACpB,OAAK,KAAK,GAAK,EACdA,GAAO,MAAS,CAAC,KAAK,GAEtBA,GAAO,MAAQ,KAAK,GAErBA,GAAO,IACAA,CACR,CAKAF,EAAO,QAAUC,ICzCjB,IAAAE,EAAAC,EAAA,SAAAC,EAAAC,EAAA,cA0BA,SAASC,GAAS,CAEjB,IAAIC,EAAM,CAAC,EACX,OAAAA,EAAI,KAAO,YACXA,EAAI,GAAK,KAAK,GACdA,EAAI,GAAK,KAAK,GACPA,CACR,CAKAF,EAAO,QAAUC,ICtCjB,IAAAE,EAAAC,EAAA,SAAAC,EAAAC,EAAA,cAsBA,IAAIC,EAAW,QAAS,0BAA2B,EAAE,YACjDC,EAAiB,QAAS,+BAAgC,EAC1DC,EAAc,QAAS,uDAAwD,EAC/EC,EAAmB,QAAS,wCAAyC,EACrEC,EAAS,QAAS,uBAAwB,EAC1CC,EAAQ,IACRC,EAAS,IAoBb,SAASC,EAAWC,EAAMC,EAAO,CAChC,GAAK,EAAG,gBAAgBF,GACvB,MAAM,IAAI,UAAW,wEAAyE,EAE/F,GAAK,CAACP,EAAUQ,CAAK,EACpB,MAAM,IAAI,UAAWJ,EAAQ,kEAAmEI,CAAK,CAAE,EAExG,GAAK,CAACR,EAAUS,CAAK,EACpB,MAAM,IAAI,UAAWL,EAAQ,uEAAwEK,CAAK,CAAE,EAE7G,OAAAR,EAAgB,KAAM,KAAM,CAC3B,aAAgB,GAChB,WAAc,GACd,SAAY,GACZ,MAASE,EAAkBK,CAAK,CACjC,CAAC,EACDP,EAAgB,KAAM,KAAM,CAC3B,aAAgB,GAChB,WAAc,GACd,SAAY,GACZ,MAASE,EAAkBM,CAAK,CACjC,CAAC,EACM,IACR,CAcAP,EAAaK,EAAW,oBAAqB,CAAE,EAgB/CL,EAAaK,EAAU,UAAW,oBAAqB,CAAE,EAgBzDL,EAAaK,EAAU,UAAW,aAAc,CAAE,EAgBlDL,EAAaK,EAAU,UAAW,WAAYF,CAAM,EAoBpDH,EAAaK,EAAU,UAAW,SAAUD,CAAO,EAKnDP,EAAO,QAAUQ,IC5HjB,IAAIG,EAAO,IAKX,OAAO,QAAUA",
+  "names": ["require_tostring", "__commonJSMin", "exports", "module", "toString", "str", "require_tojson", "__commonJSMin", "exports", "module", "toJSON", "out", "require_main", "__commonJSMin", "exports", "module", "isNumber", "defineProperty", "setReadOnly", "float64ToFloat32", "format", "toStr", "toJSON", "Complex64", "real", "imag", "main"]
+}

package/docs/types/index.d.ts

@@ -16,7 +16,7 @@
 * limitations under the License.
 */
 
-// TypeScript Version: 2.0
+// TypeScript Version: 4.1
 
 /**
 * 64-bit complex number.
@@ -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/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;