Add support for complex number dtypes and data buffers exposing get and set methods

Author: kgryte

lib/node_modules/@stdlib/ndarray/base/ctor/README.md

@@ -61,7 +61,7 @@ var arr = ndarray( 'generic', buffer, shape, strides, offset, order );
 
 The constructor has the following parameters:
 
--   **dtype**: underlying data type.
+-   **dtype**: underlying [data type][@stdlib/ndarray/dtypes].
 -   **buffer**: data buffer.
 -   **shape**: array shape (dimensions).
 -   **strides**: array strides which are index offsets specifying how to access along corresponding dimensions.
@@ -212,7 +212,7 @@ var bool = ( d === buffer );
 
 #### ndarray.prototype.dtype
 
-Underlying data type.
+Underlying [data type][@stdlib/ndarray/dtypes].
 
 ```javascript
 var Uint8Array = require( '@stdlib/array/uint8' );
@@ -563,8 +563,14 @@ The method does **not** serialize data outside of the buffer region defined by t
 
 <!-- Package usage notes. Make sure to keep an empty line after the `section` element and another before the `/section` close. -->
 
+* * *
+
 <section class="notes">
 
+## Notes
+
+-   A data buffer must be an array-like object (i.e., have a `length` property). For data buffers which are not indexed collections (i.e., collections which cannot support direct index access, such as `buffer[ index ]`; e.g., [`Complex64Array`][@stdlib/array/complex64], [`Complex128Array`][@stdlib/array/complex128], etc), a data buffer should provide `#.get( idx )` and `#.set( v, idx )` methods. Note that, for `set` methods, the value to set should be the first argument, followed by the linear index, similar to the native typed array `set` method.
+
 </section>
 
 <!-- /.notes -->
@@ -639,6 +645,12 @@ str = JSON.stringify( arr.toJSON() );
 
 [json]: http://www.json.org/
 
+[@stdlib/ndarray/dtypes]: https://github.com/stdlib-js/stdlib
+
+[@stdlib/array/complex64]: https://github.com/stdlib-js/stdlib
+
+[@stdlib/array/complex128]: https://github.com/stdlib-js/stdlib
+
 </section>
 
 <!-- /.links -->

lib/node_modules/@stdlib/ndarray/base/ctor/lib/get.js

@@ -40,6 +40,9 @@ function get() {
 	for ( i = 0; i < arguments.length; i++ ) {
 		idx += this._strides[ i ] * arguments[ i ];
 	}
+	if ( this._getter ) {
+		return this._getter.call( this._buffer, idx );
+	}
 	return this._buffer[ idx ];
 }
 

lib/node_modules/@stdlib/ndarray/base/ctor/lib/iget.js

@@ -47,11 +47,17 @@ function iget( idx ) {
 	if ( this._flags.ROW_MAJOR_CONTIGUOUS || this._flags.COLUMN_MAJOR_CONTIGUOUS ) { // eslint-disable-line max-len
 		// Trivial case where we have all positive strides...
 		if ( this._iterationOrder === 1 ) {
-			return this._buffer[ this._offset + idx ];
+			if ( this._getter ) {
+				return this._getter.call( this._buffer, this._offset+idx );
+			}
+			return this._buffer[ this._offset+idx ];
 		}
 		// Trivial case where we have all negative strides...
 		if ( this._iterationOrder === -1 ) {
-			return this._buffer[ this._offset - idx ];
+			if ( this._getter ) {
+				return this._getter.call( this._buffer, this.offset-idx );
+			}
+			return this._buffer[ this._offset-idx ];
 		}
 	}
 	// The approach which follows is to resolve a view index to its subscripts and then plug the subscripts into the standard formula for computing the linear index in the underlying data buffer...
@@ -65,6 +71,9 @@ function iget( idx ) {
 			idx /= shape[ i ];
 			ind += s * strides[ i ];
 		}
+		if ( this._getter ) {
+			return this._getter.call( this._buffer, ind );
+		}
 		return this._buffer[ ind ];
 	}
 	// Case: row-major
@@ -74,6 +83,9 @@ function iget( idx ) {
 		idx /= shape[ i ];
 		ind += s * strides[ i ];
 	}
+	if ( this._getter ) {
+		return this._getter.call( this._buffer, ind );
+	}
 	return this._buffer[ ind ];
 }
 

lib/node_modules/@stdlib/ndarray/base/ctor/lib/iset.js

@@ -43,18 +43,30 @@ function iset( idx, v ) {
 
 	ndims = this._ndims;
 	if ( ndims === 0 ) {
-		this._buffer[ this._offset ] = idx;
+		if ( this._setter ) {
+			this._setter.call( this._buffer, idx, this._offset );
+		} else {
+			this._buffer[ this._offset ] = idx;
+		}
 		return this;
 	}
 	if ( this._flags.ROW_MAJOR_CONTIGUOUS || this._flags.COLUMN_MAJOR_CONTIGUOUS ) { // eslint-disable-line max-len
 		// Trivial case where we have all positive strides...
 		if ( this._iterationOrder === 1 ) {
-			this._buffer[ this._offset + idx ] = v;
+			if ( this._setter ) {
+				this._setter.call( this._buffer, v, this._offset+idx );
+			} else {
+				this._buffer[ this._offset+idx ] = v;
+			}
 			return this;
 		}
 		// Trivial case where we have all negative strides...
 		if ( this._iterationOrder === -1 ) {
-			this._buffer[ this._offset - idx ] = v;
+			if ( this._setter ) {
+				this._setter.call( this._buffer, v, this._offset-idx );
+			} else {
+				this._buffer[ this._offset-idx ] = v;
+			}
 			return this;
 		}
 	}
@@ -69,7 +81,11 @@ function iset( idx, v ) {
 			idx /= shape[ i ];
 			ind += s * strides[ i ];
 		}
-		this._buffer[ ind ] = v;
+		if ( this._setter ) {
+			this._setter.call( this._buffer, v, ind );
+		} else {
+			this._buffer[ ind ] = v;
+		}
 		return this;
 	}
 	// Case: row-major
@@ -79,7 +95,11 @@ function iset( idx, v ) {
 		idx /= shape[ i ];
 		ind += s * strides[ i ];
 	}
-	this._buffer[ ind ] = v;
+	if ( this._setter ) {
+		this._setter.call( this._buffer, v, ind );
+	} else {
+		this._buffer[ ind ] = v;
+	}
 	return this;
 }
 

lib/node_modules/@stdlib/ndarray/base/ctor/lib/main.js

@@ -106,6 +106,14 @@ function ndarray( dtype, buffer, shape, strides, offset, order ) {
 	this._shape = shape;
 	this._strides = strides;
 
+	if ( buffer.get && buffer.set ) {
+		this._getter = buffer.get;
+		this._setter = buffer.set;
+	} else {
+		this._getter = null;
+		this._setter = null;
+	}
+
 	this._iterationOrder = iterationOrder( strides );
 
 	// Determine if the array can be stored contiguously:

lib/node_modules/@stdlib/ndarray/base/ctor/lib/set.js

@@ -41,7 +41,11 @@ function set() {
 	for ( i = 0; i < arguments.length-1; i++ ) {
 		idx += this._strides[ i ] * arguments[ i ];
 	}
-	this._buffer[ idx ] = arguments[ i ];
+	if ( this._setter ) {
+		this._setter.call( this._buffer, arguments[ i ], idx );
+	} else {
+		this._buffer[ idx ] = arguments[ i ];
+	}
 	return this;
 }
 

lib/node_modules/@stdlib/ndarray/base/ctor/lib/tojson.js

@@ -18,6 +18,12 @@
 
 'use strict';
 
+// MODULES //
+
+var real = require( '@stdlib/complex/real' );
+var imag = require( '@stdlib/complex/imag' );
+
+
 // MAIN //
 
 /**
@@ -34,6 +40,7 @@ function toJSON() {
 	/* eslint-disable no-invalid-this */
 	var out;
 	var len;
+	var v;
 	var i;
 
 	len = this._length;
@@ -55,8 +62,15 @@ function toJSON() {
 	}
 	// Cast data to generic array...
 	out.data = [];
-	for ( i = 0; i < len; i++ ) {
-		out.data.push( this.iget( i ) );
+	if ( out.dtype === 'complex64' || out.dtype === 'complex128' ) {
+		for ( i = 0; i < len; i++ ) {
+			v = this.iget( i );
+			out.data.push( real( v ), imag( v ) );
+		}
+	} else {
+		for ( i = 0; i < len; i++ ) {
+			out.data.push( this.iget( i ) );
+		}
 	}
 	return out;
 }

lib/node_modules/@stdlib/ndarray/base/ctor/lib/tostring.js

@@ -21,6 +21,8 @@
 // MODULES //
 
 var replace = require( '@stdlib/string/replace' );
+var real = require( '@stdlib/complex/real' );
+var imag = require( '@stdlib/complex/imag' );
 
 
 // VARIABLES //
@@ -36,7 +38,9 @@ var CTORS = {
 	'float32': 'new Float32Array( [ {{data}} ] )',
 	'float64': 'new Float64Array( [ {{data}} ] )',
 	'generic': '[ {{data}} ]',
-	'binary': 'new Buffer( [ {{data}} ] )'
+	'binary': 'new Buffer( [ {{data}} ] )',
+	'complex64': 'new Complex64Array( [ {{data}} ] )',
+	'complex128': 'new Complex128Array( [ {{data}} ] )'
 };
 
 
@@ -58,37 +62,70 @@ function toString() { // eslint-disable-line stdlib/no-redeclare
 	var ndims;
 	var ctor;
 	var str;
+	var dt;
+	var v;
 	var i;
 
 	ndims = this._shape.length;
+	dt = this._dtype;
 
 	// Function to invoke to create an ndarray:
-	str = 'ndarray( \''+this._dtype+'\', ';
+	str = 'ndarray( \''+dt+'\', ';
 
 	// Data buffer parameter...
 	buffer = '';
 	if ( this._length <= 100 ) {
-		for ( i = 0; i < this._length; i++ ) {
-			buffer += this.iget( i );
-			if ( i < this._length-1 ) {
-				buffer += ', ';
+		if ( dt === 'complex64' || dt === 'complex128' ) {
+			for ( i = 0; i < this._length; i++ ) {
+				v = this.iget( i );
+				buffer += real( v ) + ', ' + imag( v );
+				if ( i < this._length-1 ) {
+					buffer += ', ';
+				}
+			}
+		} else {
+			for ( i = 0; i < this._length; i++ ) {
+				buffer += this.iget( i );
+				if ( i < this._length-1 ) {
+					buffer += ', ';
+				}
 			}
 		}
 	} else {
 		// First three values...
-		for ( i = 0; i < 3; i++ ) {
-			buffer += this.iget( i );
-			if ( i < 2 ) {
-				buffer += ', ';
+		if ( dt === 'complex64' || dt === 'complex128' ) {
+			for ( i = 0; i < 3; i++ ) {
+				v = this.iget( i );
+				buffer += real( v ) + ', ' + imag( v );
+				if ( i < 2 ) {
+					buffer += ', ';
+				}
+			}
+		} else {
+			for ( i = 0; i < 3; i++ ) {
+				buffer += this.iget( i );
+				if ( i < 2 ) {
+					buffer += ', ';
+				}
 			}
 		}
 		buffer += ', ..., ';
 
 		// Last three values...
-		for ( i = 2; i >= 0; i-- ) {
-			buffer += this.iget( this._length-1-i );
-			if ( i > 0 ) {
-				buffer += ', ';
+		if ( dt === 'complex64' || dt === 'complex128' ) {
+			for ( i = 2; i >= 0; i-- ) {
+				v = this.iget( this._length-1-i );
+				buffer += real( v ) + ', ' + imag( v );
+				if ( i > 0 ) {
+					buffer += ', ';
+				}
+			}
+		} else {
+			for ( i = 2; i >= 0; i-- ) {
+				buffer += this.iget( this._length-1-i );
+				if ( i > 0 ) {
+					buffer += ', ';
+				}
 			}
 		}
 	}