time-to-botec

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

0d_accessors.js (3401B)

      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 zero-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 ] );
     58 * var ybuf = new Complex64Array( 2 );
     59 *
     60 * // Define the shape of the input and output arrays:
     61 * var shape = [];
     62 *
     63 * // Define the array strides:
     64 * var sx = [ 0 ];
     65 * var sy = [ 0 ];
     66 *
     67 * // Define the index offsets:
     68 * var ox = 1;
     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 * unary0d( x, y, scale );
    102 *
    103 * var v = y.data.get( 0 );
    104 *
    105 * var re = real( v );
    106 * // returns 30.0
    107 *
    108 * var im = imag( v );
    109 * // returns 40.0
    110 */
    111 function unary0d( x, y, fcn ) {
    112 	y.setter( y.data, y.offset, fcn( x.getter( x.data, x.offset ) ) );
    113 }
    114 
    115 
    116 // EXPORTS //
    117 
    118 module.exports = unary0d;