2d_accessors.js (5003B)
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 two-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 = [ 2, 2 ]; 62 * 63 * // Define the array strides: 64 * var sx = [ 2, 1 ]; 65 * var sy = [ 2, 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 * unary2d( 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 unary2d( x, y, fcn ) { 112 var xbuf; 113 var ybuf; 114 var get; 115 var set; 116 var dx0; 117 var dx1; 118 var dy0; 119 var dy1; 120 var sh; 121 var S0; 122 var S1; 123 var sx; 124 var sy; 125 var ix; 126 var iy; 127 var i0; 128 var i1; 129 130 // Note on variable naming convention: S#, dx#, dy#, i# where # corresponds to the loop number, with `0` being the innermost loop... 131 132 // Extract loop variables for purposes of loop interchange: dimensions and loop offset (pointer) increments... 133 sh = x.shape; 134 sx = x.strides; 135 sy = y.strides; 136 if ( x.order === 'row-major' ) { 137 // For row-major ndarrays, the last dimensions have the fastest changing indices... 138 S0 = sh[ 1 ]; 139 S1 = sh[ 0 ]; 140 dx0 = sx[ 1 ]; // offset increment for innermost loop 141 dx1 = sx[ 0 ] - ( S0*sx[1] ); // offset increment for outermost loop 142 dy0 = sy[ 1 ]; 143 dy1 = sy[ 0 ] - ( S0*sy[1] ); 144 } else { // order === 'column-major' 145 // For column-major ndarrays, the first dimensions have the fastest changing indices... 146 S0 = sh[ 0 ]; 147 S1 = sh[ 1 ]; 148 dx0 = sx[ 0 ]; // offset increment for innermost loop 149 dx1 = sx[ 1 ] - ( S0*sx[0] ); // offset increment for outermost loop 150 dy0 = sy[ 0 ]; 151 dy1 = sy[ 1 ] - ( S0*sy[0] ); 152 } 153 // Set the pointers to the first indexed elements in the respective ndarrays... 154 ix = x.offset; 155 iy = y.offset; 156 157 // Cache references to the input and output ndarray buffers... 158 xbuf = x.data; 159 ybuf = y.data; 160 161 // Cache accessors: 162 get = x.getter; 163 set = y.setter; 164 165 // Iterate over the ndarray dimensions... 166 for ( i1 = 0; i1 < S1; i1++ ) { 167 for ( i0 = 0; i0 < S0; i0++ ) { 168 set( ybuf, iy, fcn( get( xbuf, ix ) ) ); 169 ix += dx0; 170 iy += dy0; 171 } 172 ix += dx1; 173 iy += dy1; 174 } 175 } 176 177 178 // EXPORTS // 179 180 module.exports = unary2d;