time-to-botec

Benchmark sampling in different programming languages
Log | Files | Refs | README

1d_accessors.js (4150B)

      1 /**
      2 * @license Apache-2.0
      3 *
      4 * Copyright (c) 2021 The Stdlib Authors.
      5 *
      6 * Licensed under the Apache License, Version 2.0 (the "License");
      7 * you may not use this file except in compliance with the License.
      8 * You may obtain a copy of the License at
      9 *
     10 *    http://www.apache.org/licenses/LICENSE-2.0
     11 *
     12 * Unless required by applicable law or agreed to in writing, software
     13 * distributed under the License is distributed on an "AS IS" BASIS,
     14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     15 * See the License for the specific language governing permissions and
     16 * limitations under the License.
     17 */
     18 
     19 'use strict';
     20 
     21 // MAIN //
     22 
     23 /**
     24 * Applies a unary callback to elements in a one-dimensional input ndarray and assigns results to elements in an equivalently shaped output ndarray.
     25 *
     26 * @private
     27 * @param {Object} x - object containing input ndarray meta data
     28 * @param {string} x.dtype - data type
     29 * @param {Collection} x.data - data buffer
     30 * @param {NonNegativeIntegerArray} x.shape - dimensions
     31 * @param {IntegerArray} x.strides - stride lengths
     32 * @param {NonNegativeInteger} x.offset - index offset
     33 * @param {string} x.order - specifies whether `x` is row-major (C-style) or column-major (Fortran-style)
     34 * @param {Function} x.getter - callback for accessing `x` data buffer elements
     35 * @param {Object} y - object containing output ndarray meta data
     36 * @param {string} y.dtype - data type
     37 * @param {Collection} y.data - data buffer
     38 * @param {NonNegativeIntegerArray} y.shape - dimensions
     39 * @param {IntegerArray} y.strides - stride lengths
     40 * @param {NonNegativeInteger} y.offset - index offset
     41 * @param {string} y.order - specifies whether `y` is row-major (C-style) or column-major (Fortran-style)
     42 * @param {Function} y.setter - callback for setting `y` data buffer elements
     43 * @param {Callback} fcn - unary callback
     44 * @returns {void}
     45 *
     46 * @example
     47 * var Complex64Array = require( '@stdlib/array/complex64' );
     48 * var Complex64 = require( '@stdlib/complex/float32' );
     49 * var real = require( '@stdlib/complex/real' );
     50 * var imag = require( '@stdlib/complex/imag' );
     51 *
     52 * function scale( z ) {
     53 *     return new Complex64( real(z)*10.0, imag(z)*10.0 );
     54 * }
     55 *
     56 * // Create data buffers:
     57 * var xbuf = new Complex64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
     58 * var ybuf = new Complex64Array( 4 );
     59 *
     60 * // Define the shape of the input and output arrays:
     61 * var shape = [ 4 ];
     62 *
     63 * // Define the array strides:
     64 * var sx = [ 1 ];
     65 * var sy = [ 1 ];
     66 *
     67 * // Define the index offsets:
     68 * var ox = 0;
     69 * var oy = 0;
     70 *
     71 * // Define getters and setters:
     72 * function getter( buf, idx ) {
     73 *     return buf.get( idx );
     74 * }
     75 *
     76 * function setter( buf, idx, value ) {
     77 *     buf.set( value, idx );
     78 * }
     79 *
     80 * // Create the input and output ndarray-like objects:
     81 * var x = {
     82 *     'dtype': 'complex64',
     83 *     'data': xbuf,
     84 *     'shape': shape,
     85 *     'strides': sx,
     86 *     'offset': ox,
     87 *     'order': 'row-major',
     88 *     'getter': getter
     89 * };
     90 * var y = {
     91 *     'dtype': 'complex64',
     92 *     'data': ybuf,
     93 *     'shape': shape,
     94 *     'strides': sy,
     95 *     'offset': oy,
     96 *     'order': 'row-major',
     97 *     'setter': setter
     98 * };
     99 *
    100 * // Apply the unary function:
    101 * unary1d( x, y, scale );
    102 *
    103 * var v = y.data.get( 0 );
    104 *
    105 * var re = real( v );
    106 * // returns 10.0
    107 *
    108 * var im = imag( v );
    109 * // returns 20.0
    110 */
    111 function unary1d( x, y, fcn ) {
    112 	var xbuf;
    113 	var ybuf;
    114 	var get;
    115 	var set;
    116 	var dx0;
    117 	var dy0;
    118 	var S0;
    119 	var ix;
    120 	var iy;
    121 	var i0;
    122 
    123 	// Note on variable naming convention: S#, dx#, dy#, i# where # corresponds to the loop number, with `0` being the innermost loop...
    124 
    125 	// Extract loop variables: dimensions and loop offset (pointer) increments...
    126 	S0 = x.shape[ 0 ];
    127 	dx0 = x.strides[ 0 ];
    128 	dy0 = y.strides[ 0 ];
    129 
    130 	// Set the pointers to the first indexed elements in the respective ndarrays...
    131 	ix = x.offset;
    132 	iy = y.offset;
    133 
    134 	// Cache references to the input and output ndarray buffers...
    135 	xbuf = x.data;
    136 	ybuf = y.data;
    137 
    138 	// Cache accessors:
    139 	get = x.getter;
    140 	set = y.setter;
    141 
    142 	// Iterate over the ndarray dimensions...
    143 	for ( i0 = 0; i0 < S0; i0++ ) {
    144 		set( ybuf, iy, fcn( get( xbuf, ix ) ) );
    145 		ix += dx0;
    146 		iy += dy0;
    147 	}
    148 }
    149 
    150 
    151 // EXPORTS //
    152 
    153 module.exports = unary1d;