@stdlib/complex-float32 0.0.6 → 0.1.0

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

@@ -23,8 +23,9 @@
 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 format = require( '@stdlib/string-format' );
+var toStr = require( './tostring.js' );
 var toJSON = require( './tojson.js' );
 
 
@@ -37,8 +38,8 @@ var toJSON = require( './tojson.js' );
 * @param {number} real - real component
 * @param {number} imag - imaginary component
 * @throws {TypeError} must invoke using the `new` keyword
-* @throws {TypeError} real component must be a number primitive
-* @throws {TypeError} imaginary component must be a number primitive
+* @throws {TypeError} real component must be a number
+* @throws {TypeError} imaginary component must be a number
 * @returns {Complex64} 64-bit complex number
 *
 * @example
@@ -46,52 +47,28 @@ 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.' );
 	}
 	if ( !isNumber( real ) ) {
-		throw new TypeError( 'invalid argument. Real component must be a number primitive. Value: `'+real+'`.' );
+		throw new TypeError( format( 'invalid argument. Real component must be a number. Value: `%s`.', real ) );
 	}
 	if ( !isNumber( imag ) ) {
-		throw new TypeError( 'invalid argument. Imaginary component must be a number primitive. Value: `'+imag+'`.' );
+		throw new TypeError( format( 'invalid argument. Imaginary component must be a number. Value: `%s`.', 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 +131,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.
@@ -163,7 +140,6 @@ setReadOnly( Complex64.prototype, 'toString', toString );
 *
 * -   `JSON.stringify()` implicitly calls this method when stringifying a `Complex64` instance.
 *
-*
 * @name toJSON
 * @memberof Complex64.prototype
 * @type {Function}

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.6",
+  "version": "0.1.0",
   "description": "64-bit complex number.",
   "license": "Apache-2.0",
   "author": {
@@ -18,7 +18,9 @@
     "benchmark": "./benchmark",
     "doc": "./docs",
     "example": "./examples",
+    "include": "./include",
     "lib": "./lib",
+    "src": "./src",
     "test": "./test"
   },
   "types": "./docs/types",
@@ -37,19 +39,22 @@
     "url": "https://github.com/stdlib-js/stdlib/issues"
   },
   "dependencies": {
-    "@stdlib/array-float32": "^0.0.x",
-    "@stdlib/assert-is-number": "^0.0.x",
-    "@stdlib/utils-define-nonenumerable-read-only-property": "^0.0.x",
-    "@stdlib/utils-define-property": "^0.0.x"
+    "@stdlib/assert-is-number": "^0.1.0",
+    "@stdlib/number-float64-base-to-float32": "^0.1.0",
+    "@stdlib/string-format": "^0.1.0",
+    "@stdlib/utils-define-nonenumerable-read-only-property": "^0.1.0",
+    "@stdlib/utils-define-property": "^0.1.0",
+    "@stdlib/utils-library-manifest": "^0.1.0",
+    "@stdlib/error-tools-fmtprodmsg": "^0.1.0"
   },
   "devDependencies": {
-    "@stdlib/assert-has-own-property": "^0.0.x",
-    "@stdlib/bench": "^0.0.x",
-    "@stdlib/math-base-assert-is-nan": "^0.0.x",
-    "@stdlib/random-base-randu": "^0.0.x",
+    "@stdlib/assert-has-own-property": "^0.1.0",
+    "@stdlib/bench": "^0.1.0",
+    "@stdlib/math-base-assert-is-nan": "^0.1.0",
+    "@stdlib/random-base-randu": "^0.0.8",
     "tape": "git+https://github.com/kgryte/tape.git#fix/globby",
     "istanbul": "^0.4.1",
-    "tap-spec": "5.x.x"
+    "tap-min": "git+https://github.com/Planeshifter/tap-min.git"
   },
   "engines": {
     "node": ">=0.10.0",
@@ -82,7 +87,7 @@
     "ieee754"
   ],
   "funding": {
-    "type": "patreon",
-    "url": "https://www.patreon.com/athan"
+    "type": "opencollective",
+    "url": "https://opencollective.com/stdlib"
   }
 }

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/docs/repl.txt

@@ -1,44 +0,0 @@
-
-{{alias}}( real, imag )
-    64-bit complex number constructor.
-
-    Both the real and imaginary components are stored as single-precision
-    floating-point numbers.
-
-    Parameters
-    ----------
-    real: number
-        Real component.
-
-    imag: number
-        Imaginary component.
-
-    Returns
-    -------
-    z: Complex64
-        64-bit complex number.
-
-    z.re: number
-        Read-only property returning the real component.
-
-    z.im: number
-        Read-only property returning the imaginary component.
-
-    z.BYTES_PER_ELEMENT
-        Size (in bytes) of each component. Value: 4.
-
-    z.byteLength
-        Length (in bytes) of a complex number. Value: 8.
-
-    Examples
-    --------
-    > var z = new {{alias}}( 5.0, 3.0 )
-    <Complex64>
-    > z.re
-    5.0
-    > z.im
-    3.0
-
-    See Also
-    --------
-

package/docs/types/test.ts

@@ -1,69 +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.
-*/
-
-import Complex64 = require( './index' );
-
-
-// TESTS //
-
-// The function returns a 64-bit complex number with the expected properties...
-{
-	const x = new Complex64( 5.0, 3.0 ); // $ExpectType Complex64
-
-	// tslint:disable-next-line:no-unused-expression
-	x.im; // $ExpectType number
-
-	// tslint:disable-next-line:no-unused-expression
-	x.re; // $ExpectType number
-
-	// tslint:disable-next-line:no-unused-expression
-	x.BYTES_PER_ELEMENT; // $ExpectType number
-
-	// tslint:disable-next-line:no-unused-expression
-	x.byteLength; // $ExpectType number
-}
-
-// 64-bit complex number comes with a `toString` method to serialize a complex number as a string...
-{
-	const x = new Complex64( 5.0, 3.0 ); // $ExpectType Complex64
-
-	// tslint:disable-next-line:no-unused-expression
-	x.toString(); // $ExpectType string
-}
-
-// 64-bit complex number comes with a `toJSON` method to serialize a complex number as a JSON object....
-{
-	const x = new Complex64( 5.0, 3.0 ); // $ExpectType Complex64
-
-	// tslint:disable-next-line:no-unused-expression
-	x.toJSON(); // $ExpectType any
-}
-
-// The compiler throws an error if the constructor is invoked without the `new` keyword...
-{
-	Complex64( 5.0, 3.0 ); // $ExpectError
-}
-
-// The compiler throws an error if the constructor is provided an unsupported number of arguments...
-{
-	// tslint:disable-next-line:no-unused-expression
-	new Complex64( 5.0 ); // $ExpectError
-
-	// tslint:disable-next-line:no-unused-expression
-	new Complex64( 5.0, 3.0, 1.0 ); // $ExpectError
-}