9d.js (6448B)
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 /* eslint-disable max-depth */ 20 21 'use strict'; 22 23 // MAIN // 24 25 /** 26 * Applies a unary callback to elements in a nine-dimensional input ndarray and assigns results to elements in an equivalently shaped output ndarray. 27 * 28 * @private 29 * @param {Object} x - object containing input ndarray meta data 30 * @param {string} x.dtype - data type 31 * @param {Collection} x.data - data buffer 32 * @param {NonNegativeIntegerArray} x.shape - dimensions 33 * @param {IntegerArray} x.strides - stride lengths 34 * @param {NonNegativeInteger} x.offset - index offset 35 * @param {string} x.order - specifies whether `x` is row-major (C-style) or column-major (Fortran-style) 36 * @param {Object} y - object containing output ndarray meta data 37 * @param {string} y.dtype - data type 38 * @param {Collection} y.data - data buffer 39 * @param {NonNegativeIntegerArray} y.shape - dimensions 40 * @param {IntegerArray} y.strides - stride lengths 41 * @param {NonNegativeInteger} y.offset - index offset 42 * @param {string} y.order - specifies whether `y` is row-major (C-style) or column-major (Fortran-style) 43 * @param {Callback} fcn - unary callback 44 * @returns {void} 45 * 46 * @example 47 * var Float64Array = require( '@stdlib/array/float64' ); 48 * 49 * function scale( x ) { 50 * return x * 10.0; 51 * } 52 * 53 * // Create data buffers: 54 * var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] ); 55 * var ybuf = new Float64Array( 6 ); 56 * 57 * // Define the shape of the input and output arrays: 58 * var shape = [ 1, 1, 1, 1, 1, 1, 3, 1, 2 ]; 59 * 60 * // Define the array strides: 61 * var sx = [ 12, 12, 12, 12, 12, 12, 4, 4, 1 ]; 62 * var sy = [ 6, 6, 6, 6, 6, 6, 2, 2, 1 ]; 63 * 64 * // Define the index offsets: 65 * var ox = 1; 66 * var oy = 0; 67 * 68 * // Create the input and output ndarray-like objects: 69 * var x = { 70 * 'dtype': 'float64', 71 * 'data': xbuf, 72 * 'shape': shape, 73 * 'strides': sx, 74 * 'offset': ox, 75 * 'order': 'row-major' 76 * }; 77 * var y = { 78 * 'dtype': 'float64', 79 * 'data': ybuf, 80 * 'shape': shape, 81 * 'strides': sy, 82 * 'offset': oy, 83 * 'order': 'row-major' 84 * }; 85 * 86 * // Apply the unary function: 87 * unary9d( x, y, scale ); 88 * 89 * console.log( y.data ); 90 * // => <Float64Array>[ 20.0, 30.0, 60.0, 70.0, 100.0, 110.0 ] 91 */ 92 function unary9d( x, y, fcn ) { // eslint-disable-line max-statements 93 var xbuf; 94 var ybuf; 95 var dx0; 96 var dx1; 97 var dx2; 98 var dx3; 99 var dx4; 100 var dx5; 101 var dx6; 102 var dx7; 103 var dx8; 104 var dy0; 105 var dy1; 106 var dy2; 107 var dy3; 108 var dy4; 109 var dy5; 110 var dy6; 111 var dy7; 112 var dy8; 113 var sh; 114 var S0; 115 var S1; 116 var S2; 117 var S3; 118 var S4; 119 var S5; 120 var S6; 121 var S7; 122 var S8; 123 var sx; 124 var sy; 125 var ix; 126 var iy; 127 var i0; 128 var i1; 129 var i2; 130 var i3; 131 var i4; 132 var i5; 133 var i6; 134 var i7; 135 var i8; 136 137 // Note on variable naming convention: S#, dx#, dy#, i# where # corresponds to the loop number, with `0` being the innermost loop... 138 139 // Extract loop variables for purposes of loop interchange: dimensions and loop offset (pointer) increments... 140 sh = x.shape; 141 sx = x.strides; 142 sy = y.strides; 143 if ( x.order === 'row-major' ) { 144 // For row-major ndarrays, the last dimensions have the fastest changing indices... 145 S0 = sh[ 8 ]; 146 S1 = sh[ 7 ]; 147 S2 = sh[ 6 ]; 148 S3 = sh[ 5 ]; 149 S4 = sh[ 4 ]; 150 S5 = sh[ 3 ]; 151 S6 = sh[ 2 ]; 152 S7 = sh[ 1 ]; 153 S8 = sh[ 0 ]; 154 dx0 = sx[ 8 ]; // offset increment for innermost loop 155 dx1 = sx[ 7 ] - ( S0*sx[8] ); 156 dx2 = sx[ 6 ] - ( S1*sx[7] ); 157 dx3 = sx[ 5 ] - ( S2*sx[6] ); 158 dx4 = sx[ 4 ] - ( S3*sx[5] ); 159 dx5 = sx[ 3 ] - ( S4*sx[4] ); 160 dx6 = sx[ 2 ] - ( S5*sx[3] ); 161 dx7 = sx[ 1 ] - ( S6*sx[2] ); 162 dx8 = sx[ 0 ] - ( S7*sx[1] ); // offset increment for outermost loop 163 dy0 = sy[ 8 ]; 164 dy1 = sy[ 7 ] - ( S0*sy[8] ); 165 dy2 = sy[ 6 ] - ( S1*sy[7] ); 166 dy3 = sy[ 5 ] - ( S2*sy[6] ); 167 dy4 = sy[ 4 ] - ( S3*sy[5] ); 168 dy5 = sy[ 3 ] - ( S4*sy[4] ); 169 dy6 = sy[ 2 ] - ( S5*sy[3] ); 170 dy7 = sy[ 1 ] - ( S6*sy[2] ); 171 dy8 = sy[ 0 ] - ( S7*sy[1] ); 172 } else { // order === 'column-major' 173 // For column-major ndarrays, the first dimensions have the fastest changing indices... 174 S0 = sh[ 0 ]; 175 S1 = sh[ 1 ]; 176 S2 = sh[ 2 ]; 177 S3 = sh[ 3 ]; 178 S4 = sh[ 4 ]; 179 S5 = sh[ 5 ]; 180 S6 = sh[ 6 ]; 181 S7 = sh[ 7 ]; 182 S8 = sh[ 8 ]; 183 dx0 = sx[ 0 ]; // offset increment for innermost loop 184 dx1 = sx[ 1 ] - ( S0*sx[0] ); 185 dx2 = sx[ 2 ] - ( S1*sx[1] ); 186 dx3 = sx[ 3 ] - ( S2*sx[2] ); 187 dx4 = sx[ 4 ] - ( S3*sx[3] ); 188 dx5 = sx[ 5 ] - ( S4*sx[4] ); 189 dx6 = sx[ 6 ] - ( S5*sx[5] ); 190 dx7 = sx[ 7 ] - ( S6*sx[6] ); 191 dx8 = sx[ 8 ] - ( S7*sx[7] ); // offset increment for outermost loop 192 dy0 = sy[ 0 ]; 193 dy1 = sy[ 1 ] - ( S0*sy[0] ); 194 dy2 = sy[ 2 ] - ( S1*sy[1] ); 195 dy3 = sy[ 3 ] - ( S2*sy[2] ); 196 dy4 = sy[ 4 ] - ( S3*sy[3] ); 197 dy5 = sy[ 5 ] - ( S4*sy[4] ); 198 dy6 = sy[ 6 ] - ( S5*sy[5] ); 199 dy7 = sy[ 7 ] - ( S6*sy[6] ); 200 dy8 = sy[ 8 ] - ( S7*sy[7] ); 201 } 202 // Set the pointers to the first indexed elements in the respective ndarrays... 203 ix = x.offset; 204 iy = y.offset; 205 206 // Cache references to the input and output ndarray buffers... 207 xbuf = x.data; 208 ybuf = y.data; 209 210 // Iterate over the ndarray dimensions... 211 for ( i8 = 0; i8 < S8; i8++ ) { 212 for ( i7 = 0; i7 < S7; i7++ ) { 213 for ( i6 = 0; i6 < S6; i6++ ) { 214 for ( i5 = 0; i5 < S5; i5++ ) { 215 for ( i4 = 0; i4 < S4; i4++ ) { 216 for ( i3 = 0; i3 < S3; i3++ ) { 217 for ( i2 = 0; i2 < S2; i2++ ) { 218 for ( i1 = 0; i1 < S1; i1++ ) { 219 for ( i0 = 0; i0 < S0; i0++ ) { 220 ybuf[ iy ] = fcn( xbuf[ ix ] ); 221 ix += dx0; 222 iy += dy0; 223 } 224 ix += dx1; 225 iy += dy1; 226 } 227 ix += dx2; 228 iy += dy2; 229 } 230 ix += dx3; 231 iy += dy3; 232 } 233 ix += dx4; 234 iy += dy4; 235 } 236 ix += dx5; 237 iy += dy5; 238 } 239 ix += dx6; 240 iy += dy6; 241 } 242 ix += dx7; 243 iy += dy7; 244 } 245 ix += dx8; 246 iy += dy8; 247 } 248 } 249 250 251 // EXPORTS // 252 253 module.exports = unary9d;