Add logic for determining layout order

Author: kgryte

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

@@ -27,6 +27,7 @@ var isArray = require( '@stdlib/assert/is-array' );
 var isndarrayLike = require( '@stdlib/assert/is-ndarray-like' );
 var shape2strides = require( '@stdlib/ndarray/base/shape2strides' );
 var strides2offset = require( '@stdlib/ndarray/base/strides2offset' );
+var strides2order = require( '@stdlib/ndarray/base/strides2order' );
 var numel = require( '@stdlib/ndarray/base/numel' );
 var ctor = require( '@stdlib/ndarray/memoized-ctor' );
 var isDataType = require( '@stdlib/ndarray/base/assert/is-data-type' );
@@ -49,7 +50,7 @@ var castBuffer = require( './cast_buffer.js' );
 * @param {Options} [options] - function options
 * @param {(ArrayLikeObject|TypedArrayLike|Buffer|ndarrayLike)} [options.buffer] - data source
 * @param {string} [options.dtype="float64"] - underlying storage data type (if the input data is not of the same type, this option specifies the data type to which to cast the input data)
-* @param {string} [options.order="row-major"] - specifies whether an array should be row-major (C-style) or column-major (Fortran-style)
+* @param {string} [options.order="row-major"] - specifies the memory layout of the array as either row-major (C-style) or column-major (Fortran-style)
 * @param {NonNegativeIntegerArray} [options.shape] - array shape
 * @param {boolean} [options.codegen=true] - boolean indicating whether to use code generation
 * @param {string} [options.mode="throw"] - specifies how to handle indices which exceed array dimensions
@@ -107,6 +108,7 @@ function array() {
 	var nopts;
 	var opts;
 	var len;
+	var ord;
 	var FLG;
 
 	if ( arguments.length === 1 ) {
@@ -144,7 +146,27 @@ function array() {
 	}
 	if ( hasOwnProp( options, 'order' ) ) {
 		order = options.order;
-		if ( !isOrder( order ) && order !== 'any' && order !== 'keep' ) {
+		if ( order === 'any' || order === 'same' ) {
+			if ( FLG ) {
+				// If the user indicated that "any" order suffices (meaning the user does not care about ndarray order), then we default to the default order, unless the input ndarray is unequivocally either "row-major" or "column-major"....
+				if ( order === 'any' ) {
+					ord = strides2order( buffer.strides );
+					if ( ord === 'column-major' ) {
+						order = ord;
+					} else if ( ord === 'row-major' ) {
+						order = ord;
+					} else {
+						order = defaults.order;
+					}
+				}
+				// If the user indicated to keep the same order, then TODO...
+				else if ( order === 'same' ) {
+
+				}
+			} else {
+				order = defaults.order;
+			}
+		} else if ( !isOrder( order ) ) {
 			throw new TypeError( 'invalid option. `order` option must be a recognized order. Option: `' + order + '`.' );
 		}
 	} else {
@@ -212,27 +234,48 @@ function array() {
 	} else {
 		throw new Error( 'invalid input arguments. Must provide either a data source, array shape, or both.' );
 	}
-	// TODO: if provided an ndarray, determine order
-
-	// Compute the array strides:
-	strides = shape2strides( shape, order );
-
-	// Determine the index offset (i.e., the pointer to the first array element):
-	offset = strides2offset( shape, strides );
+	// If provided an ndarray, we need to take special care to ensure we determine the correct order...
+	if ( FLG ) {
+		// If we are not copying the ndarray buffer, then we are simply creating another ndarray wrapper around the same underlying buffer...
+		if ( opts.copy === false ) {
+			strides = buffer.strides;
+			offset = buffer.offset;
+			order = buffer.order;
+		}
+		// If we are copying the ndarray buffer, then we need to perform some analysis to determine order of the output ndarray...
+		else {
 
+		}
+	}
+	// For all other data source inputs, we assume we've been provided a contiguous data source for which we can simply compute the strides and index offset pointing to the first indexed element...
+	else {
+		strides = shape2strides( shape, order );
+		offset = strides2offset( shape, strides );
+	}
 	// If not provided a data buffer, create it; otherwise, see if we need to cast a provided data buffer to another data type or perform a copy...
 	if ( buffer ) {
 		// TODO: determine how to handle ndarray data sources (for non-copy, we need to compute strides based on the order taking into account that a provided ndarray may have "scrambled" strides; for copy, we need to "pluck" the values from the ndarray buffer)
 
-		btype = getType( buffer );
-		if ( btype === 'generic' && opts.flatten ) {
-			buffer = flattenArray( buffer );
-		}
-		if ( btype !== dtype || opts.copy ) {
-			if ( buffer.length < len ) {
-				throw new RangeError( 'invalid input arguments. Array shape is incompatible with provided data source. To accommodate the requested shape, provide a bigger data source.' );
+		if ( FLG ) {
+			if ( buffer.length !== len ) {
+				throw new RangeError( 'invalid input arguments. Array shape is incompatible with provided data source. Number of data source elements does not match array shape.' );
+			}
+			if ( opts.copy ) {
+				// TODO: pluck data
+			} else {
+				buffer = buffer.data;
+			}
+		} else {
+			btype = getType( buffer );
+			if ( btype === 'generic' && opts.flatten ) {
+				buffer = flattenArray( buffer );
+			}
+			if ( buffer.length !== len ) {
+				throw new RangeError( 'invalid input arguments. Array shape is incompatible with provided data source. Number of data source elements does not match array shape.' );
+			}
+			if ( btype !== dtype || opts.copy ) {
+				buffer = castBuffer( buffer, len, dtype );
 			}
-			buffer = castBuffer( buffer, len, dtype );
 		}
 	} else {
 		buffer = createBuffer( dtype, len );