diff --git a/lib/node_modules/@stdlib/ndarray/base/mskfilter/include/stdlib/ndarray/base/mskfilter/macros/1d.h b/lib/node_modules/@stdlib/ndarray/base/mskfilter/include/stdlib/ndarray/base/mskfilter/macros/1d.h new file mode 100644 index 00000000000..aae397aa7ef --- /dev/null +++ b/lib/node_modules/@stdlib/ndarray/base/mskfilter/include/stdlib/ndarray/base/mskfilter/macros/1d.h @@ -0,0 +1,136 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2024 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +#ifndef STDLIB_NDARRAY_BASE_MSKFILTER_MACROS_1D_H +#define STDLIB_NDARRAY_BASE_MSKFILTER_MACROS_1D_H + +#include "stdlib/ndarray/ctor.h" +#include + +/** +* Macro containing the preamble for a loop which operates on elements of a one-dimensional ndarray, with a mask array. +* +* ## Notes +* +* - Variable naming conventions: +* +* - `sx#`, `px#`, and `d@x#` where `#` corresponds to the ndarray argument number, starting at `1`. +* - `S@`, `i@`, and `d@x#` where `@` corresponds to the loop number, with `0` being the innermost loop. +* +* @example +* STDLIB_NDARRAY_MSKFILTER_1D_LOOP_PREMABLE { +* // Innermost loop body... +* } +* STDLIB_NDARRAY_MSKFILTER_1D_LOOP_EPILOGUE +*/ +#define STDLIB_NDARRAY_MSKFILTER_1D_LOOP_PREAMBLE \ + struct ndarray *x1 = arrays[ 0 ]; \ + struct ndarray *x2 = arrays[ 1 ]; \ + struct ndarray *x3 = arrays[ 2 ]; \ + int64_t *shx1 = stdlib_ndarray_shape( x1 ); \ + int64_t *shx3 = stdlib_ndarray_shape( x3 ); \ + int64_t *sx1 = stdlib_ndarray_strides( x1 ); \ + int64_t *sx2 = stdlib_ndarray_strides( x2 ); \ + int64_t *sx3 = stdlib_ndarray_strides( x3 ); \ + uint8_t *px1 = stdlib_ndarray_data( x1 ); \ + uint8_t *px2 = stdlib_ndarray_data( x2 ); \ + uint8_t *px3 = stdlib_ndarray_data( x3 ); \ + int64_t d0x1; \ + int64_t d0x2; \ + int64_t d0x3; \ + int64_t S0; \ + int64_t i0; \ + /* Extract loop variables: dimensions and loop offset (pointer) increments... */ \ + S0 = shx1[ 0 ]; \ + d0x1 = sx1[ 0 ]; \ + d0x2 = sx2[ 0 ]; \ + d0x3 = sx3[ 0 ]; \ + /* Set the pointers to the first indexed elements... */ \ + px1 += stdlib_ndarray_offset( x1 ); \ + px2 += stdlib_ndarray_offset( x2 ); \ + px3 += stdlib_ndarray_offset( x3 ); \ + /* Iterate over the ndarray dimensions... */ \ + for ( i0 = 0; i0 < S0; i0++, px1 += d0x1, px2 += d0x2 ) + +/** +* Macro containing the epilogue for loops which operate on elements of a one-dimensional ndarray with a mask. +* +* @example +* STDLIB_NDARRAY_MSKFILTER_1D_LOOP_PREMABLE { +* // Innermost loop body... +* } +* STDLIB_NDARRAY_MSKFILTER_1D_LOOP_EPILOGUE +*/ +#define STDLIB_NDARRAY_MSKFILTER_1D_LOOP_EPILOGUE + +/** +* Macro for a unary one-dimensional ndarray loop which applies mask and cast input ndarray elements and assigns unmasked values to an output ndarray. +* +* ## Notes +* +* - Retrieves each ndarray element according to type `tin` via the pointer `px1`. +* - Retrieves a mask element according to type `uint8_t` via the pointer `px2`. +* - If the mask element is truthy then explicitly casts the ndarray element to `tout`. +* - Stores the result in an output ndarray via the pointer `px3`. +* +* @param tin input type +* @param tout output type +* +* @example +* // e.g., d_d +* STDLIB_NDARRAY_MSKFILTER_1D_LOOP_CAST( double, double ) +*/ +#define STDLIB_NDARRAY_MSKFILTER_1D_LOOP_CAST( tin, tout ) \ + STDLIB_NDARRAY_MSKFILTER_1D_LOOP_PREAMBLE { \ + if ( *(uint8_t *)px2 ) { \ + const tin x = *(tin *)px1; \ + *(tout *)px3 = (tout)x; \ + px3 += d0x3; \ + } \ + } \ + STDLIB_NDARRAY_MSKFILTER_1D_LOOP_EPILOGUE + +/** +* Macro for a unary one-dimensional ndarray loop which applies mask and does not cast input ndarray elements and assigns unmasked values to an output ndarray. +* +* ## Notes +* +* - Retrieves each ndarray element according to type `tin` via the pointer `px1`. +* - Retrieves a mask element according to type `uint8_t` via the pointer `px2`. +* - If the mask element is truthy then stores the ndarray element in an output ndarray of type `tout` via the pointer `px3`. +* +* @param tin input type +* @param tout output type +* +* @example +* #include "stdlib/complex/float64/ctor.h" +* +* // e.g., z_z +* STDLIB_NDARRAY_ASSIGN_1D_LOOP_NOCAST( stdlib_complex128_t, stdlib_complex128_t ) +*/ +#define STDLIB_NDARRAY_MSKFILTER_1D_LOOP_NOCAST( tin, tout ) \ + STDLIB_NDARRAY_MSKFILTER_1D_LOOP_PREAMBLE { \ + if ( *(uint8_t *)px2 ) { \ + const tin x = *(tin *)px1; \ + *(tout *)px3 = x; \ + px3 += d0x3; \ + } \ + } \ + STDLIB_NDARRAY_MSKFILTER_1D_LOOP_EPILOGUE + +#endif // !STDLIB_NDARRAY_BASE_MSKFILTER_MACROS_1D_H diff --git a/lib/node_modules/@stdlib/ndarray/base/mskfilter/include/stdlib/ndarray/base/mskfilter/macros/2d.h b/lib/node_modules/@stdlib/ndarray/base/mskfilter/include/stdlib/ndarray/base/mskfilter/macros/2d.h new file mode 100644 index 00000000000..e60d838f265 --- /dev/null +++ b/lib/node_modules/@stdlib/ndarray/base/mskfilter/include/stdlib/ndarray/base/mskfilter/macros/2d.h @@ -0,0 +1,157 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2024 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +#ifndef STDLIB_NDARRAY_BASE_MSKFILTER_MACROS_2D_H +#define STDLIB_NDARRAY_BASE_MSKFILTER_MACROS_2D_H + +#include "stdlib/ndarray/ctor.h" +#include "stdlib/ndarray/orders.h" +#include + +/** +* Macro containing the preamble for a loop which operates on elements of a two-dimensional ndarray, with a mask array. +* +* ## Notes +* +* - Variable naming conventions: +* +* - `sx#`, `px#`, and `d@x#` where `#` corresponds to the ndarray argument number, starting at `1`. +* - `S@`, `i@`, and `d@x#` where `@` corresponds to the loop number, with `0` being the innermost loop. +* +* @example +* STDLIB_NDARRAY_MSKFILTER_2D_LOOP_PREMABLE { +* // Innermost loop body... +* } +* STDLIB_NDARRAY_MSKFILTER_2D_LOOP_EPILOGUE +*/ +#define STDLIB_NDARRAY_MSKFILTER_2D_LOOP_PREAMBLE \ + struct ndarray *x1 = arrays[ 0 ]; \ + struct ndarray *x2 = arrays[ 1 ]; \ + struct ndarray *x3 = arrays[ 2 ]; \ + int64_t *shx1 = stdlib_ndarray_shape( x1 ); \ + int64_t *shx3 = stdlib_ndarray_shape( x3 ); \ + int64_t *sx1 = stdlib_ndarray_strides( x1 ); \ + int64_t *sx2 = stdlib_ndarray_strides( x2 ); \ + int64_t *sx3 = stdlib_ndarray_strides( x3 ); \ + uint8_t *px1 = stdlib_ndarray_data( x1 ); \ + uint8_t *px2 = stdlib_ndarray_data( x2 ); \ + uint8_t *px3 = stdlib_ndarray_data( x3 ); \ + int64_t d0x1; \ + int64_t d1x1; \ + int64_t d0x2; \ + int64_t d1x2; \ + int64_t d0x3; \ + int64_t S0; \ + int64_t S1; \ + int64_t i0; \ + int64_t i1; \ + /* Extract loop variables for purposes of loop interchange: dimensions and loop offset (pointer) increments... */ \ + if ( stdlib_ndarray_order( x1 ) == STDLIB_NDARRAY_ROW_MAJOR ) { \ + /* For row-major ndarrays, the last dimensions have the fastest changing indices... */ \ + S0 = shx1[ 1 ]; \ + S1 = shx1[ 0 ]; \ + d0x1 = sx1[ 1 ]; \ + d1x1 = sx1[ 0 ] - ( S0*sx1[1] ); \ + d0x2 = sx2[ 1 ]; \ + d1x2 = sx2[ 0 ] - ( S0*sx2[1] ); \ + } else { \ + /* For column-major ndarrays, the first dimensions have the fastest changing indices... */ \ + S0 = shx1[ 0 ]; \ + S1 = shx1[ 1 ]; \ + d0x1 = sx1[ 0 ]; \ + d1x1 = sx1[ 1 ] - ( S0*sx1[0] ); \ + d0x2 = sx2[ 0 ]; \ + d1x2 = sx2[ 1 ] - ( S0*sx2[0] ); \ + } \ + d0x3 = sx3[ 0 ]; \ + /* Set the pointers to the first indexed elements... */ \ + px1 += stdlib_ndarray_offset( x1 ); \ + px2 += stdlib_ndarray_offset( x2 ); \ + px3 += stdlib_ndarray_offset( x3 ); \ + /* Iterate over the ndarray dimensions... */ \ + for ( i1 = 0; i1 < S1; i1++, px1 += d1x1, px2 += d1x2 ) { \ + for ( i0 = 0; i0 < S0; i0++, px1 += d0x1, px2 += d0x2 ) + +/** +* Macro containing the epilogue for loops which operate on elements of a two-dimensional ndarray with a mask. +* +* @example +* STDLIB_NDARRAY_MSKFILTER_2D_LOOP_PREMABLE { +* // Innermost loop body... +* } +* STDLIB_NDARRAY_MSKFILTER_2D_LOOP_EPILOGUE +*/ +#define STDLIB_NDARRAY_MSKFILTER_2D_LOOP_EPILOGUE \ + } + +/** +* Macro for a unary two-dimensional ndarray loop which applies mask and cast input ndarray elements and assigns unmasked values to an output ndarray. +* +* ## Notes +* +* - Retrieves each ndarray element according to type `tin` via the pointer `px1`. +* - Retrieves a mask element according to type `uint8_t` via the pointer `px2`. +* - If the mask element is truthy then explicitly casts the ndarray element to `tout`. +* - Stores the result in an output ndarray via the pointer `px3`. +* +* @param tin input type +* @param tout output type +* +* @example +* // e.g., d_d +* STDLIB_NDARRAY_MSKFILTER_2D_LOOP_CAST( double, double ) +*/ +#define STDLIB_NDARRAY_MSKFILTER_2D_LOOP_CAST( tin, tout ) \ + STDLIB_NDARRAY_MSKFILTER_2D_LOOP_PREAMBLE { \ + if ( *(uint8_t *)px2 ) { \ + const tin x = *(tin *)px1; \ + *(tout *)px3 = (tout)x; \ + px3 += d0x3; \ + } \ + } \ + STDLIB_NDARRAY_MSKFILTER_2D_LOOP_EPILOGUE + +/** +* Macro for a unary one-dimensional ndarray loop which applies mask and does not cast input ndarray elements and assigns unmasked values to an output ndarray. +* +* ## Notes +* +* - Retrieves each ndarray element according to type `tin` via the pointer `px1`. +* - Retrieves a mask element according to type `uint8_t` via the pointer `px2`. +* - If the mask element is truthy then stores the ndarray element in an output ndarray of type `tout` via the pointer `px3`. +* +* @param tin input type +* @param tout output type +* +* @example +* #include "stdlib/complex/float64/ctor.h" +* +* // e.g., z_z +* STDLIB_NDARRAY_MSKFILTER_2D_LOOP_NOCAST( stdlib_complex128_t, stdlib_complex128_t ) +*/ +#define STDLIB_NDARRAY_MSKFILTER_2D_LOOP_NOCAST( tin, tout ) \ + STDLIB_NDARRAY_MSKFILTER_2D_LOOP_PREAMBLE { \ + if ( *(uint8_t *)px2 ) { \ + const tin x = *(tin *)px1; \ + *(tout *)px3 = x; \ + px3 += d0x3; \ + } \ + } \ + STDLIB_NDARRAY_MSKFILTER_2D_LOOP_EPILOGUE + +#endif // !STDLIB_NDARRAY_BASE_MSKFILTER_MACROS_2D_H diff --git a/lib/node_modules/@stdlib/ndarray/base/mskfilter/include/stdlib/ndarray/base/mskfilter/macros/2d_blocked.h b/lib/node_modules/@stdlib/ndarray/base/mskfilter/include/stdlib/ndarray/base/mskfilter/macros/2d_blocked.h new file mode 100644 index 00000000000..09076aea00a --- /dev/null +++ b/lib/node_modules/@stdlib/ndarray/base/mskfilter/include/stdlib/ndarray/base/mskfilter/macros/2d_blocked.h @@ -0,0 +1,212 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2024 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +#ifndef STDLIB_NDARRAY_BASE_MSKFILTER_MACROS_2D_BLOCKED_H +#define STDLIB_NDARRAY_BASE_MSKFILTER_MACROS_2D_BLOCKED_H + +#include "stdlib/ndarray/base/mskfilter/macros/constants.h" +#include "stdlib/ndarray/base/mskfilter/internal/permute.h" +#include "stdlib/ndarray/base/mskfilter/internal/range.h" +#include "stdlib/ndarray/base/mskfilter/internal/sort2ins.h" +#include "stdlib/ndarray/base/bytes_per_element.h" +#include "stdlib/ndarray/ctor.h" +#include +#include + +/** +* Macro containing the preamble for blocked nested loops which operate on elements of a two-dimensional ndarray. +* +* ## Notes +* +* - Variable naming conventions: +* +* - `sx#`, `pbx#`, `px#`, `ox#`, `nbx#`, and `d@x#` where `#` corresponds to the ndarray argument number, starting at `1`. +* - `S@`, `i@`, `j@`, `o@x#`, and `d@x#` where `@` corresponds to the loop number, with `0` being the innermost loop. +* +* @example +* STDLIB_NDARRAY_MSKFILTER_2D_BLOCKED_LOOP_PREMABLE { +* // Innermost loop body... +* } +* STDLIB_NDARRAY_MSKFILTER_2D_BLOCKED_LOOP_EPILOGUE +*/ +#define STDLIB_NDARRAY_MSKFILTER_2D_BLOCKED_LOOP_PREAMBLE \ + struct ndarray *x1 = arrays[ 0 ]; \ + struct ndarray *x2 = arrays[ 1 ]; \ + struct ndarray *x3 = arrays[ 2 ]; \ + int64_t shx1[2]; \ + int64_t sx1[2]; \ + int64_t sx2[2]; \ + int64_t sx3[1]; \ + int64_t idx[2]; \ + int64_t tmp[2]; \ + int64_t bsize; \ + uint8_t *pbx1; \ + uint8_t *pbx2; \ + uint8_t *pbx3; \ + uint8_t *px1; \ + uint8_t *px2; \ + uint8_t *px3; \ + int64_t d0x1; \ + int64_t d1x1; \ + int64_t d0x2; \ + int64_t d1x2; \ + int64_t d0x3; \ + int64_t o1x1; \ + int64_t o1x2; \ + int64_t nbx1; \ + int64_t nbx2; \ + int64_t ox1; \ + int64_t ox2; \ + int64_t s0; \ + int64_t s1; \ + int64_t i0; \ + int64_t i1; \ + int64_t j0; \ + int64_t j1; \ + /* Copy strides to prevent mutation to the original ndarray: */ \ + memcpy( sx1, stdlib_ndarray_strides( x1 ), sizeof sx1 ); \ + memcpy( sx3, stdlib_ndarray_strides( x3 ), sizeof sx3 ); \ + /* Create a loop interchange index array for loop order permutation: */ \ + stdlib_ndarray_base_mskfilter_internal_range( 2, idx ); \ + /* Sort the input array strides in increasing order (of magnitude): */ \ + stdlib_ndarray_base_mskfilter_internal_sort2ins( 2, sx1, idx ); \ + /* Permute the shape and array strides (avoiding mutation) according to loop order: */ \ + stdlib_ndarray_base_mskfilter_internal_permute( 2, stdlib_ndarray_shape( x1 ), idx, tmp ); \ + memcpy( shx1, tmp, sizeof shx1 ); \ + stdlib_ndarray_base_mskfilter_internal_permute( 2, stdlib_ndarray_strides( x2 ), idx, tmp ); \ + memcpy( sx2, tmp, sizeof sx2 ); \ + /* Determine the block size... */ \ + nbx1 = stdlib_ndarray_bytes_per_element( stdlib_ndarray_dtype( x1 ) ); \ + nbx2 = stdlib_ndarray_bytes_per_element( stdlib_ndarray_dtype( x2 ) ); \ + if ( nbx1 == 0 && nbx2 == 0 ) { \ + bsize = STDLIB_NDARRAY_MSKFILTER_BLOCK_SIZE_IN_ELEMENTS; \ + } else if ( nbx1 > nbx2 ) { \ + bsize = STDLIB_NDARRAY_MSKFILTER_BLOCK_SIZE_IN_BYTES / nbx1; \ + } else { \ + bsize = STDLIB_NDARRAY_MSKFILTER_BLOCK_SIZE_IN_BYTES / nbx2; \ + } \ + /* Cache pointers to the ndarray buffers... */ \ + pbx1 = stdlib_ndarray_data( x1 ); \ + pbx2 = stdlib_ndarray_data( x2 ); \ + pbx3 = stdlib_ndarray_data( x3 ); \ + /* Cache byte offsets to the first indexed elements... */ \ + ox1 = stdlib_ndarray_offset( x1 ); \ + ox2 = stdlib_ndarray_offset( x2 ); \ + px3 = stdlib_ndarray_offset( x3 ); \ + /* Cache offset increments for the innermost loop... */ \ + d0x1 = sx1[0]; \ + d0x2 = sx2[0]; \ + d0x3 = sx3[0]; \ + /* Iterate over blocks... */ \ + for ( j1 = shape[1]; j1 > 0; ) { \ + if ( j1 < bsize ) { \ + s1 = j1; \ + j1 = 0; \ + } else { \ + s1 = bsize; \ + j1 -= bsize; \ + } \ + o1x1 = ox1 + ( j1*sx1[1] ); \ + o1x2 = ox2 + ( j1*sx2[1] ); \ + for ( j0 = shape[0]; j0 > 0; ) { \ + if ( j0 < bsize ) { \ + s0 = j0; \ + j0 = 0; \ + } else { \ + s0 = bsize; \ + j0 -= bsize; \ + } \ + /* Compute pointers to the first ndarray elements in the current block... */ \ + px1 = pbx1 + o1x1 + ( j0*sx1[0] ); \ + px2 = pbx2 + o1x2 + ( j0*sx2[0] ); \ + /* Compute loop offset increments... */ \ + d1x1 = sx1[1] - ( s0*sx1[0] ); \ + d1x2 = sx2[1] - ( s0*sx2[0] ); \ + /* Iterate over the ndarray dimensions... */ \ + for ( i1 = 0; i1 < s1; i1++, px1 += d1x1, px2 += d1x2 ) { \ + for ( i0 = 0; i0 < s0; i0++, px1 += d0x1, px2 += d0x2 ) + +/** +* Macro containing the epilogue for blocked nested loops which operate on elements of a one-dimensional ndarray with a mask. +* +* @example +* STDLIB_NDARRAY_MSKFILTER_2D_BLOCKED_LOOP_PREMABLE { +* // Innermost loop body... +* } +* STDLIB_NDARRAY_MSKFILTER_2D_BLOCKED_LOOP_EPILOGUE +*/ +#define STDLIB_NDARRAY_MSKFILTER_2D_BLOCKED_LOOP_EPILOGUE \ + } \ + } \ + } + +/** +* Macro for a blocked unary two-dimensional ndarray loop which applies mask and cast input ndarray elements and assigns unmasked values to an output ndarray. +* +* ## Notes +* +* - Retrieves each ndarray element according to type `tin` via the pointer `px1`. +* - Retrieves a mask element according to type `uint8_t` via the pointer `px2`. +* - If the mask element is truthy then explicitly casts the ndarray element to `tout`. +* - Stores the result in an output ndarray via the pointer `px3`. +* +* @param tin input type +* @param tout output type +* +* @example +* // e.g., d_d +* STDLIB_NDARRAY_MSKFILTER_2D_BLOCKED_LOOP_CAST( double, double ) +*/ +#define STDLIB_NDARRAY_MSKFILTER_2D_BLOCKED_LOOP_CAST( tin, tout ) \ + STDLIB_NDARRAY_MSKFILTER_2D_BLOCKED_LOOP_PREAMBLE { \ + if ( *(uint8_t *)px2 ) { \ + const tin x = *(tin *)px1; \ + *(tout *)px3 = (tout)x; \ + px3 += d0x3; \ + } \ + } \ + STDLIB_NDARRAY_MSKFILTER_2D_BLOCKED_LOOP_EPILOGUE +/** +* Macro for a blocked unary one-dimensional ndarray loop which applies mask and does not cast input ndarray elements and assigns unmasked values to an output ndarray. +* +* ## Notes +* +* - Retrieves each ndarray element according to type `tin` via the pointer `px1`. +* - Retrieves a mask element according to type `uint8_t` via the pointer `px2`. +* - If the mask element is truthy then stores the ndarray element in an output ndarray of type `tout` via the pointer `px3`. +* +* @param tin input type +* @param tout output type +* +* @example +* #include "stdlib/complex/float64/ctor.h" +* +* // e.g., z_z +* STDLIB_NDARRAY_MSKFILTER_2D_BLOCKED_LOOP_NOCAST( stdlib_complex128_t, stdlib_complex128_t ) +*/ +#define STDLIB_NDARRAY_MSKFILTER_2D_BLOCKED_LOOP_NOCAST( tin, tout ) \ + STDLIB_NDARRAY_MSKFILTER_2D_BLOCKED_LOOP_PREAMBLE { \ + if ( *(uint8_t *)px2 ) { \ + const tin x = *(tin *)px1; \ + *(tout *)px3 = x; \ + px3 += d0x3; \ + } \ + } \ + STDLIB_NDARRAY_MSKFILTER_2D_BLOCKED_LOOP_EPILOGUE + +#endif // !STDLIB_NDARRAY_BASE_MSKFILTER_MACROS_2D_BLOCKED_H diff --git a/lib/node_modules/@stdlib/ndarray/base/mskfilter/scripts/templates/source.txt b/lib/node_modules/@stdlib/ndarray/base/mskfilter/scripts/templates/source.txt index 9b90d38a625..6d97e1c391f 100644 --- a/lib/node_modules/@stdlib/ndarray/base/mskfilter/scripts/templates/source.txt +++ b/lib/node_modules/@stdlib/ndarray/base/mskfilter/scripts/templates/source.txt @@ -110,7 +110,7 @@ * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_{{SIGNATURE}}_0d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -214,7 +214,7 @@ int8_t stdlib_ndarray_mskfilter_{{SIGNATURE}}_0d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_{{SIGNATURE}}_1d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -315,7 +315,7 @@ int8_t stdlib_ndarray_mskfilter_{{SIGNATURE}}_1d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_{{SIGNATURE}}_2d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -417,7 +417,7 @@ int8_t stdlib_ndarray_mskfilter_{{SIGNATURE}}_2d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_{{SIGNATURE}}_2d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -518,7 +518,7 @@ int8_t stdlib_ndarray_mskfilter_{{SIGNATURE}}_2d_blocked( struct ndarray *arrays * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_{{SIGNATURE}}_3d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -619,7 +619,7 @@ int8_t stdlib_ndarray_mskfilter_{{SIGNATURE}}_3d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_{{SIGNATURE}}_3d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -720,7 +720,7 @@ int8_t stdlib_ndarray_mskfilter_{{SIGNATURE}}_3d_blocked( struct ndarray *arrays * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_{{SIGNATURE}}_4d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -821,7 +821,7 @@ int8_t stdlib_ndarray_mskfilter_{{SIGNATURE}}_4d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_{{SIGNATURE}}_4d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -922,7 +922,7 @@ int8_t stdlib_ndarray_mskfilter_{{SIGNATURE}}_4d_blocked( struct ndarray *arrays * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_{{SIGNATURE}}_5d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1023,7 +1023,7 @@ int8_t stdlib_ndarray_mskfilter_{{SIGNATURE}}_5d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_{{SIGNATURE}}_5d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1124,7 +1124,7 @@ int8_t stdlib_ndarray_mskfilter_{{SIGNATURE}}_5d_blocked( struct ndarray *arrays * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_{{SIGNATURE}}_6d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1225,7 +1225,7 @@ int8_t stdlib_ndarray_mskfilter_{{SIGNATURE}}_6d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_{{SIGNATURE}}_6d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1326,7 +1326,7 @@ int8_t stdlib_ndarray_mskfilter_{{SIGNATURE}}_6d_blocked( struct ndarray *arrays * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_{{SIGNATURE}}_7d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1427,7 +1427,7 @@ int8_t stdlib_ndarray_mskfilter_{{SIGNATURE}}_7d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_{{SIGNATURE}}_7d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1528,7 +1528,7 @@ int8_t stdlib_ndarray_mskfilter_{{SIGNATURE}}_7d_blocked( struct ndarray *arrays * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_{{SIGNATURE}}_8d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1629,7 +1629,7 @@ int8_t stdlib_ndarray_mskfilter_{{SIGNATURE}}_8d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_{{SIGNATURE}}_8d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1730,7 +1730,7 @@ int8_t stdlib_ndarray_mskfilter_{{SIGNATURE}}_8d_blocked( struct ndarray *arrays * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_{{SIGNATURE}}_9d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1831,7 +1831,7 @@ int8_t stdlib_ndarray_mskfilter_{{SIGNATURE}}_9d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_{{SIGNATURE}}_9d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1932,7 +1932,7 @@ int8_t stdlib_ndarray_mskfilter_{{SIGNATURE}}_9d_blocked( struct ndarray *arrays * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_{{SIGNATURE}}_10d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2033,7 +2033,7 @@ int8_t stdlib_ndarray_mskfilter_{{SIGNATURE}}_10d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_{{SIGNATURE}}_10d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2134,7 +2134,7 @@ int8_t stdlib_ndarray_mskfilter_{{SIGNATURE}}_10d_blocked( struct ndarray *array * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_{{SIGNATURE}}_nd( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2279,7 +2279,7 @@ static const struct ndarrayUnarymskfilterDispatchObject obj = { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_{{SIGNATURE}}( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); diff --git a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/b_b.c b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/b_b.c index 96f4884f367..0a8a77cc8a2 100644 --- a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/b_b.c +++ b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/b_b.c @@ -110,7 +110,7 @@ * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_b_0d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -214,7 +214,7 @@ int8_t stdlib_ndarray_mskfilter_b_b_0d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_b_1d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -315,7 +315,7 @@ int8_t stdlib_ndarray_mskfilter_b_b_1d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_b_2d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -417,7 +417,7 @@ int8_t stdlib_ndarray_mskfilter_b_b_2d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_b_2d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -518,7 +518,7 @@ int8_t stdlib_ndarray_mskfilter_b_b_2d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_b_3d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -619,7 +619,7 @@ int8_t stdlib_ndarray_mskfilter_b_b_3d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_b_3d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -720,7 +720,7 @@ int8_t stdlib_ndarray_mskfilter_b_b_3d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_b_4d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -821,7 +821,7 @@ int8_t stdlib_ndarray_mskfilter_b_b_4d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_b_4d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -922,7 +922,7 @@ int8_t stdlib_ndarray_mskfilter_b_b_4d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_b_5d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1023,7 +1023,7 @@ int8_t stdlib_ndarray_mskfilter_b_b_5d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_b_5d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1124,7 +1124,7 @@ int8_t stdlib_ndarray_mskfilter_b_b_5d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_b_6d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1225,7 +1225,7 @@ int8_t stdlib_ndarray_mskfilter_b_b_6d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_b_6d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1326,7 +1326,7 @@ int8_t stdlib_ndarray_mskfilter_b_b_6d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_b_7d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1427,7 +1427,7 @@ int8_t stdlib_ndarray_mskfilter_b_b_7d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_b_7d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1528,7 +1528,7 @@ int8_t stdlib_ndarray_mskfilter_b_b_7d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_b_8d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1629,7 +1629,7 @@ int8_t stdlib_ndarray_mskfilter_b_b_8d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_b_8d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1730,7 +1730,7 @@ int8_t stdlib_ndarray_mskfilter_b_b_8d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_b_9d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1831,7 +1831,7 @@ int8_t stdlib_ndarray_mskfilter_b_b_9d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_b_9d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1932,7 +1932,7 @@ int8_t stdlib_ndarray_mskfilter_b_b_9d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_b_10d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2033,7 +2033,7 @@ int8_t stdlib_ndarray_mskfilter_b_b_10d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_b_10d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2134,7 +2134,7 @@ int8_t stdlib_ndarray_mskfilter_b_b_10d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_b_nd( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2279,7 +2279,7 @@ static const struct ndarrayUnarymskfilterDispatchObject obj = { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_b( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); diff --git a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/b_c.c b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/b_c.c index 90ee22fa694..96787966ad0 100644 --- a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/b_c.c +++ b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/b_c.c @@ -111,7 +111,7 @@ * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_c_0d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -215,7 +215,7 @@ int8_t stdlib_ndarray_mskfilter_b_c_0d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_c_1d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -316,7 +316,7 @@ int8_t stdlib_ndarray_mskfilter_b_c_1d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_c_2d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -418,7 +418,7 @@ int8_t stdlib_ndarray_mskfilter_b_c_2d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_c_2d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -519,7 +519,7 @@ int8_t stdlib_ndarray_mskfilter_b_c_2d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_c_3d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -620,7 +620,7 @@ int8_t stdlib_ndarray_mskfilter_b_c_3d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_c_3d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -721,7 +721,7 @@ int8_t stdlib_ndarray_mskfilter_b_c_3d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_c_4d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -822,7 +822,7 @@ int8_t stdlib_ndarray_mskfilter_b_c_4d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_c_4d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -923,7 +923,7 @@ int8_t stdlib_ndarray_mskfilter_b_c_4d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_c_5d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1024,7 +1024,7 @@ int8_t stdlib_ndarray_mskfilter_b_c_5d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_c_5d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1125,7 +1125,7 @@ int8_t stdlib_ndarray_mskfilter_b_c_5d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_c_6d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1226,7 +1226,7 @@ int8_t stdlib_ndarray_mskfilter_b_c_6d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_c_6d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1327,7 +1327,7 @@ int8_t stdlib_ndarray_mskfilter_b_c_6d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_c_7d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1428,7 +1428,7 @@ int8_t stdlib_ndarray_mskfilter_b_c_7d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_c_7d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1529,7 +1529,7 @@ int8_t stdlib_ndarray_mskfilter_b_c_7d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_c_8d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1630,7 +1630,7 @@ int8_t stdlib_ndarray_mskfilter_b_c_8d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_c_8d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1731,7 +1731,7 @@ int8_t stdlib_ndarray_mskfilter_b_c_8d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_c_9d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1832,7 +1832,7 @@ int8_t stdlib_ndarray_mskfilter_b_c_9d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_c_9d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1933,7 +1933,7 @@ int8_t stdlib_ndarray_mskfilter_b_c_9d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_c_10d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2034,7 +2034,7 @@ int8_t stdlib_ndarray_mskfilter_b_c_10d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_c_10d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2135,7 +2135,7 @@ int8_t stdlib_ndarray_mskfilter_b_c_10d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_c_nd( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2280,7 +2280,7 @@ static const struct ndarrayUnarymskfilterDispatchObject obj = { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_c( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); diff --git a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/b_d.c b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/b_d.c index 0391b739147..a092fb9b05f 100644 --- a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/b_d.c +++ b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/b_d.c @@ -110,7 +110,7 @@ * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_d_0d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -214,7 +214,7 @@ int8_t stdlib_ndarray_mskfilter_b_d_0d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_d_1d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -315,7 +315,7 @@ int8_t stdlib_ndarray_mskfilter_b_d_1d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_d_2d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -417,7 +417,7 @@ int8_t stdlib_ndarray_mskfilter_b_d_2d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_d_2d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -518,7 +518,7 @@ int8_t stdlib_ndarray_mskfilter_b_d_2d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_d_3d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -619,7 +619,7 @@ int8_t stdlib_ndarray_mskfilter_b_d_3d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_d_3d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -720,7 +720,7 @@ int8_t stdlib_ndarray_mskfilter_b_d_3d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_d_4d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -821,7 +821,7 @@ int8_t stdlib_ndarray_mskfilter_b_d_4d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_d_4d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -922,7 +922,7 @@ int8_t stdlib_ndarray_mskfilter_b_d_4d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_d_5d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1023,7 +1023,7 @@ int8_t stdlib_ndarray_mskfilter_b_d_5d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_d_5d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1124,7 +1124,7 @@ int8_t stdlib_ndarray_mskfilter_b_d_5d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_d_6d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1225,7 +1225,7 @@ int8_t stdlib_ndarray_mskfilter_b_d_6d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_d_6d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1326,7 +1326,7 @@ int8_t stdlib_ndarray_mskfilter_b_d_6d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_d_7d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1427,7 +1427,7 @@ int8_t stdlib_ndarray_mskfilter_b_d_7d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_d_7d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1528,7 +1528,7 @@ int8_t stdlib_ndarray_mskfilter_b_d_7d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_d_8d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1629,7 +1629,7 @@ int8_t stdlib_ndarray_mskfilter_b_d_8d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_d_8d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1730,7 +1730,7 @@ int8_t stdlib_ndarray_mskfilter_b_d_8d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_d_9d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1831,7 +1831,7 @@ int8_t stdlib_ndarray_mskfilter_b_d_9d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_d_9d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1932,7 +1932,7 @@ int8_t stdlib_ndarray_mskfilter_b_d_9d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_d_10d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2033,7 +2033,7 @@ int8_t stdlib_ndarray_mskfilter_b_d_10d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_d_10d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2134,7 +2134,7 @@ int8_t stdlib_ndarray_mskfilter_b_d_10d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_d_nd( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2279,7 +2279,7 @@ static const struct ndarrayUnarymskfilterDispatchObject obj = { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); diff --git a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/b_f.c b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/b_f.c index 1fe0e95e9ff..f7749a519ea 100644 --- a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/b_f.c +++ b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/b_f.c @@ -110,7 +110,7 @@ * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_f_0d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -214,7 +214,7 @@ int8_t stdlib_ndarray_mskfilter_b_f_0d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_f_1d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -315,7 +315,7 @@ int8_t stdlib_ndarray_mskfilter_b_f_1d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_f_2d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -417,7 +417,7 @@ int8_t stdlib_ndarray_mskfilter_b_f_2d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_f_2d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -518,7 +518,7 @@ int8_t stdlib_ndarray_mskfilter_b_f_2d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_f_3d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -619,7 +619,7 @@ int8_t stdlib_ndarray_mskfilter_b_f_3d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_f_3d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -720,7 +720,7 @@ int8_t stdlib_ndarray_mskfilter_b_f_3d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_f_4d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -821,7 +821,7 @@ int8_t stdlib_ndarray_mskfilter_b_f_4d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_f_4d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -922,7 +922,7 @@ int8_t stdlib_ndarray_mskfilter_b_f_4d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_f_5d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1023,7 +1023,7 @@ int8_t stdlib_ndarray_mskfilter_b_f_5d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_f_5d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1124,7 +1124,7 @@ int8_t stdlib_ndarray_mskfilter_b_f_5d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_f_6d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1225,7 +1225,7 @@ int8_t stdlib_ndarray_mskfilter_b_f_6d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_f_6d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1326,7 +1326,7 @@ int8_t stdlib_ndarray_mskfilter_b_f_6d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_f_7d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1427,7 +1427,7 @@ int8_t stdlib_ndarray_mskfilter_b_f_7d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_f_7d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1528,7 +1528,7 @@ int8_t stdlib_ndarray_mskfilter_b_f_7d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_f_8d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1629,7 +1629,7 @@ int8_t stdlib_ndarray_mskfilter_b_f_8d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_f_8d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1730,7 +1730,7 @@ int8_t stdlib_ndarray_mskfilter_b_f_8d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_f_9d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1831,7 +1831,7 @@ int8_t stdlib_ndarray_mskfilter_b_f_9d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_f_9d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1932,7 +1932,7 @@ int8_t stdlib_ndarray_mskfilter_b_f_9d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_f_10d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2033,7 +2033,7 @@ int8_t stdlib_ndarray_mskfilter_b_f_10d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_f_10d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2134,7 +2134,7 @@ int8_t stdlib_ndarray_mskfilter_b_f_10d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_f_nd( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2279,7 +2279,7 @@ static const struct ndarrayUnarymskfilterDispatchObject obj = { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_f( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); diff --git a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/b_i.c b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/b_i.c index bdcf9006bac..a480469ce55 100644 --- a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/b_i.c +++ b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/b_i.c @@ -110,7 +110,7 @@ * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_i_0d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -214,7 +214,7 @@ int8_t stdlib_ndarray_mskfilter_b_i_0d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_i_1d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -315,7 +315,7 @@ int8_t stdlib_ndarray_mskfilter_b_i_1d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_i_2d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -417,7 +417,7 @@ int8_t stdlib_ndarray_mskfilter_b_i_2d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_i_2d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -518,7 +518,7 @@ int8_t stdlib_ndarray_mskfilter_b_i_2d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_i_3d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -619,7 +619,7 @@ int8_t stdlib_ndarray_mskfilter_b_i_3d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_i_3d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -720,7 +720,7 @@ int8_t stdlib_ndarray_mskfilter_b_i_3d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_i_4d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -821,7 +821,7 @@ int8_t stdlib_ndarray_mskfilter_b_i_4d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_i_4d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -922,7 +922,7 @@ int8_t stdlib_ndarray_mskfilter_b_i_4d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_i_5d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1023,7 +1023,7 @@ int8_t stdlib_ndarray_mskfilter_b_i_5d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_i_5d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1124,7 +1124,7 @@ int8_t stdlib_ndarray_mskfilter_b_i_5d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_i_6d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1225,7 +1225,7 @@ int8_t stdlib_ndarray_mskfilter_b_i_6d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_i_6d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1326,7 +1326,7 @@ int8_t stdlib_ndarray_mskfilter_b_i_6d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_i_7d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1427,7 +1427,7 @@ int8_t stdlib_ndarray_mskfilter_b_i_7d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_i_7d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1528,7 +1528,7 @@ int8_t stdlib_ndarray_mskfilter_b_i_7d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_i_8d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1629,7 +1629,7 @@ int8_t stdlib_ndarray_mskfilter_b_i_8d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_i_8d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1730,7 +1730,7 @@ int8_t stdlib_ndarray_mskfilter_b_i_8d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_i_9d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1831,7 +1831,7 @@ int8_t stdlib_ndarray_mskfilter_b_i_9d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_i_9d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1932,7 +1932,7 @@ int8_t stdlib_ndarray_mskfilter_b_i_9d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_i_10d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2033,7 +2033,7 @@ int8_t stdlib_ndarray_mskfilter_b_i_10d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_i_10d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2134,7 +2134,7 @@ int8_t stdlib_ndarray_mskfilter_b_i_10d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_i_nd( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2279,7 +2279,7 @@ static const struct ndarrayUnarymskfilterDispatchObject obj = { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_i( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); diff --git a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/b_k.c b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/b_k.c index b79118bbee1..6e9ba82ee69 100644 --- a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/b_k.c +++ b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/b_k.c @@ -110,7 +110,7 @@ * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_k_0d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -214,7 +214,7 @@ int8_t stdlib_ndarray_mskfilter_b_k_0d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_k_1d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -315,7 +315,7 @@ int8_t stdlib_ndarray_mskfilter_b_k_1d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_k_2d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -417,7 +417,7 @@ int8_t stdlib_ndarray_mskfilter_b_k_2d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_k_2d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -518,7 +518,7 @@ int8_t stdlib_ndarray_mskfilter_b_k_2d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_k_3d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -619,7 +619,7 @@ int8_t stdlib_ndarray_mskfilter_b_k_3d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_k_3d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -720,7 +720,7 @@ int8_t stdlib_ndarray_mskfilter_b_k_3d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_k_4d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -821,7 +821,7 @@ int8_t stdlib_ndarray_mskfilter_b_k_4d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_k_4d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -922,7 +922,7 @@ int8_t stdlib_ndarray_mskfilter_b_k_4d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_k_5d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1023,7 +1023,7 @@ int8_t stdlib_ndarray_mskfilter_b_k_5d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_k_5d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1124,7 +1124,7 @@ int8_t stdlib_ndarray_mskfilter_b_k_5d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_k_6d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1225,7 +1225,7 @@ int8_t stdlib_ndarray_mskfilter_b_k_6d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_k_6d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1326,7 +1326,7 @@ int8_t stdlib_ndarray_mskfilter_b_k_6d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_k_7d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1427,7 +1427,7 @@ int8_t stdlib_ndarray_mskfilter_b_k_7d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_k_7d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1528,7 +1528,7 @@ int8_t stdlib_ndarray_mskfilter_b_k_7d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_k_8d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1629,7 +1629,7 @@ int8_t stdlib_ndarray_mskfilter_b_k_8d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_k_8d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1730,7 +1730,7 @@ int8_t stdlib_ndarray_mskfilter_b_k_8d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_k_9d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1831,7 +1831,7 @@ int8_t stdlib_ndarray_mskfilter_b_k_9d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_k_9d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1932,7 +1932,7 @@ int8_t stdlib_ndarray_mskfilter_b_k_9d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_k_10d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2033,7 +2033,7 @@ int8_t stdlib_ndarray_mskfilter_b_k_10d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_k_10d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2134,7 +2134,7 @@ int8_t stdlib_ndarray_mskfilter_b_k_10d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_k_nd( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2279,7 +2279,7 @@ static const struct ndarrayUnarymskfilterDispatchObject obj = { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_k( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); diff --git a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/b_t.c b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/b_t.c index 7f2f3b732f3..2d769dfb99c 100644 --- a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/b_t.c +++ b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/b_t.c @@ -110,7 +110,7 @@ * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_t_0d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -214,7 +214,7 @@ int8_t stdlib_ndarray_mskfilter_b_t_0d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_t_1d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -315,7 +315,7 @@ int8_t stdlib_ndarray_mskfilter_b_t_1d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_t_2d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -417,7 +417,7 @@ int8_t stdlib_ndarray_mskfilter_b_t_2d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_t_2d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -518,7 +518,7 @@ int8_t stdlib_ndarray_mskfilter_b_t_2d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_t_3d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -619,7 +619,7 @@ int8_t stdlib_ndarray_mskfilter_b_t_3d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_t_3d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -720,7 +720,7 @@ int8_t stdlib_ndarray_mskfilter_b_t_3d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_t_4d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -821,7 +821,7 @@ int8_t stdlib_ndarray_mskfilter_b_t_4d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_t_4d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -922,7 +922,7 @@ int8_t stdlib_ndarray_mskfilter_b_t_4d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_t_5d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1023,7 +1023,7 @@ int8_t stdlib_ndarray_mskfilter_b_t_5d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_t_5d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1124,7 +1124,7 @@ int8_t stdlib_ndarray_mskfilter_b_t_5d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_t_6d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1225,7 +1225,7 @@ int8_t stdlib_ndarray_mskfilter_b_t_6d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_t_6d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1326,7 +1326,7 @@ int8_t stdlib_ndarray_mskfilter_b_t_6d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_t_7d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1427,7 +1427,7 @@ int8_t stdlib_ndarray_mskfilter_b_t_7d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_t_7d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1528,7 +1528,7 @@ int8_t stdlib_ndarray_mskfilter_b_t_7d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_t_8d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1629,7 +1629,7 @@ int8_t stdlib_ndarray_mskfilter_b_t_8d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_t_8d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1730,7 +1730,7 @@ int8_t stdlib_ndarray_mskfilter_b_t_8d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_t_9d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1831,7 +1831,7 @@ int8_t stdlib_ndarray_mskfilter_b_t_9d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_t_9d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1932,7 +1932,7 @@ int8_t stdlib_ndarray_mskfilter_b_t_9d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_t_10d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2033,7 +2033,7 @@ int8_t stdlib_ndarray_mskfilter_b_t_10d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_t_10d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2134,7 +2134,7 @@ int8_t stdlib_ndarray_mskfilter_b_t_10d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_t_nd( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2279,7 +2279,7 @@ static const struct ndarrayUnarymskfilterDispatchObject obj = { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_t( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); diff --git a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/b_u.c b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/b_u.c index 8cb20e60e53..62ae1741cbc 100644 --- a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/b_u.c +++ b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/b_u.c @@ -110,7 +110,7 @@ * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_u_0d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -214,7 +214,7 @@ int8_t stdlib_ndarray_mskfilter_b_u_0d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_u_1d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -315,7 +315,7 @@ int8_t stdlib_ndarray_mskfilter_b_u_1d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_u_2d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -417,7 +417,7 @@ int8_t stdlib_ndarray_mskfilter_b_u_2d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_u_2d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -518,7 +518,7 @@ int8_t stdlib_ndarray_mskfilter_b_u_2d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_u_3d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -619,7 +619,7 @@ int8_t stdlib_ndarray_mskfilter_b_u_3d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_u_3d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -720,7 +720,7 @@ int8_t stdlib_ndarray_mskfilter_b_u_3d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_u_4d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -821,7 +821,7 @@ int8_t stdlib_ndarray_mskfilter_b_u_4d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_u_4d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -922,7 +922,7 @@ int8_t stdlib_ndarray_mskfilter_b_u_4d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_u_5d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1023,7 +1023,7 @@ int8_t stdlib_ndarray_mskfilter_b_u_5d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_u_5d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1124,7 +1124,7 @@ int8_t stdlib_ndarray_mskfilter_b_u_5d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_u_6d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1225,7 +1225,7 @@ int8_t stdlib_ndarray_mskfilter_b_u_6d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_u_6d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1326,7 +1326,7 @@ int8_t stdlib_ndarray_mskfilter_b_u_6d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_u_7d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1427,7 +1427,7 @@ int8_t stdlib_ndarray_mskfilter_b_u_7d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_u_7d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1528,7 +1528,7 @@ int8_t stdlib_ndarray_mskfilter_b_u_7d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_u_8d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1629,7 +1629,7 @@ int8_t stdlib_ndarray_mskfilter_b_u_8d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_u_8d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1730,7 +1730,7 @@ int8_t stdlib_ndarray_mskfilter_b_u_8d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_u_9d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1831,7 +1831,7 @@ int8_t stdlib_ndarray_mskfilter_b_u_9d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_u_9d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1932,7 +1932,7 @@ int8_t stdlib_ndarray_mskfilter_b_u_9d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_u_10d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2033,7 +2033,7 @@ int8_t stdlib_ndarray_mskfilter_b_u_10d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_u_10d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2134,7 +2134,7 @@ int8_t stdlib_ndarray_mskfilter_b_u_10d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_u_nd( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2279,7 +2279,7 @@ static const struct ndarrayUnarymskfilterDispatchObject obj = { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_u( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); diff --git a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/b_z.c b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/b_z.c index e6ca14f5589..17cb340db14 100644 --- a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/b_z.c +++ b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/b_z.c @@ -111,7 +111,7 @@ * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_z_0d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -215,7 +215,7 @@ int8_t stdlib_ndarray_mskfilter_b_z_0d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_z_1d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -316,7 +316,7 @@ int8_t stdlib_ndarray_mskfilter_b_z_1d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_z_2d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -418,7 +418,7 @@ int8_t stdlib_ndarray_mskfilter_b_z_2d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_z_2d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -519,7 +519,7 @@ int8_t stdlib_ndarray_mskfilter_b_z_2d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_z_3d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -620,7 +620,7 @@ int8_t stdlib_ndarray_mskfilter_b_z_3d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_z_3d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -721,7 +721,7 @@ int8_t stdlib_ndarray_mskfilter_b_z_3d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_z_4d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -822,7 +822,7 @@ int8_t stdlib_ndarray_mskfilter_b_z_4d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_z_4d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -923,7 +923,7 @@ int8_t stdlib_ndarray_mskfilter_b_z_4d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_z_5d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1024,7 +1024,7 @@ int8_t stdlib_ndarray_mskfilter_b_z_5d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_z_5d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1125,7 +1125,7 @@ int8_t stdlib_ndarray_mskfilter_b_z_5d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_z_6d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1226,7 +1226,7 @@ int8_t stdlib_ndarray_mskfilter_b_z_6d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_z_6d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1327,7 +1327,7 @@ int8_t stdlib_ndarray_mskfilter_b_z_6d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_z_7d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1428,7 +1428,7 @@ int8_t stdlib_ndarray_mskfilter_b_z_7d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_z_7d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1529,7 +1529,7 @@ int8_t stdlib_ndarray_mskfilter_b_z_7d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_z_8d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1630,7 +1630,7 @@ int8_t stdlib_ndarray_mskfilter_b_z_8d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_z_8d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1731,7 +1731,7 @@ int8_t stdlib_ndarray_mskfilter_b_z_8d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_z_9d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1832,7 +1832,7 @@ int8_t stdlib_ndarray_mskfilter_b_z_9d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_z_9d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1933,7 +1933,7 @@ int8_t stdlib_ndarray_mskfilter_b_z_9d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_z_10d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2034,7 +2034,7 @@ int8_t stdlib_ndarray_mskfilter_b_z_10d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_z_10d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2135,7 +2135,7 @@ int8_t stdlib_ndarray_mskfilter_b_z_10d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_z_nd( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2280,7 +2280,7 @@ static const struct ndarrayUnarymskfilterDispatchObject obj = { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_b_z( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); diff --git a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/c_c.c b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/c_c.c index b3d90079e66..b1510a26a1c 100644 --- a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/c_c.c +++ b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/c_c.c @@ -111,7 +111,7 @@ * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_c_c_0d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -215,7 +215,7 @@ int8_t stdlib_ndarray_mskfilter_c_c_0d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_c_c_1d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -316,7 +316,7 @@ int8_t stdlib_ndarray_mskfilter_c_c_1d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_c_c_2d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -418,7 +418,7 @@ int8_t stdlib_ndarray_mskfilter_c_c_2d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_c_c_2d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -519,7 +519,7 @@ int8_t stdlib_ndarray_mskfilter_c_c_2d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_c_c_3d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -620,7 +620,7 @@ int8_t stdlib_ndarray_mskfilter_c_c_3d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_c_c_3d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -721,7 +721,7 @@ int8_t stdlib_ndarray_mskfilter_c_c_3d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_c_c_4d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -822,7 +822,7 @@ int8_t stdlib_ndarray_mskfilter_c_c_4d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_c_c_4d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -923,7 +923,7 @@ int8_t stdlib_ndarray_mskfilter_c_c_4d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_c_c_5d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1024,7 +1024,7 @@ int8_t stdlib_ndarray_mskfilter_c_c_5d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_c_c_5d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1125,7 +1125,7 @@ int8_t stdlib_ndarray_mskfilter_c_c_5d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_c_c_6d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1226,7 +1226,7 @@ int8_t stdlib_ndarray_mskfilter_c_c_6d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_c_c_6d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1327,7 +1327,7 @@ int8_t stdlib_ndarray_mskfilter_c_c_6d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_c_c_7d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1428,7 +1428,7 @@ int8_t stdlib_ndarray_mskfilter_c_c_7d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_c_c_7d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1529,7 +1529,7 @@ int8_t stdlib_ndarray_mskfilter_c_c_7d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_c_c_8d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1630,7 +1630,7 @@ int8_t stdlib_ndarray_mskfilter_c_c_8d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_c_c_8d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1731,7 +1731,7 @@ int8_t stdlib_ndarray_mskfilter_c_c_8d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_c_c_9d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1832,7 +1832,7 @@ int8_t stdlib_ndarray_mskfilter_c_c_9d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_c_c_9d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1933,7 +1933,7 @@ int8_t stdlib_ndarray_mskfilter_c_c_9d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_c_c_10d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2034,7 +2034,7 @@ int8_t stdlib_ndarray_mskfilter_c_c_10d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_c_c_10d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2135,7 +2135,7 @@ int8_t stdlib_ndarray_mskfilter_c_c_10d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_c_c_nd( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2280,7 +2280,7 @@ static const struct ndarrayUnarymskfilterDispatchObject obj = { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_c_c( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); diff --git a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/c_z.c b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/c_z.c index c11659568cd..b45a8325f86 100644 --- a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/c_z.c +++ b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/c_z.c @@ -112,7 +112,7 @@ * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_c_z_0d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -216,7 +216,7 @@ int8_t stdlib_ndarray_mskfilter_c_z_0d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_c_z_1d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -317,7 +317,7 @@ int8_t stdlib_ndarray_mskfilter_c_z_1d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_c_z_2d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -419,7 +419,7 @@ int8_t stdlib_ndarray_mskfilter_c_z_2d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_c_z_2d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -520,7 +520,7 @@ int8_t stdlib_ndarray_mskfilter_c_z_2d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_c_z_3d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -621,7 +621,7 @@ int8_t stdlib_ndarray_mskfilter_c_z_3d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_c_z_3d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -722,7 +722,7 @@ int8_t stdlib_ndarray_mskfilter_c_z_3d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_c_z_4d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -823,7 +823,7 @@ int8_t stdlib_ndarray_mskfilter_c_z_4d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_c_z_4d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -924,7 +924,7 @@ int8_t stdlib_ndarray_mskfilter_c_z_4d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_c_z_5d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1025,7 +1025,7 @@ int8_t stdlib_ndarray_mskfilter_c_z_5d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_c_z_5d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1126,7 +1126,7 @@ int8_t stdlib_ndarray_mskfilter_c_z_5d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_c_z_6d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1227,7 +1227,7 @@ int8_t stdlib_ndarray_mskfilter_c_z_6d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_c_z_6d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1328,7 +1328,7 @@ int8_t stdlib_ndarray_mskfilter_c_z_6d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_c_z_7d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1429,7 +1429,7 @@ int8_t stdlib_ndarray_mskfilter_c_z_7d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_c_z_7d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1530,7 +1530,7 @@ int8_t stdlib_ndarray_mskfilter_c_z_7d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_c_z_8d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1631,7 +1631,7 @@ int8_t stdlib_ndarray_mskfilter_c_z_8d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_c_z_8d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1732,7 +1732,7 @@ int8_t stdlib_ndarray_mskfilter_c_z_8d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_c_z_9d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1833,7 +1833,7 @@ int8_t stdlib_ndarray_mskfilter_c_z_9d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_c_z_9d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1934,7 +1934,7 @@ int8_t stdlib_ndarray_mskfilter_c_z_9d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_c_z_10d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2035,7 +2035,7 @@ int8_t stdlib_ndarray_mskfilter_c_z_10d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_c_z_10d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2136,7 +2136,7 @@ int8_t stdlib_ndarray_mskfilter_c_z_10d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_c_z_nd( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2281,7 +2281,7 @@ static const struct ndarrayUnarymskfilterDispatchObject obj = { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_c_z( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); diff --git a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/d_c.c b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/d_c.c index ca34b51874a..ad9531dbc95 100644 --- a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/d_c.c +++ b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/d_c.c @@ -111,7 +111,7 @@ * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_d_c_0d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -215,7 +215,7 @@ int8_t stdlib_ndarray_mskfilter_d_c_0d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_d_c_1d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -316,7 +316,7 @@ int8_t stdlib_ndarray_mskfilter_d_c_1d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_d_c_2d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -418,7 +418,7 @@ int8_t stdlib_ndarray_mskfilter_d_c_2d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_d_c_2d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -519,7 +519,7 @@ int8_t stdlib_ndarray_mskfilter_d_c_2d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_d_c_3d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -620,7 +620,7 @@ int8_t stdlib_ndarray_mskfilter_d_c_3d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_d_c_3d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -721,7 +721,7 @@ int8_t stdlib_ndarray_mskfilter_d_c_3d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_d_c_4d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -822,7 +822,7 @@ int8_t stdlib_ndarray_mskfilter_d_c_4d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_d_c_4d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -923,7 +923,7 @@ int8_t stdlib_ndarray_mskfilter_d_c_4d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_d_c_5d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1024,7 +1024,7 @@ int8_t stdlib_ndarray_mskfilter_d_c_5d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_d_c_5d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1125,7 +1125,7 @@ int8_t stdlib_ndarray_mskfilter_d_c_5d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_d_c_6d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1226,7 +1226,7 @@ int8_t stdlib_ndarray_mskfilter_d_c_6d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_d_c_6d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1327,7 +1327,7 @@ int8_t stdlib_ndarray_mskfilter_d_c_6d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_d_c_7d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1428,7 +1428,7 @@ int8_t stdlib_ndarray_mskfilter_d_c_7d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_d_c_7d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1529,7 +1529,7 @@ int8_t stdlib_ndarray_mskfilter_d_c_7d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_d_c_8d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1630,7 +1630,7 @@ int8_t stdlib_ndarray_mskfilter_d_c_8d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_d_c_8d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1731,7 +1731,7 @@ int8_t stdlib_ndarray_mskfilter_d_c_8d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_d_c_9d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1832,7 +1832,7 @@ int8_t stdlib_ndarray_mskfilter_d_c_9d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_d_c_9d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1933,7 +1933,7 @@ int8_t stdlib_ndarray_mskfilter_d_c_9d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_d_c_10d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2034,7 +2034,7 @@ int8_t stdlib_ndarray_mskfilter_d_c_10d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_d_c_10d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2135,7 +2135,7 @@ int8_t stdlib_ndarray_mskfilter_d_c_10d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_d_c_nd( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2280,7 +2280,7 @@ static const struct ndarrayUnarymskfilterDispatchObject obj = { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_d_c( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); diff --git a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/d_d.c b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/d_d.c index 3f2244fcf03..d2ed9a6e4e0 100644 --- a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/d_d.c +++ b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/d_d.c @@ -110,7 +110,7 @@ * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_d_d_0d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -214,7 +214,7 @@ int8_t stdlib_ndarray_mskfilter_d_d_0d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_d_d_1d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -315,7 +315,7 @@ int8_t stdlib_ndarray_mskfilter_d_d_1d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_d_d_2d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -417,7 +417,7 @@ int8_t stdlib_ndarray_mskfilter_d_d_2d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_d_d_2d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -518,7 +518,7 @@ int8_t stdlib_ndarray_mskfilter_d_d_2d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_d_d_3d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -619,7 +619,7 @@ int8_t stdlib_ndarray_mskfilter_d_d_3d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_d_d_3d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -720,7 +720,7 @@ int8_t stdlib_ndarray_mskfilter_d_d_3d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_d_d_4d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -821,7 +821,7 @@ int8_t stdlib_ndarray_mskfilter_d_d_4d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_d_d_4d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -922,7 +922,7 @@ int8_t stdlib_ndarray_mskfilter_d_d_4d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_d_d_5d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1023,7 +1023,7 @@ int8_t stdlib_ndarray_mskfilter_d_d_5d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_d_d_5d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1124,7 +1124,7 @@ int8_t stdlib_ndarray_mskfilter_d_d_5d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_d_d_6d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1225,7 +1225,7 @@ int8_t stdlib_ndarray_mskfilter_d_d_6d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_d_d_6d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1326,7 +1326,7 @@ int8_t stdlib_ndarray_mskfilter_d_d_6d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_d_d_7d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1427,7 +1427,7 @@ int8_t stdlib_ndarray_mskfilter_d_d_7d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_d_d_7d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1528,7 +1528,7 @@ int8_t stdlib_ndarray_mskfilter_d_d_7d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_d_d_8d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1629,7 +1629,7 @@ int8_t stdlib_ndarray_mskfilter_d_d_8d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_d_d_8d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1730,7 +1730,7 @@ int8_t stdlib_ndarray_mskfilter_d_d_8d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_d_d_9d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1831,7 +1831,7 @@ int8_t stdlib_ndarray_mskfilter_d_d_9d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_d_d_9d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1932,7 +1932,7 @@ int8_t stdlib_ndarray_mskfilter_d_d_9d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_d_d_10d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2033,7 +2033,7 @@ int8_t stdlib_ndarray_mskfilter_d_d_10d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_d_d_10d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2134,7 +2134,7 @@ int8_t stdlib_ndarray_mskfilter_d_d_10d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_d_d_nd( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2279,7 +2279,7 @@ static const struct ndarrayUnarymskfilterDispatchObject obj = { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_d_d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); diff --git a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/d_f.c b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/d_f.c index a674b8b34a7..6c744914023 100644 --- a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/d_f.c +++ b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/d_f.c @@ -110,7 +110,7 @@ * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_d_f_0d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -214,7 +214,7 @@ int8_t stdlib_ndarray_mskfilter_d_f_0d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_d_f_1d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -315,7 +315,7 @@ int8_t stdlib_ndarray_mskfilter_d_f_1d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_d_f_2d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -417,7 +417,7 @@ int8_t stdlib_ndarray_mskfilter_d_f_2d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_d_f_2d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -518,7 +518,7 @@ int8_t stdlib_ndarray_mskfilter_d_f_2d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_d_f_3d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -619,7 +619,7 @@ int8_t stdlib_ndarray_mskfilter_d_f_3d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_d_f_3d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -720,7 +720,7 @@ int8_t stdlib_ndarray_mskfilter_d_f_3d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_d_f_4d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -821,7 +821,7 @@ int8_t stdlib_ndarray_mskfilter_d_f_4d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_d_f_4d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -922,7 +922,7 @@ int8_t stdlib_ndarray_mskfilter_d_f_4d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_d_f_5d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1023,7 +1023,7 @@ int8_t stdlib_ndarray_mskfilter_d_f_5d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_d_f_5d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1124,7 +1124,7 @@ int8_t stdlib_ndarray_mskfilter_d_f_5d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_d_f_6d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1225,7 +1225,7 @@ int8_t stdlib_ndarray_mskfilter_d_f_6d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_d_f_6d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1326,7 +1326,7 @@ int8_t stdlib_ndarray_mskfilter_d_f_6d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_d_f_7d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1427,7 +1427,7 @@ int8_t stdlib_ndarray_mskfilter_d_f_7d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_d_f_7d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1528,7 +1528,7 @@ int8_t stdlib_ndarray_mskfilter_d_f_7d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_d_f_8d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1629,7 +1629,7 @@ int8_t stdlib_ndarray_mskfilter_d_f_8d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_d_f_8d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1730,7 +1730,7 @@ int8_t stdlib_ndarray_mskfilter_d_f_8d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_d_f_9d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1831,7 +1831,7 @@ int8_t stdlib_ndarray_mskfilter_d_f_9d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_d_f_9d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1932,7 +1932,7 @@ int8_t stdlib_ndarray_mskfilter_d_f_9d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_d_f_10d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2033,7 +2033,7 @@ int8_t stdlib_ndarray_mskfilter_d_f_10d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_d_f_10d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2134,7 +2134,7 @@ int8_t stdlib_ndarray_mskfilter_d_f_10d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_d_f_nd( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2279,7 +2279,7 @@ static const struct ndarrayUnarymskfilterDispatchObject obj = { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_d_f( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); diff --git a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/d_z.c b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/d_z.c index f321e2cdcfa..37e5ad38675 100644 --- a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/d_z.c +++ b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/d_z.c @@ -111,7 +111,7 @@ * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_d_z_0d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -215,7 +215,7 @@ int8_t stdlib_ndarray_mskfilter_d_z_0d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_d_z_1d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -316,7 +316,7 @@ int8_t stdlib_ndarray_mskfilter_d_z_1d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_d_z_2d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -418,7 +418,7 @@ int8_t stdlib_ndarray_mskfilter_d_z_2d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_d_z_2d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -519,7 +519,7 @@ int8_t stdlib_ndarray_mskfilter_d_z_2d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_d_z_3d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -620,7 +620,7 @@ int8_t stdlib_ndarray_mskfilter_d_z_3d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_d_z_3d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -721,7 +721,7 @@ int8_t stdlib_ndarray_mskfilter_d_z_3d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_d_z_4d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -822,7 +822,7 @@ int8_t stdlib_ndarray_mskfilter_d_z_4d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_d_z_4d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -923,7 +923,7 @@ int8_t stdlib_ndarray_mskfilter_d_z_4d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_d_z_5d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1024,7 +1024,7 @@ int8_t stdlib_ndarray_mskfilter_d_z_5d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_d_z_5d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1125,7 +1125,7 @@ int8_t stdlib_ndarray_mskfilter_d_z_5d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_d_z_6d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1226,7 +1226,7 @@ int8_t stdlib_ndarray_mskfilter_d_z_6d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_d_z_6d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1327,7 +1327,7 @@ int8_t stdlib_ndarray_mskfilter_d_z_6d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_d_z_7d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1428,7 +1428,7 @@ int8_t stdlib_ndarray_mskfilter_d_z_7d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_d_z_7d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1529,7 +1529,7 @@ int8_t stdlib_ndarray_mskfilter_d_z_7d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_d_z_8d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1630,7 +1630,7 @@ int8_t stdlib_ndarray_mskfilter_d_z_8d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_d_z_8d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1731,7 +1731,7 @@ int8_t stdlib_ndarray_mskfilter_d_z_8d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_d_z_9d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1832,7 +1832,7 @@ int8_t stdlib_ndarray_mskfilter_d_z_9d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_d_z_9d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1933,7 +1933,7 @@ int8_t stdlib_ndarray_mskfilter_d_z_9d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_d_z_10d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2034,7 +2034,7 @@ int8_t stdlib_ndarray_mskfilter_d_z_10d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_d_z_10d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2135,7 +2135,7 @@ int8_t stdlib_ndarray_mskfilter_d_z_10d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_d_z_nd( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2280,7 +2280,7 @@ static const struct ndarrayUnarymskfilterDispatchObject obj = { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_d_z( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); diff --git a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/f_c.c b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/f_c.c index 13f15db61fa..3ac47fdb55b 100644 --- a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/f_c.c +++ b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/f_c.c @@ -111,7 +111,7 @@ * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_f_c_0d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -215,7 +215,7 @@ int8_t stdlib_ndarray_mskfilter_f_c_0d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_f_c_1d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -316,7 +316,7 @@ int8_t stdlib_ndarray_mskfilter_f_c_1d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_f_c_2d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -418,7 +418,7 @@ int8_t stdlib_ndarray_mskfilter_f_c_2d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_f_c_2d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -519,7 +519,7 @@ int8_t stdlib_ndarray_mskfilter_f_c_2d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_f_c_3d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -620,7 +620,7 @@ int8_t stdlib_ndarray_mskfilter_f_c_3d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_f_c_3d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -721,7 +721,7 @@ int8_t stdlib_ndarray_mskfilter_f_c_3d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_f_c_4d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -822,7 +822,7 @@ int8_t stdlib_ndarray_mskfilter_f_c_4d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_f_c_4d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -923,7 +923,7 @@ int8_t stdlib_ndarray_mskfilter_f_c_4d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_f_c_5d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1024,7 +1024,7 @@ int8_t stdlib_ndarray_mskfilter_f_c_5d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_f_c_5d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1125,7 +1125,7 @@ int8_t stdlib_ndarray_mskfilter_f_c_5d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_f_c_6d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1226,7 +1226,7 @@ int8_t stdlib_ndarray_mskfilter_f_c_6d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_f_c_6d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1327,7 +1327,7 @@ int8_t stdlib_ndarray_mskfilter_f_c_6d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_f_c_7d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1428,7 +1428,7 @@ int8_t stdlib_ndarray_mskfilter_f_c_7d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_f_c_7d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1529,7 +1529,7 @@ int8_t stdlib_ndarray_mskfilter_f_c_7d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_f_c_8d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1630,7 +1630,7 @@ int8_t stdlib_ndarray_mskfilter_f_c_8d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_f_c_8d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1731,7 +1731,7 @@ int8_t stdlib_ndarray_mskfilter_f_c_8d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_f_c_9d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1832,7 +1832,7 @@ int8_t stdlib_ndarray_mskfilter_f_c_9d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_f_c_9d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1933,7 +1933,7 @@ int8_t stdlib_ndarray_mskfilter_f_c_9d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_f_c_10d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2034,7 +2034,7 @@ int8_t stdlib_ndarray_mskfilter_f_c_10d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_f_c_10d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2135,7 +2135,7 @@ int8_t stdlib_ndarray_mskfilter_f_c_10d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_f_c_nd( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2280,7 +2280,7 @@ static const struct ndarrayUnarymskfilterDispatchObject obj = { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_f_c( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); diff --git a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/f_d.c b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/f_d.c index cafd8ca9c1f..c82adde9b15 100644 --- a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/f_d.c +++ b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/f_d.c @@ -110,7 +110,7 @@ * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_f_d_0d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -214,7 +214,7 @@ int8_t stdlib_ndarray_mskfilter_f_d_0d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_f_d_1d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -315,7 +315,7 @@ int8_t stdlib_ndarray_mskfilter_f_d_1d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_f_d_2d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -417,7 +417,7 @@ int8_t stdlib_ndarray_mskfilter_f_d_2d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_f_d_2d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -518,7 +518,7 @@ int8_t stdlib_ndarray_mskfilter_f_d_2d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_f_d_3d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -619,7 +619,7 @@ int8_t stdlib_ndarray_mskfilter_f_d_3d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_f_d_3d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -720,7 +720,7 @@ int8_t stdlib_ndarray_mskfilter_f_d_3d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_f_d_4d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -821,7 +821,7 @@ int8_t stdlib_ndarray_mskfilter_f_d_4d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_f_d_4d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -922,7 +922,7 @@ int8_t stdlib_ndarray_mskfilter_f_d_4d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_f_d_5d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1023,7 +1023,7 @@ int8_t stdlib_ndarray_mskfilter_f_d_5d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_f_d_5d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1124,7 +1124,7 @@ int8_t stdlib_ndarray_mskfilter_f_d_5d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_f_d_6d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1225,7 +1225,7 @@ int8_t stdlib_ndarray_mskfilter_f_d_6d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_f_d_6d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1326,7 +1326,7 @@ int8_t stdlib_ndarray_mskfilter_f_d_6d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_f_d_7d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1427,7 +1427,7 @@ int8_t stdlib_ndarray_mskfilter_f_d_7d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_f_d_7d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1528,7 +1528,7 @@ int8_t stdlib_ndarray_mskfilter_f_d_7d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_f_d_8d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1629,7 +1629,7 @@ int8_t stdlib_ndarray_mskfilter_f_d_8d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_f_d_8d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1730,7 +1730,7 @@ int8_t stdlib_ndarray_mskfilter_f_d_8d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_f_d_9d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1831,7 +1831,7 @@ int8_t stdlib_ndarray_mskfilter_f_d_9d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_f_d_9d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1932,7 +1932,7 @@ int8_t stdlib_ndarray_mskfilter_f_d_9d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_f_d_10d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2033,7 +2033,7 @@ int8_t stdlib_ndarray_mskfilter_f_d_10d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_f_d_10d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2134,7 +2134,7 @@ int8_t stdlib_ndarray_mskfilter_f_d_10d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_f_d_nd( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2279,7 +2279,7 @@ static const struct ndarrayUnarymskfilterDispatchObject obj = { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_f_d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); diff --git a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/f_f.c b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/f_f.c index 29c7e60bd66..5b67a1563b0 100644 --- a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/f_f.c +++ b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/f_f.c @@ -110,7 +110,7 @@ * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_f_f_0d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -214,7 +214,7 @@ int8_t stdlib_ndarray_mskfilter_f_f_0d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_f_f_1d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -315,7 +315,7 @@ int8_t stdlib_ndarray_mskfilter_f_f_1d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_f_f_2d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -417,7 +417,7 @@ int8_t stdlib_ndarray_mskfilter_f_f_2d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_f_f_2d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -518,7 +518,7 @@ int8_t stdlib_ndarray_mskfilter_f_f_2d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_f_f_3d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -619,7 +619,7 @@ int8_t stdlib_ndarray_mskfilter_f_f_3d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_f_f_3d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -720,7 +720,7 @@ int8_t stdlib_ndarray_mskfilter_f_f_3d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_f_f_4d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -821,7 +821,7 @@ int8_t stdlib_ndarray_mskfilter_f_f_4d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_f_f_4d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -922,7 +922,7 @@ int8_t stdlib_ndarray_mskfilter_f_f_4d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_f_f_5d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1023,7 +1023,7 @@ int8_t stdlib_ndarray_mskfilter_f_f_5d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_f_f_5d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1124,7 +1124,7 @@ int8_t stdlib_ndarray_mskfilter_f_f_5d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_f_f_6d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1225,7 +1225,7 @@ int8_t stdlib_ndarray_mskfilter_f_f_6d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_f_f_6d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1326,7 +1326,7 @@ int8_t stdlib_ndarray_mskfilter_f_f_6d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_f_f_7d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1427,7 +1427,7 @@ int8_t stdlib_ndarray_mskfilter_f_f_7d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_f_f_7d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1528,7 +1528,7 @@ int8_t stdlib_ndarray_mskfilter_f_f_7d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_f_f_8d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1629,7 +1629,7 @@ int8_t stdlib_ndarray_mskfilter_f_f_8d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_f_f_8d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1730,7 +1730,7 @@ int8_t stdlib_ndarray_mskfilter_f_f_8d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_f_f_9d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1831,7 +1831,7 @@ int8_t stdlib_ndarray_mskfilter_f_f_9d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_f_f_9d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1932,7 +1932,7 @@ int8_t stdlib_ndarray_mskfilter_f_f_9d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_f_f_10d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2033,7 +2033,7 @@ int8_t stdlib_ndarray_mskfilter_f_f_10d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_f_f_10d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2134,7 +2134,7 @@ int8_t stdlib_ndarray_mskfilter_f_f_10d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_f_f_nd( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2279,7 +2279,7 @@ static const struct ndarrayUnarymskfilterDispatchObject obj = { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_f_f( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); diff --git a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/f_z.c b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/f_z.c index 70dc0deaefa..28bf9a928a1 100644 --- a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/f_z.c +++ b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/f_z.c @@ -111,7 +111,7 @@ * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_f_z_0d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -215,7 +215,7 @@ int8_t stdlib_ndarray_mskfilter_f_z_0d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_f_z_1d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -316,7 +316,7 @@ int8_t stdlib_ndarray_mskfilter_f_z_1d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_f_z_2d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -418,7 +418,7 @@ int8_t stdlib_ndarray_mskfilter_f_z_2d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_f_z_2d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -519,7 +519,7 @@ int8_t stdlib_ndarray_mskfilter_f_z_2d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_f_z_3d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -620,7 +620,7 @@ int8_t stdlib_ndarray_mskfilter_f_z_3d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_f_z_3d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -721,7 +721,7 @@ int8_t stdlib_ndarray_mskfilter_f_z_3d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_f_z_4d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -822,7 +822,7 @@ int8_t stdlib_ndarray_mskfilter_f_z_4d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_f_z_4d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -923,7 +923,7 @@ int8_t stdlib_ndarray_mskfilter_f_z_4d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_f_z_5d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1024,7 +1024,7 @@ int8_t stdlib_ndarray_mskfilter_f_z_5d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_f_z_5d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1125,7 +1125,7 @@ int8_t stdlib_ndarray_mskfilter_f_z_5d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_f_z_6d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1226,7 +1226,7 @@ int8_t stdlib_ndarray_mskfilter_f_z_6d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_f_z_6d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1327,7 +1327,7 @@ int8_t stdlib_ndarray_mskfilter_f_z_6d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_f_z_7d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1428,7 +1428,7 @@ int8_t stdlib_ndarray_mskfilter_f_z_7d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_f_z_7d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1529,7 +1529,7 @@ int8_t stdlib_ndarray_mskfilter_f_z_7d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_f_z_8d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1630,7 +1630,7 @@ int8_t stdlib_ndarray_mskfilter_f_z_8d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_f_z_8d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1731,7 +1731,7 @@ int8_t stdlib_ndarray_mskfilter_f_z_8d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_f_z_9d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1832,7 +1832,7 @@ int8_t stdlib_ndarray_mskfilter_f_z_9d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_f_z_9d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1933,7 +1933,7 @@ int8_t stdlib_ndarray_mskfilter_f_z_9d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_f_z_10d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2034,7 +2034,7 @@ int8_t stdlib_ndarray_mskfilter_f_z_10d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_f_z_10d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2135,7 +2135,7 @@ int8_t stdlib_ndarray_mskfilter_f_z_10d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_f_z_nd( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2280,7 +2280,7 @@ static const struct ndarrayUnarymskfilterDispatchObject obj = { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_f_z( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); diff --git a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/i_d.c b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/i_d.c index 01aa3e77588..4b94570f4d6 100644 --- a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/i_d.c +++ b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/i_d.c @@ -110,7 +110,7 @@ * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_i_d_0d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -214,7 +214,7 @@ int8_t stdlib_ndarray_mskfilter_i_d_0d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_i_d_1d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -315,7 +315,7 @@ int8_t stdlib_ndarray_mskfilter_i_d_1d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_i_d_2d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -417,7 +417,7 @@ int8_t stdlib_ndarray_mskfilter_i_d_2d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_i_d_2d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -518,7 +518,7 @@ int8_t stdlib_ndarray_mskfilter_i_d_2d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_i_d_3d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -619,7 +619,7 @@ int8_t stdlib_ndarray_mskfilter_i_d_3d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_i_d_3d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -720,7 +720,7 @@ int8_t stdlib_ndarray_mskfilter_i_d_3d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_i_d_4d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -821,7 +821,7 @@ int8_t stdlib_ndarray_mskfilter_i_d_4d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_i_d_4d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -922,7 +922,7 @@ int8_t stdlib_ndarray_mskfilter_i_d_4d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_i_d_5d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1023,7 +1023,7 @@ int8_t stdlib_ndarray_mskfilter_i_d_5d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_i_d_5d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1124,7 +1124,7 @@ int8_t stdlib_ndarray_mskfilter_i_d_5d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_i_d_6d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1225,7 +1225,7 @@ int8_t stdlib_ndarray_mskfilter_i_d_6d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_i_d_6d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1326,7 +1326,7 @@ int8_t stdlib_ndarray_mskfilter_i_d_6d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_i_d_7d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1427,7 +1427,7 @@ int8_t stdlib_ndarray_mskfilter_i_d_7d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_i_d_7d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1528,7 +1528,7 @@ int8_t stdlib_ndarray_mskfilter_i_d_7d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_i_d_8d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1629,7 +1629,7 @@ int8_t stdlib_ndarray_mskfilter_i_d_8d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_i_d_8d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1730,7 +1730,7 @@ int8_t stdlib_ndarray_mskfilter_i_d_8d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_i_d_9d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1831,7 +1831,7 @@ int8_t stdlib_ndarray_mskfilter_i_d_9d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_i_d_9d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1932,7 +1932,7 @@ int8_t stdlib_ndarray_mskfilter_i_d_9d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_i_d_10d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2033,7 +2033,7 @@ int8_t stdlib_ndarray_mskfilter_i_d_10d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_i_d_10d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2134,7 +2134,7 @@ int8_t stdlib_ndarray_mskfilter_i_d_10d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_i_d_nd( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2279,7 +2279,7 @@ static const struct ndarrayUnarymskfilterDispatchObject obj = { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_i_d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); diff --git a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/i_i.c b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/i_i.c index 83571748bae..a8b9c96447b 100644 --- a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/i_i.c +++ b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/i_i.c @@ -110,7 +110,7 @@ * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_i_i_0d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -214,7 +214,7 @@ int8_t stdlib_ndarray_mskfilter_i_i_0d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_i_i_1d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -315,7 +315,7 @@ int8_t stdlib_ndarray_mskfilter_i_i_1d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_i_i_2d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -417,7 +417,7 @@ int8_t stdlib_ndarray_mskfilter_i_i_2d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_i_i_2d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -518,7 +518,7 @@ int8_t stdlib_ndarray_mskfilter_i_i_2d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_i_i_3d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -619,7 +619,7 @@ int8_t stdlib_ndarray_mskfilter_i_i_3d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_i_i_3d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -720,7 +720,7 @@ int8_t stdlib_ndarray_mskfilter_i_i_3d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_i_i_4d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -821,7 +821,7 @@ int8_t stdlib_ndarray_mskfilter_i_i_4d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_i_i_4d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -922,7 +922,7 @@ int8_t stdlib_ndarray_mskfilter_i_i_4d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_i_i_5d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1023,7 +1023,7 @@ int8_t stdlib_ndarray_mskfilter_i_i_5d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_i_i_5d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1124,7 +1124,7 @@ int8_t stdlib_ndarray_mskfilter_i_i_5d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_i_i_6d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1225,7 +1225,7 @@ int8_t stdlib_ndarray_mskfilter_i_i_6d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_i_i_6d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1326,7 +1326,7 @@ int8_t stdlib_ndarray_mskfilter_i_i_6d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_i_i_7d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1427,7 +1427,7 @@ int8_t stdlib_ndarray_mskfilter_i_i_7d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_i_i_7d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1528,7 +1528,7 @@ int8_t stdlib_ndarray_mskfilter_i_i_7d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_i_i_8d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1629,7 +1629,7 @@ int8_t stdlib_ndarray_mskfilter_i_i_8d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_i_i_8d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1730,7 +1730,7 @@ int8_t stdlib_ndarray_mskfilter_i_i_8d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_i_i_9d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1831,7 +1831,7 @@ int8_t stdlib_ndarray_mskfilter_i_i_9d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_i_i_9d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1932,7 +1932,7 @@ int8_t stdlib_ndarray_mskfilter_i_i_9d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_i_i_10d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2033,7 +2033,7 @@ int8_t stdlib_ndarray_mskfilter_i_i_10d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_i_i_10d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2134,7 +2134,7 @@ int8_t stdlib_ndarray_mskfilter_i_i_10d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_i_i_nd( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2279,7 +2279,7 @@ static const struct ndarrayUnarymskfilterDispatchObject obj = { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_i_i( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); diff --git a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/i_u.c b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/i_u.c index 95327608752..cd787280542 100644 --- a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/i_u.c +++ b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/i_u.c @@ -110,7 +110,7 @@ * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_i_u_0d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -214,7 +214,7 @@ int8_t stdlib_ndarray_mskfilter_i_u_0d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_i_u_1d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -315,7 +315,7 @@ int8_t stdlib_ndarray_mskfilter_i_u_1d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_i_u_2d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -417,7 +417,7 @@ int8_t stdlib_ndarray_mskfilter_i_u_2d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_i_u_2d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -518,7 +518,7 @@ int8_t stdlib_ndarray_mskfilter_i_u_2d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_i_u_3d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -619,7 +619,7 @@ int8_t stdlib_ndarray_mskfilter_i_u_3d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_i_u_3d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -720,7 +720,7 @@ int8_t stdlib_ndarray_mskfilter_i_u_3d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_i_u_4d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -821,7 +821,7 @@ int8_t stdlib_ndarray_mskfilter_i_u_4d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_i_u_4d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -922,7 +922,7 @@ int8_t stdlib_ndarray_mskfilter_i_u_4d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_i_u_5d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1023,7 +1023,7 @@ int8_t stdlib_ndarray_mskfilter_i_u_5d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_i_u_5d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1124,7 +1124,7 @@ int8_t stdlib_ndarray_mskfilter_i_u_5d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_i_u_6d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1225,7 +1225,7 @@ int8_t stdlib_ndarray_mskfilter_i_u_6d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_i_u_6d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1326,7 +1326,7 @@ int8_t stdlib_ndarray_mskfilter_i_u_6d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_i_u_7d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1427,7 +1427,7 @@ int8_t stdlib_ndarray_mskfilter_i_u_7d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_i_u_7d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1528,7 +1528,7 @@ int8_t stdlib_ndarray_mskfilter_i_u_7d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_i_u_8d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1629,7 +1629,7 @@ int8_t stdlib_ndarray_mskfilter_i_u_8d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_i_u_8d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1730,7 +1730,7 @@ int8_t stdlib_ndarray_mskfilter_i_u_8d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_i_u_9d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1831,7 +1831,7 @@ int8_t stdlib_ndarray_mskfilter_i_u_9d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_i_u_9d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1932,7 +1932,7 @@ int8_t stdlib_ndarray_mskfilter_i_u_9d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_i_u_10d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2033,7 +2033,7 @@ int8_t stdlib_ndarray_mskfilter_i_u_10d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_i_u_10d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2134,7 +2134,7 @@ int8_t stdlib_ndarray_mskfilter_i_u_10d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_i_u_nd( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2279,7 +2279,7 @@ static const struct ndarrayUnarymskfilterDispatchObject obj = { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_i_u( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); diff --git a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/i_z.c b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/i_z.c index 002597d8a44..3c2dff1c262 100644 --- a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/i_z.c +++ b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/i_z.c @@ -111,7 +111,7 @@ * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_i_z_0d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -215,7 +215,7 @@ int8_t stdlib_ndarray_mskfilter_i_z_0d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_i_z_1d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -316,7 +316,7 @@ int8_t stdlib_ndarray_mskfilter_i_z_1d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_i_z_2d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -418,7 +418,7 @@ int8_t stdlib_ndarray_mskfilter_i_z_2d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_i_z_2d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -519,7 +519,7 @@ int8_t stdlib_ndarray_mskfilter_i_z_2d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_i_z_3d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -620,7 +620,7 @@ int8_t stdlib_ndarray_mskfilter_i_z_3d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_i_z_3d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -721,7 +721,7 @@ int8_t stdlib_ndarray_mskfilter_i_z_3d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_i_z_4d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -822,7 +822,7 @@ int8_t stdlib_ndarray_mskfilter_i_z_4d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_i_z_4d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -923,7 +923,7 @@ int8_t stdlib_ndarray_mskfilter_i_z_4d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_i_z_5d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1024,7 +1024,7 @@ int8_t stdlib_ndarray_mskfilter_i_z_5d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_i_z_5d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1125,7 +1125,7 @@ int8_t stdlib_ndarray_mskfilter_i_z_5d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_i_z_6d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1226,7 +1226,7 @@ int8_t stdlib_ndarray_mskfilter_i_z_6d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_i_z_6d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1327,7 +1327,7 @@ int8_t stdlib_ndarray_mskfilter_i_z_6d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_i_z_7d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1428,7 +1428,7 @@ int8_t stdlib_ndarray_mskfilter_i_z_7d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_i_z_7d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1529,7 +1529,7 @@ int8_t stdlib_ndarray_mskfilter_i_z_7d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_i_z_8d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1630,7 +1630,7 @@ int8_t stdlib_ndarray_mskfilter_i_z_8d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_i_z_8d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1731,7 +1731,7 @@ int8_t stdlib_ndarray_mskfilter_i_z_8d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_i_z_9d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1832,7 +1832,7 @@ int8_t stdlib_ndarray_mskfilter_i_z_9d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_i_z_9d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1933,7 +1933,7 @@ int8_t stdlib_ndarray_mskfilter_i_z_9d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_i_z_10d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2034,7 +2034,7 @@ int8_t stdlib_ndarray_mskfilter_i_z_10d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_i_z_10d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2135,7 +2135,7 @@ int8_t stdlib_ndarray_mskfilter_i_z_10d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_i_z_nd( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2280,7 +2280,7 @@ static const struct ndarrayUnarymskfilterDispatchObject obj = { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_i_z( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); diff --git a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/internal/permute.c b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/internal/permute.c new file mode 100644 index 00000000000..4f2d5237bd6 --- /dev/null +++ b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/internal/permute.c @@ -0,0 +1,35 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2024 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +#include "stdlib/ndarray/base/mskfilter/internal/permute.h" +#include + +/** +* Permutes an input array according to a provided index array. +* +* @param n number of elements to permute +* @param arr input array +* @param idx permutation indices +* @param out output array +*/ +void stdlib_ndarray_base_mskfilter_internal_permute( const int64_t n, const int64_t *arr, const int64_t *idx, int64_t *out ) { + int64_t i; + for ( i = 0; i < n; i++ ) { + out[ i ] = arr[ idx[i] ]; + } +} diff --git a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/internal/range.c b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/internal/range.c new file mode 100644 index 00000000000..f1c06b05589 --- /dev/null +++ b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/internal/range.c @@ -0,0 +1,33 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2024 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +#include "stdlib/ndarray/base/mskfilter/internal/range.h" +#include + +/** +* Writes `n` evenly spaced values from `0` to `n-1` to an output array. +* +* @param n number of values to write +* @param out output array +*/ +void stdlib_ndarray_base_mskfilter_internal_range( const int64_t n, int64_t *out ) { + int64_t i; + for ( i = 0; i < n; i++ ) { + out[ i ] = i; + } +} diff --git a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/internal/sort2ins.c b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/internal/sort2ins.c new file mode 100644 index 00000000000..83df23cf95c --- /dev/null +++ b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/internal/sort2ins.c @@ -0,0 +1,79 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2024 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +#include "stdlib/ndarray/base/mskfilter/internal/sort2ins.h" +#include + +/** +* Simultaneously sorts two arrays based on the sort order of the first array using insertion sort. +* +* ## Notes +* +* - The first array is sorted in increasing order according to absolute value. +* - The algorithm has space complexity `O(1)` and worst case time complexity `O(N^2)`. +* - The algorithm is efficient for small arrays (typically `N <= 20``) and is particularly efficient for sorting arrays which are already substantially sorted. +* - The algorithm is **stable**, meaning that the algorithm does **not** change the order of array elements which are equal or equivalent. +* - The input arrays are sorted in-place (i.e., the input arrays are mutated). +* +* @param n number of elements +* @param x first array +* @param y second array +*/ +void stdlib_ndarray_base_mskfilter_internal_sort2ins( const int64_t n, int64_t *x, int64_t *y ) { + int64_t avx; + int64_t aux; + int64_t ix; + int64_t iy; + int64_t jx; + int64_t jy; + int64_t vx; + int64_t vy; + int64_t ux; + int64_t i; + + ix = 1; + iy = 1; + + // Sort in increasing order... + for ( i = 1; i < n; i++ ) { + vx = x[ ix ]; + avx = ( vx < 0 ) ? -vx : vx; + + vy = y[ iy ]; + + jx = ix - 1; + jy = iy - 1; + + // Shift all larger values to the left of the current element to the right... + while ( jx >= 0 ) { + ux = x[ jx ]; + aux = ( ux < 0 ) ? -ux : ux; + if ( aux <= avx ) { + break; + } + x[ jx+1 ] = ux; + y[ jy+1 ] = y[ jy ]; + jx -= 1; + jy -= 1; + } + x[ jx+1 ] = vx; + y[ jy+1 ] = vy; + ix += 1; + iy += 1; + } +} diff --git a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/k_c.c b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/k_c.c index ce288ecee14..07193a6629e 100644 --- a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/k_c.c +++ b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/k_c.c @@ -111,7 +111,7 @@ * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_c_0d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -215,7 +215,7 @@ int8_t stdlib_ndarray_mskfilter_k_c_0d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_c_1d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -316,7 +316,7 @@ int8_t stdlib_ndarray_mskfilter_k_c_1d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_c_2d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -418,7 +418,7 @@ int8_t stdlib_ndarray_mskfilter_k_c_2d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_c_2d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -519,7 +519,7 @@ int8_t stdlib_ndarray_mskfilter_k_c_2d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_c_3d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -620,7 +620,7 @@ int8_t stdlib_ndarray_mskfilter_k_c_3d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_c_3d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -721,7 +721,7 @@ int8_t stdlib_ndarray_mskfilter_k_c_3d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_c_4d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -822,7 +822,7 @@ int8_t stdlib_ndarray_mskfilter_k_c_4d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_c_4d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -923,7 +923,7 @@ int8_t stdlib_ndarray_mskfilter_k_c_4d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_c_5d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1024,7 +1024,7 @@ int8_t stdlib_ndarray_mskfilter_k_c_5d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_c_5d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1125,7 +1125,7 @@ int8_t stdlib_ndarray_mskfilter_k_c_5d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_c_6d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1226,7 +1226,7 @@ int8_t stdlib_ndarray_mskfilter_k_c_6d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_c_6d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1327,7 +1327,7 @@ int8_t stdlib_ndarray_mskfilter_k_c_6d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_c_7d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1428,7 +1428,7 @@ int8_t stdlib_ndarray_mskfilter_k_c_7d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_c_7d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1529,7 +1529,7 @@ int8_t stdlib_ndarray_mskfilter_k_c_7d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_c_8d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1630,7 +1630,7 @@ int8_t stdlib_ndarray_mskfilter_k_c_8d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_c_8d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1731,7 +1731,7 @@ int8_t stdlib_ndarray_mskfilter_k_c_8d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_c_9d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1832,7 +1832,7 @@ int8_t stdlib_ndarray_mskfilter_k_c_9d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_c_9d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1933,7 +1933,7 @@ int8_t stdlib_ndarray_mskfilter_k_c_9d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_c_10d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2034,7 +2034,7 @@ int8_t stdlib_ndarray_mskfilter_k_c_10d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_c_10d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2135,7 +2135,7 @@ int8_t stdlib_ndarray_mskfilter_k_c_10d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_c_nd( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2280,7 +2280,7 @@ static const struct ndarrayUnarymskfilterDispatchObject obj = { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_c( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); diff --git a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/k_d.c b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/k_d.c index 1ce9c2c564a..f4c60fd50f3 100644 --- a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/k_d.c +++ b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/k_d.c @@ -110,7 +110,7 @@ * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_d_0d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -214,7 +214,7 @@ int8_t stdlib_ndarray_mskfilter_k_d_0d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_d_1d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -315,7 +315,7 @@ int8_t stdlib_ndarray_mskfilter_k_d_1d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_d_2d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -417,7 +417,7 @@ int8_t stdlib_ndarray_mskfilter_k_d_2d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_d_2d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -518,7 +518,7 @@ int8_t stdlib_ndarray_mskfilter_k_d_2d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_d_3d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -619,7 +619,7 @@ int8_t stdlib_ndarray_mskfilter_k_d_3d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_d_3d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -720,7 +720,7 @@ int8_t stdlib_ndarray_mskfilter_k_d_3d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_d_4d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -821,7 +821,7 @@ int8_t stdlib_ndarray_mskfilter_k_d_4d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_d_4d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -922,7 +922,7 @@ int8_t stdlib_ndarray_mskfilter_k_d_4d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_d_5d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1023,7 +1023,7 @@ int8_t stdlib_ndarray_mskfilter_k_d_5d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_d_5d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1124,7 +1124,7 @@ int8_t stdlib_ndarray_mskfilter_k_d_5d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_d_6d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1225,7 +1225,7 @@ int8_t stdlib_ndarray_mskfilter_k_d_6d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_d_6d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1326,7 +1326,7 @@ int8_t stdlib_ndarray_mskfilter_k_d_6d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_d_7d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1427,7 +1427,7 @@ int8_t stdlib_ndarray_mskfilter_k_d_7d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_d_7d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1528,7 +1528,7 @@ int8_t stdlib_ndarray_mskfilter_k_d_7d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_d_8d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1629,7 +1629,7 @@ int8_t stdlib_ndarray_mskfilter_k_d_8d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_d_8d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1730,7 +1730,7 @@ int8_t stdlib_ndarray_mskfilter_k_d_8d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_d_9d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1831,7 +1831,7 @@ int8_t stdlib_ndarray_mskfilter_k_d_9d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_d_9d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1932,7 +1932,7 @@ int8_t stdlib_ndarray_mskfilter_k_d_9d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_d_10d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2033,7 +2033,7 @@ int8_t stdlib_ndarray_mskfilter_k_d_10d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_d_10d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2134,7 +2134,7 @@ int8_t stdlib_ndarray_mskfilter_k_d_10d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_d_nd( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2279,7 +2279,7 @@ static const struct ndarrayUnarymskfilterDispatchObject obj = { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); diff --git a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/k_f.c b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/k_f.c index 1911b3c6f22..8f9baad9ce9 100644 --- a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/k_f.c +++ b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/k_f.c @@ -110,7 +110,7 @@ * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_f_0d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -214,7 +214,7 @@ int8_t stdlib_ndarray_mskfilter_k_f_0d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_f_1d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -315,7 +315,7 @@ int8_t stdlib_ndarray_mskfilter_k_f_1d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_f_2d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -417,7 +417,7 @@ int8_t stdlib_ndarray_mskfilter_k_f_2d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_f_2d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -518,7 +518,7 @@ int8_t stdlib_ndarray_mskfilter_k_f_2d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_f_3d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -619,7 +619,7 @@ int8_t stdlib_ndarray_mskfilter_k_f_3d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_f_3d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -720,7 +720,7 @@ int8_t stdlib_ndarray_mskfilter_k_f_3d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_f_4d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -821,7 +821,7 @@ int8_t stdlib_ndarray_mskfilter_k_f_4d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_f_4d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -922,7 +922,7 @@ int8_t stdlib_ndarray_mskfilter_k_f_4d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_f_5d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1023,7 +1023,7 @@ int8_t stdlib_ndarray_mskfilter_k_f_5d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_f_5d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1124,7 +1124,7 @@ int8_t stdlib_ndarray_mskfilter_k_f_5d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_f_6d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1225,7 +1225,7 @@ int8_t stdlib_ndarray_mskfilter_k_f_6d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_f_6d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1326,7 +1326,7 @@ int8_t stdlib_ndarray_mskfilter_k_f_6d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_f_7d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1427,7 +1427,7 @@ int8_t stdlib_ndarray_mskfilter_k_f_7d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_f_7d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1528,7 +1528,7 @@ int8_t stdlib_ndarray_mskfilter_k_f_7d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_f_8d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1629,7 +1629,7 @@ int8_t stdlib_ndarray_mskfilter_k_f_8d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_f_8d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1730,7 +1730,7 @@ int8_t stdlib_ndarray_mskfilter_k_f_8d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_f_9d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1831,7 +1831,7 @@ int8_t stdlib_ndarray_mskfilter_k_f_9d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_f_9d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1932,7 +1932,7 @@ int8_t stdlib_ndarray_mskfilter_k_f_9d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_f_10d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2033,7 +2033,7 @@ int8_t stdlib_ndarray_mskfilter_k_f_10d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_f_10d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2134,7 +2134,7 @@ int8_t stdlib_ndarray_mskfilter_k_f_10d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_f_nd( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2279,7 +2279,7 @@ static const struct ndarrayUnarymskfilterDispatchObject obj = { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_f( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); diff --git a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/k_i.c b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/k_i.c index fd693aa859e..ccaab9db4e0 100644 --- a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/k_i.c +++ b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/k_i.c @@ -110,7 +110,7 @@ * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_i_0d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -214,7 +214,7 @@ int8_t stdlib_ndarray_mskfilter_k_i_0d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_i_1d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -315,7 +315,7 @@ int8_t stdlib_ndarray_mskfilter_k_i_1d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_i_2d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -417,7 +417,7 @@ int8_t stdlib_ndarray_mskfilter_k_i_2d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_i_2d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -518,7 +518,7 @@ int8_t stdlib_ndarray_mskfilter_k_i_2d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_i_3d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -619,7 +619,7 @@ int8_t stdlib_ndarray_mskfilter_k_i_3d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_i_3d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -720,7 +720,7 @@ int8_t stdlib_ndarray_mskfilter_k_i_3d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_i_4d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -821,7 +821,7 @@ int8_t stdlib_ndarray_mskfilter_k_i_4d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_i_4d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -922,7 +922,7 @@ int8_t stdlib_ndarray_mskfilter_k_i_4d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_i_5d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1023,7 +1023,7 @@ int8_t stdlib_ndarray_mskfilter_k_i_5d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_i_5d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1124,7 +1124,7 @@ int8_t stdlib_ndarray_mskfilter_k_i_5d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_i_6d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1225,7 +1225,7 @@ int8_t stdlib_ndarray_mskfilter_k_i_6d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_i_6d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1326,7 +1326,7 @@ int8_t stdlib_ndarray_mskfilter_k_i_6d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_i_7d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1427,7 +1427,7 @@ int8_t stdlib_ndarray_mskfilter_k_i_7d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_i_7d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1528,7 +1528,7 @@ int8_t stdlib_ndarray_mskfilter_k_i_7d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_i_8d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1629,7 +1629,7 @@ int8_t stdlib_ndarray_mskfilter_k_i_8d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_i_8d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1730,7 +1730,7 @@ int8_t stdlib_ndarray_mskfilter_k_i_8d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_i_9d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1831,7 +1831,7 @@ int8_t stdlib_ndarray_mskfilter_k_i_9d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_i_9d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1932,7 +1932,7 @@ int8_t stdlib_ndarray_mskfilter_k_i_9d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_i_10d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2033,7 +2033,7 @@ int8_t stdlib_ndarray_mskfilter_k_i_10d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_i_10d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2134,7 +2134,7 @@ int8_t stdlib_ndarray_mskfilter_k_i_10d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_i_nd( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2279,7 +2279,7 @@ static const struct ndarrayUnarymskfilterDispatchObject obj = { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_i( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); diff --git a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/k_k.c b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/k_k.c index 971028cd25f..2f9e8871d27 100644 --- a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/k_k.c +++ b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/k_k.c @@ -110,7 +110,7 @@ * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_k_0d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -214,7 +214,7 @@ int8_t stdlib_ndarray_mskfilter_k_k_0d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_k_1d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -315,7 +315,7 @@ int8_t stdlib_ndarray_mskfilter_k_k_1d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_k_2d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -417,7 +417,7 @@ int8_t stdlib_ndarray_mskfilter_k_k_2d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_k_2d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -518,7 +518,7 @@ int8_t stdlib_ndarray_mskfilter_k_k_2d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_k_3d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -619,7 +619,7 @@ int8_t stdlib_ndarray_mskfilter_k_k_3d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_k_3d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -720,7 +720,7 @@ int8_t stdlib_ndarray_mskfilter_k_k_3d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_k_4d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -821,7 +821,7 @@ int8_t stdlib_ndarray_mskfilter_k_k_4d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_k_4d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -922,7 +922,7 @@ int8_t stdlib_ndarray_mskfilter_k_k_4d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_k_5d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1023,7 +1023,7 @@ int8_t stdlib_ndarray_mskfilter_k_k_5d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_k_5d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1124,7 +1124,7 @@ int8_t stdlib_ndarray_mskfilter_k_k_5d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_k_6d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1225,7 +1225,7 @@ int8_t stdlib_ndarray_mskfilter_k_k_6d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_k_6d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1326,7 +1326,7 @@ int8_t stdlib_ndarray_mskfilter_k_k_6d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_k_7d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1427,7 +1427,7 @@ int8_t stdlib_ndarray_mskfilter_k_k_7d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_k_7d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1528,7 +1528,7 @@ int8_t stdlib_ndarray_mskfilter_k_k_7d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_k_8d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1629,7 +1629,7 @@ int8_t stdlib_ndarray_mskfilter_k_k_8d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_k_8d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1730,7 +1730,7 @@ int8_t stdlib_ndarray_mskfilter_k_k_8d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_k_9d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1831,7 +1831,7 @@ int8_t stdlib_ndarray_mskfilter_k_k_9d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_k_9d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1932,7 +1932,7 @@ int8_t stdlib_ndarray_mskfilter_k_k_9d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_k_10d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2033,7 +2033,7 @@ int8_t stdlib_ndarray_mskfilter_k_k_10d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_k_10d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2134,7 +2134,7 @@ int8_t stdlib_ndarray_mskfilter_k_k_10d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_k_nd( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2279,7 +2279,7 @@ static const struct ndarrayUnarymskfilterDispatchObject obj = { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_k( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); diff --git a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/k_t.c b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/k_t.c index 900d83763dc..63f8a0d5811 100644 --- a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/k_t.c +++ b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/k_t.c @@ -110,7 +110,7 @@ * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_t_0d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -214,7 +214,7 @@ int8_t stdlib_ndarray_mskfilter_k_t_0d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_t_1d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -315,7 +315,7 @@ int8_t stdlib_ndarray_mskfilter_k_t_1d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_t_2d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -417,7 +417,7 @@ int8_t stdlib_ndarray_mskfilter_k_t_2d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_t_2d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -518,7 +518,7 @@ int8_t stdlib_ndarray_mskfilter_k_t_2d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_t_3d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -619,7 +619,7 @@ int8_t stdlib_ndarray_mskfilter_k_t_3d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_t_3d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -720,7 +720,7 @@ int8_t stdlib_ndarray_mskfilter_k_t_3d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_t_4d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -821,7 +821,7 @@ int8_t stdlib_ndarray_mskfilter_k_t_4d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_t_4d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -922,7 +922,7 @@ int8_t stdlib_ndarray_mskfilter_k_t_4d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_t_5d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1023,7 +1023,7 @@ int8_t stdlib_ndarray_mskfilter_k_t_5d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_t_5d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1124,7 +1124,7 @@ int8_t stdlib_ndarray_mskfilter_k_t_5d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_t_6d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1225,7 +1225,7 @@ int8_t stdlib_ndarray_mskfilter_k_t_6d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_t_6d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1326,7 +1326,7 @@ int8_t stdlib_ndarray_mskfilter_k_t_6d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_t_7d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1427,7 +1427,7 @@ int8_t stdlib_ndarray_mskfilter_k_t_7d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_t_7d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1528,7 +1528,7 @@ int8_t stdlib_ndarray_mskfilter_k_t_7d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_t_8d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1629,7 +1629,7 @@ int8_t stdlib_ndarray_mskfilter_k_t_8d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_t_8d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1730,7 +1730,7 @@ int8_t stdlib_ndarray_mskfilter_k_t_8d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_t_9d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1831,7 +1831,7 @@ int8_t stdlib_ndarray_mskfilter_k_t_9d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_t_9d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1932,7 +1932,7 @@ int8_t stdlib_ndarray_mskfilter_k_t_9d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_t_10d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2033,7 +2033,7 @@ int8_t stdlib_ndarray_mskfilter_k_t_10d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_t_10d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2134,7 +2134,7 @@ int8_t stdlib_ndarray_mskfilter_k_t_10d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_t_nd( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2279,7 +2279,7 @@ static const struct ndarrayUnarymskfilterDispatchObject obj = { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_t( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); diff --git a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/k_u.c b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/k_u.c index 0f59fcabd42..07624c37163 100644 --- a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/k_u.c +++ b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/k_u.c @@ -110,7 +110,7 @@ * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_u_0d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -214,7 +214,7 @@ int8_t stdlib_ndarray_mskfilter_k_u_0d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_u_1d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -315,7 +315,7 @@ int8_t stdlib_ndarray_mskfilter_k_u_1d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_u_2d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -417,7 +417,7 @@ int8_t stdlib_ndarray_mskfilter_k_u_2d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_u_2d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -518,7 +518,7 @@ int8_t stdlib_ndarray_mskfilter_k_u_2d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_u_3d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -619,7 +619,7 @@ int8_t stdlib_ndarray_mskfilter_k_u_3d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_u_3d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -720,7 +720,7 @@ int8_t stdlib_ndarray_mskfilter_k_u_3d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_u_4d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -821,7 +821,7 @@ int8_t stdlib_ndarray_mskfilter_k_u_4d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_u_4d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -922,7 +922,7 @@ int8_t stdlib_ndarray_mskfilter_k_u_4d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_u_5d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1023,7 +1023,7 @@ int8_t stdlib_ndarray_mskfilter_k_u_5d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_u_5d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1124,7 +1124,7 @@ int8_t stdlib_ndarray_mskfilter_k_u_5d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_u_6d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1225,7 +1225,7 @@ int8_t stdlib_ndarray_mskfilter_k_u_6d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_u_6d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1326,7 +1326,7 @@ int8_t stdlib_ndarray_mskfilter_k_u_6d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_u_7d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1427,7 +1427,7 @@ int8_t stdlib_ndarray_mskfilter_k_u_7d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_u_7d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1528,7 +1528,7 @@ int8_t stdlib_ndarray_mskfilter_k_u_7d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_u_8d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1629,7 +1629,7 @@ int8_t stdlib_ndarray_mskfilter_k_u_8d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_u_8d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1730,7 +1730,7 @@ int8_t stdlib_ndarray_mskfilter_k_u_8d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_u_9d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1831,7 +1831,7 @@ int8_t stdlib_ndarray_mskfilter_k_u_9d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_u_9d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1932,7 +1932,7 @@ int8_t stdlib_ndarray_mskfilter_k_u_9d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_u_10d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2033,7 +2033,7 @@ int8_t stdlib_ndarray_mskfilter_k_u_10d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_u_10d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2134,7 +2134,7 @@ int8_t stdlib_ndarray_mskfilter_k_u_10d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_u_nd( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2279,7 +2279,7 @@ static const struct ndarrayUnarymskfilterDispatchObject obj = { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_u( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); diff --git a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/k_z.c b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/k_z.c index c62b9ad270d..a4c8914c5b2 100644 --- a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/k_z.c +++ b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/k_z.c @@ -111,7 +111,7 @@ * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_z_0d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -215,7 +215,7 @@ int8_t stdlib_ndarray_mskfilter_k_z_0d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_z_1d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -316,7 +316,7 @@ int8_t stdlib_ndarray_mskfilter_k_z_1d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_z_2d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -418,7 +418,7 @@ int8_t stdlib_ndarray_mskfilter_k_z_2d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_z_2d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -519,7 +519,7 @@ int8_t stdlib_ndarray_mskfilter_k_z_2d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_z_3d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -620,7 +620,7 @@ int8_t stdlib_ndarray_mskfilter_k_z_3d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_z_3d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -721,7 +721,7 @@ int8_t stdlib_ndarray_mskfilter_k_z_3d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_z_4d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -822,7 +822,7 @@ int8_t stdlib_ndarray_mskfilter_k_z_4d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_z_4d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -923,7 +923,7 @@ int8_t stdlib_ndarray_mskfilter_k_z_4d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_z_5d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1024,7 +1024,7 @@ int8_t stdlib_ndarray_mskfilter_k_z_5d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_z_5d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1125,7 +1125,7 @@ int8_t stdlib_ndarray_mskfilter_k_z_5d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_z_6d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1226,7 +1226,7 @@ int8_t stdlib_ndarray_mskfilter_k_z_6d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_z_6d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1327,7 +1327,7 @@ int8_t stdlib_ndarray_mskfilter_k_z_6d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_z_7d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1428,7 +1428,7 @@ int8_t stdlib_ndarray_mskfilter_k_z_7d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_z_7d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1529,7 +1529,7 @@ int8_t stdlib_ndarray_mskfilter_k_z_7d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_z_8d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1630,7 +1630,7 @@ int8_t stdlib_ndarray_mskfilter_k_z_8d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_z_8d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1731,7 +1731,7 @@ int8_t stdlib_ndarray_mskfilter_k_z_8d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_z_9d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1832,7 +1832,7 @@ int8_t stdlib_ndarray_mskfilter_k_z_9d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_z_9d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1933,7 +1933,7 @@ int8_t stdlib_ndarray_mskfilter_k_z_9d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_z_10d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2034,7 +2034,7 @@ int8_t stdlib_ndarray_mskfilter_k_z_10d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_z_10d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2135,7 +2135,7 @@ int8_t stdlib_ndarray_mskfilter_k_z_10d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_z_nd( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2280,7 +2280,7 @@ static const struct ndarrayUnarymskfilterDispatchObject obj = { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_k_z( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); diff --git a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/s_b.c b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/s_b.c index e301f12cb80..23612643b50 100644 --- a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/s_b.c +++ b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/s_b.c @@ -110,7 +110,7 @@ * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_b_0d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -214,7 +214,7 @@ int8_t stdlib_ndarray_mskfilter_s_b_0d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_b_1d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -315,7 +315,7 @@ int8_t stdlib_ndarray_mskfilter_s_b_1d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_b_2d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -417,7 +417,7 @@ int8_t stdlib_ndarray_mskfilter_s_b_2d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_b_2d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -518,7 +518,7 @@ int8_t stdlib_ndarray_mskfilter_s_b_2d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_b_3d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -619,7 +619,7 @@ int8_t stdlib_ndarray_mskfilter_s_b_3d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_b_3d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -720,7 +720,7 @@ int8_t stdlib_ndarray_mskfilter_s_b_3d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_b_4d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -821,7 +821,7 @@ int8_t stdlib_ndarray_mskfilter_s_b_4d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_b_4d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -922,7 +922,7 @@ int8_t stdlib_ndarray_mskfilter_s_b_4d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_b_5d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1023,7 +1023,7 @@ int8_t stdlib_ndarray_mskfilter_s_b_5d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_b_5d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1124,7 +1124,7 @@ int8_t stdlib_ndarray_mskfilter_s_b_5d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_b_6d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1225,7 +1225,7 @@ int8_t stdlib_ndarray_mskfilter_s_b_6d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_b_6d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1326,7 +1326,7 @@ int8_t stdlib_ndarray_mskfilter_s_b_6d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_b_7d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1427,7 +1427,7 @@ int8_t stdlib_ndarray_mskfilter_s_b_7d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_b_7d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1528,7 +1528,7 @@ int8_t stdlib_ndarray_mskfilter_s_b_7d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_b_8d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1629,7 +1629,7 @@ int8_t stdlib_ndarray_mskfilter_s_b_8d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_b_8d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1730,7 +1730,7 @@ int8_t stdlib_ndarray_mskfilter_s_b_8d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_b_9d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1831,7 +1831,7 @@ int8_t stdlib_ndarray_mskfilter_s_b_9d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_b_9d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1932,7 +1932,7 @@ int8_t stdlib_ndarray_mskfilter_s_b_9d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_b_10d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2033,7 +2033,7 @@ int8_t stdlib_ndarray_mskfilter_s_b_10d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_b_10d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2134,7 +2134,7 @@ int8_t stdlib_ndarray_mskfilter_s_b_10d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_b_nd( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2279,7 +2279,7 @@ static const struct ndarrayUnarymskfilterDispatchObject obj = { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_b( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); diff --git a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/s_c.c b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/s_c.c index 4009bca69e1..ab67fc6c8b3 100644 --- a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/s_c.c +++ b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/s_c.c @@ -111,7 +111,7 @@ * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_c_0d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -215,7 +215,7 @@ int8_t stdlib_ndarray_mskfilter_s_c_0d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_c_1d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -316,7 +316,7 @@ int8_t stdlib_ndarray_mskfilter_s_c_1d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_c_2d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -418,7 +418,7 @@ int8_t stdlib_ndarray_mskfilter_s_c_2d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_c_2d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -519,7 +519,7 @@ int8_t stdlib_ndarray_mskfilter_s_c_2d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_c_3d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -620,7 +620,7 @@ int8_t stdlib_ndarray_mskfilter_s_c_3d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_c_3d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -721,7 +721,7 @@ int8_t stdlib_ndarray_mskfilter_s_c_3d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_c_4d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -822,7 +822,7 @@ int8_t stdlib_ndarray_mskfilter_s_c_4d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_c_4d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -923,7 +923,7 @@ int8_t stdlib_ndarray_mskfilter_s_c_4d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_c_5d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1024,7 +1024,7 @@ int8_t stdlib_ndarray_mskfilter_s_c_5d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_c_5d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1125,7 +1125,7 @@ int8_t stdlib_ndarray_mskfilter_s_c_5d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_c_6d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1226,7 +1226,7 @@ int8_t stdlib_ndarray_mskfilter_s_c_6d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_c_6d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1327,7 +1327,7 @@ int8_t stdlib_ndarray_mskfilter_s_c_6d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_c_7d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1428,7 +1428,7 @@ int8_t stdlib_ndarray_mskfilter_s_c_7d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_c_7d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1529,7 +1529,7 @@ int8_t stdlib_ndarray_mskfilter_s_c_7d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_c_8d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1630,7 +1630,7 @@ int8_t stdlib_ndarray_mskfilter_s_c_8d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_c_8d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1731,7 +1731,7 @@ int8_t stdlib_ndarray_mskfilter_s_c_8d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_c_9d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1832,7 +1832,7 @@ int8_t stdlib_ndarray_mskfilter_s_c_9d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_c_9d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1933,7 +1933,7 @@ int8_t stdlib_ndarray_mskfilter_s_c_9d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_c_10d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2034,7 +2034,7 @@ int8_t stdlib_ndarray_mskfilter_s_c_10d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_c_10d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2135,7 +2135,7 @@ int8_t stdlib_ndarray_mskfilter_s_c_10d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_c_nd( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2280,7 +2280,7 @@ static const struct ndarrayUnarymskfilterDispatchObject obj = { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_c( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); diff --git a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/s_d.c b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/s_d.c index 31d4106725d..9cbcea57cdb 100644 --- a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/s_d.c +++ b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/s_d.c @@ -110,7 +110,7 @@ * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_d_0d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -214,7 +214,7 @@ int8_t stdlib_ndarray_mskfilter_s_d_0d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_d_1d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -315,7 +315,7 @@ int8_t stdlib_ndarray_mskfilter_s_d_1d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_d_2d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -417,7 +417,7 @@ int8_t stdlib_ndarray_mskfilter_s_d_2d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_d_2d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -518,7 +518,7 @@ int8_t stdlib_ndarray_mskfilter_s_d_2d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_d_3d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -619,7 +619,7 @@ int8_t stdlib_ndarray_mskfilter_s_d_3d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_d_3d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -720,7 +720,7 @@ int8_t stdlib_ndarray_mskfilter_s_d_3d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_d_4d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -821,7 +821,7 @@ int8_t stdlib_ndarray_mskfilter_s_d_4d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_d_4d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -922,7 +922,7 @@ int8_t stdlib_ndarray_mskfilter_s_d_4d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_d_5d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1023,7 +1023,7 @@ int8_t stdlib_ndarray_mskfilter_s_d_5d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_d_5d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1124,7 +1124,7 @@ int8_t stdlib_ndarray_mskfilter_s_d_5d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_d_6d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1225,7 +1225,7 @@ int8_t stdlib_ndarray_mskfilter_s_d_6d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_d_6d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1326,7 +1326,7 @@ int8_t stdlib_ndarray_mskfilter_s_d_6d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_d_7d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1427,7 +1427,7 @@ int8_t stdlib_ndarray_mskfilter_s_d_7d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_d_7d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1528,7 +1528,7 @@ int8_t stdlib_ndarray_mskfilter_s_d_7d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_d_8d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1629,7 +1629,7 @@ int8_t stdlib_ndarray_mskfilter_s_d_8d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_d_8d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1730,7 +1730,7 @@ int8_t stdlib_ndarray_mskfilter_s_d_8d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_d_9d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1831,7 +1831,7 @@ int8_t stdlib_ndarray_mskfilter_s_d_9d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_d_9d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1932,7 +1932,7 @@ int8_t stdlib_ndarray_mskfilter_s_d_9d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_d_10d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2033,7 +2033,7 @@ int8_t stdlib_ndarray_mskfilter_s_d_10d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_d_10d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2134,7 +2134,7 @@ int8_t stdlib_ndarray_mskfilter_s_d_10d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_d_nd( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2279,7 +2279,7 @@ static const struct ndarrayUnarymskfilterDispatchObject obj = { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); diff --git a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/s_f.c b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/s_f.c index 997fa0d672a..d7323145855 100644 --- a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/s_f.c +++ b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/s_f.c @@ -110,7 +110,7 @@ * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_f_0d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -214,7 +214,7 @@ int8_t stdlib_ndarray_mskfilter_s_f_0d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_f_1d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -315,7 +315,7 @@ int8_t stdlib_ndarray_mskfilter_s_f_1d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_f_2d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -417,7 +417,7 @@ int8_t stdlib_ndarray_mskfilter_s_f_2d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_f_2d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -518,7 +518,7 @@ int8_t stdlib_ndarray_mskfilter_s_f_2d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_f_3d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -619,7 +619,7 @@ int8_t stdlib_ndarray_mskfilter_s_f_3d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_f_3d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -720,7 +720,7 @@ int8_t stdlib_ndarray_mskfilter_s_f_3d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_f_4d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -821,7 +821,7 @@ int8_t stdlib_ndarray_mskfilter_s_f_4d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_f_4d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -922,7 +922,7 @@ int8_t stdlib_ndarray_mskfilter_s_f_4d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_f_5d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1023,7 +1023,7 @@ int8_t stdlib_ndarray_mskfilter_s_f_5d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_f_5d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1124,7 +1124,7 @@ int8_t stdlib_ndarray_mskfilter_s_f_5d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_f_6d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1225,7 +1225,7 @@ int8_t stdlib_ndarray_mskfilter_s_f_6d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_f_6d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1326,7 +1326,7 @@ int8_t stdlib_ndarray_mskfilter_s_f_6d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_f_7d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1427,7 +1427,7 @@ int8_t stdlib_ndarray_mskfilter_s_f_7d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_f_7d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1528,7 +1528,7 @@ int8_t stdlib_ndarray_mskfilter_s_f_7d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_f_8d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1629,7 +1629,7 @@ int8_t stdlib_ndarray_mskfilter_s_f_8d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_f_8d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1730,7 +1730,7 @@ int8_t stdlib_ndarray_mskfilter_s_f_8d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_f_9d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1831,7 +1831,7 @@ int8_t stdlib_ndarray_mskfilter_s_f_9d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_f_9d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1932,7 +1932,7 @@ int8_t stdlib_ndarray_mskfilter_s_f_9d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_f_10d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2033,7 +2033,7 @@ int8_t stdlib_ndarray_mskfilter_s_f_10d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_f_10d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2134,7 +2134,7 @@ int8_t stdlib_ndarray_mskfilter_s_f_10d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_f_nd( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2279,7 +2279,7 @@ static const struct ndarrayUnarymskfilterDispatchObject obj = { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_f( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); diff --git a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/s_i.c b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/s_i.c index 5db9957d547..eff71ea56e1 100644 --- a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/s_i.c +++ b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/s_i.c @@ -110,7 +110,7 @@ * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_i_0d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -214,7 +214,7 @@ int8_t stdlib_ndarray_mskfilter_s_i_0d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_i_1d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -315,7 +315,7 @@ int8_t stdlib_ndarray_mskfilter_s_i_1d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_i_2d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -417,7 +417,7 @@ int8_t stdlib_ndarray_mskfilter_s_i_2d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_i_2d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -518,7 +518,7 @@ int8_t stdlib_ndarray_mskfilter_s_i_2d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_i_3d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -619,7 +619,7 @@ int8_t stdlib_ndarray_mskfilter_s_i_3d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_i_3d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -720,7 +720,7 @@ int8_t stdlib_ndarray_mskfilter_s_i_3d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_i_4d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -821,7 +821,7 @@ int8_t stdlib_ndarray_mskfilter_s_i_4d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_i_4d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -922,7 +922,7 @@ int8_t stdlib_ndarray_mskfilter_s_i_4d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_i_5d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1023,7 +1023,7 @@ int8_t stdlib_ndarray_mskfilter_s_i_5d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_i_5d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1124,7 +1124,7 @@ int8_t stdlib_ndarray_mskfilter_s_i_5d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_i_6d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1225,7 +1225,7 @@ int8_t stdlib_ndarray_mskfilter_s_i_6d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_i_6d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1326,7 +1326,7 @@ int8_t stdlib_ndarray_mskfilter_s_i_6d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_i_7d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1427,7 +1427,7 @@ int8_t stdlib_ndarray_mskfilter_s_i_7d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_i_7d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1528,7 +1528,7 @@ int8_t stdlib_ndarray_mskfilter_s_i_7d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_i_8d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1629,7 +1629,7 @@ int8_t stdlib_ndarray_mskfilter_s_i_8d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_i_8d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1730,7 +1730,7 @@ int8_t stdlib_ndarray_mskfilter_s_i_8d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_i_9d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1831,7 +1831,7 @@ int8_t stdlib_ndarray_mskfilter_s_i_9d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_i_9d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1932,7 +1932,7 @@ int8_t stdlib_ndarray_mskfilter_s_i_9d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_i_10d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2033,7 +2033,7 @@ int8_t stdlib_ndarray_mskfilter_s_i_10d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_i_10d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2134,7 +2134,7 @@ int8_t stdlib_ndarray_mskfilter_s_i_10d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_i_nd( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2279,7 +2279,7 @@ static const struct ndarrayUnarymskfilterDispatchObject obj = { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_i( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); diff --git a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/s_k.c b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/s_k.c index b33899b8348..ab290714b94 100644 --- a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/s_k.c +++ b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/s_k.c @@ -110,7 +110,7 @@ * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_k_0d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -214,7 +214,7 @@ int8_t stdlib_ndarray_mskfilter_s_k_0d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_k_1d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -315,7 +315,7 @@ int8_t stdlib_ndarray_mskfilter_s_k_1d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_k_2d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -417,7 +417,7 @@ int8_t stdlib_ndarray_mskfilter_s_k_2d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_k_2d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -518,7 +518,7 @@ int8_t stdlib_ndarray_mskfilter_s_k_2d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_k_3d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -619,7 +619,7 @@ int8_t stdlib_ndarray_mskfilter_s_k_3d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_k_3d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -720,7 +720,7 @@ int8_t stdlib_ndarray_mskfilter_s_k_3d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_k_4d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -821,7 +821,7 @@ int8_t stdlib_ndarray_mskfilter_s_k_4d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_k_4d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -922,7 +922,7 @@ int8_t stdlib_ndarray_mskfilter_s_k_4d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_k_5d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1023,7 +1023,7 @@ int8_t stdlib_ndarray_mskfilter_s_k_5d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_k_5d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1124,7 +1124,7 @@ int8_t stdlib_ndarray_mskfilter_s_k_5d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_k_6d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1225,7 +1225,7 @@ int8_t stdlib_ndarray_mskfilter_s_k_6d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_k_6d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1326,7 +1326,7 @@ int8_t stdlib_ndarray_mskfilter_s_k_6d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_k_7d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1427,7 +1427,7 @@ int8_t stdlib_ndarray_mskfilter_s_k_7d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_k_7d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1528,7 +1528,7 @@ int8_t stdlib_ndarray_mskfilter_s_k_7d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_k_8d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1629,7 +1629,7 @@ int8_t stdlib_ndarray_mskfilter_s_k_8d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_k_8d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1730,7 +1730,7 @@ int8_t stdlib_ndarray_mskfilter_s_k_8d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_k_9d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1831,7 +1831,7 @@ int8_t stdlib_ndarray_mskfilter_s_k_9d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_k_9d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1932,7 +1932,7 @@ int8_t stdlib_ndarray_mskfilter_s_k_9d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_k_10d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2033,7 +2033,7 @@ int8_t stdlib_ndarray_mskfilter_s_k_10d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_k_10d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2134,7 +2134,7 @@ int8_t stdlib_ndarray_mskfilter_s_k_10d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_k_nd( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2279,7 +2279,7 @@ static const struct ndarrayUnarymskfilterDispatchObject obj = { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_k( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); diff --git a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/s_s.c b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/s_s.c index be7a19fc7b9..01eae26280e 100644 --- a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/s_s.c +++ b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/s_s.c @@ -110,7 +110,7 @@ * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_s_0d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -214,7 +214,7 @@ int8_t stdlib_ndarray_mskfilter_s_s_0d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_s_1d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -315,7 +315,7 @@ int8_t stdlib_ndarray_mskfilter_s_s_1d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_s_2d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -417,7 +417,7 @@ int8_t stdlib_ndarray_mskfilter_s_s_2d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_s_2d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -518,7 +518,7 @@ int8_t stdlib_ndarray_mskfilter_s_s_2d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_s_3d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -619,7 +619,7 @@ int8_t stdlib_ndarray_mskfilter_s_s_3d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_s_3d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -720,7 +720,7 @@ int8_t stdlib_ndarray_mskfilter_s_s_3d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_s_4d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -821,7 +821,7 @@ int8_t stdlib_ndarray_mskfilter_s_s_4d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_s_4d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -922,7 +922,7 @@ int8_t stdlib_ndarray_mskfilter_s_s_4d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_s_5d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1023,7 +1023,7 @@ int8_t stdlib_ndarray_mskfilter_s_s_5d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_s_5d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1124,7 +1124,7 @@ int8_t stdlib_ndarray_mskfilter_s_s_5d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_s_6d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1225,7 +1225,7 @@ int8_t stdlib_ndarray_mskfilter_s_s_6d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_s_6d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1326,7 +1326,7 @@ int8_t stdlib_ndarray_mskfilter_s_s_6d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_s_7d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1427,7 +1427,7 @@ int8_t stdlib_ndarray_mskfilter_s_s_7d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_s_7d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1528,7 +1528,7 @@ int8_t stdlib_ndarray_mskfilter_s_s_7d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_s_8d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1629,7 +1629,7 @@ int8_t stdlib_ndarray_mskfilter_s_s_8d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_s_8d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1730,7 +1730,7 @@ int8_t stdlib_ndarray_mskfilter_s_s_8d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_s_9d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1831,7 +1831,7 @@ int8_t stdlib_ndarray_mskfilter_s_s_9d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_s_9d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1932,7 +1932,7 @@ int8_t stdlib_ndarray_mskfilter_s_s_9d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_s_10d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2033,7 +2033,7 @@ int8_t stdlib_ndarray_mskfilter_s_s_10d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_s_10d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2134,7 +2134,7 @@ int8_t stdlib_ndarray_mskfilter_s_s_10d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_s_nd( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2279,7 +2279,7 @@ static const struct ndarrayUnarymskfilterDispatchObject obj = { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_s( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); diff --git a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/s_t.c b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/s_t.c index 5a2a7c053f0..6789e78eaf1 100644 --- a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/s_t.c +++ b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/s_t.c @@ -110,7 +110,7 @@ * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_t_0d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -214,7 +214,7 @@ int8_t stdlib_ndarray_mskfilter_s_t_0d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_t_1d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -315,7 +315,7 @@ int8_t stdlib_ndarray_mskfilter_s_t_1d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_t_2d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -417,7 +417,7 @@ int8_t stdlib_ndarray_mskfilter_s_t_2d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_t_2d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -518,7 +518,7 @@ int8_t stdlib_ndarray_mskfilter_s_t_2d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_t_3d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -619,7 +619,7 @@ int8_t stdlib_ndarray_mskfilter_s_t_3d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_t_3d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -720,7 +720,7 @@ int8_t stdlib_ndarray_mskfilter_s_t_3d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_t_4d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -821,7 +821,7 @@ int8_t stdlib_ndarray_mskfilter_s_t_4d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_t_4d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -922,7 +922,7 @@ int8_t stdlib_ndarray_mskfilter_s_t_4d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_t_5d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1023,7 +1023,7 @@ int8_t stdlib_ndarray_mskfilter_s_t_5d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_t_5d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1124,7 +1124,7 @@ int8_t stdlib_ndarray_mskfilter_s_t_5d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_t_6d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1225,7 +1225,7 @@ int8_t stdlib_ndarray_mskfilter_s_t_6d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_t_6d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1326,7 +1326,7 @@ int8_t stdlib_ndarray_mskfilter_s_t_6d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_t_7d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1427,7 +1427,7 @@ int8_t stdlib_ndarray_mskfilter_s_t_7d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_t_7d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1528,7 +1528,7 @@ int8_t stdlib_ndarray_mskfilter_s_t_7d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_t_8d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1629,7 +1629,7 @@ int8_t stdlib_ndarray_mskfilter_s_t_8d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_t_8d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1730,7 +1730,7 @@ int8_t stdlib_ndarray_mskfilter_s_t_8d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_t_9d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1831,7 +1831,7 @@ int8_t stdlib_ndarray_mskfilter_s_t_9d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_t_9d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1932,7 +1932,7 @@ int8_t stdlib_ndarray_mskfilter_s_t_9d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_t_10d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2033,7 +2033,7 @@ int8_t stdlib_ndarray_mskfilter_s_t_10d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_t_10d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2134,7 +2134,7 @@ int8_t stdlib_ndarray_mskfilter_s_t_10d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_t_nd( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2279,7 +2279,7 @@ static const struct ndarrayUnarymskfilterDispatchObject obj = { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_t( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); diff --git a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/s_u.c b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/s_u.c index b1d9725cd96..1cff2a7ce1a 100644 --- a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/s_u.c +++ b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/s_u.c @@ -110,7 +110,7 @@ * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_u_0d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -214,7 +214,7 @@ int8_t stdlib_ndarray_mskfilter_s_u_0d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_u_1d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -315,7 +315,7 @@ int8_t stdlib_ndarray_mskfilter_s_u_1d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_u_2d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -417,7 +417,7 @@ int8_t stdlib_ndarray_mskfilter_s_u_2d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_u_2d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -518,7 +518,7 @@ int8_t stdlib_ndarray_mskfilter_s_u_2d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_u_3d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -619,7 +619,7 @@ int8_t stdlib_ndarray_mskfilter_s_u_3d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_u_3d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -720,7 +720,7 @@ int8_t stdlib_ndarray_mskfilter_s_u_3d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_u_4d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -821,7 +821,7 @@ int8_t stdlib_ndarray_mskfilter_s_u_4d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_u_4d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -922,7 +922,7 @@ int8_t stdlib_ndarray_mskfilter_s_u_4d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_u_5d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1023,7 +1023,7 @@ int8_t stdlib_ndarray_mskfilter_s_u_5d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_u_5d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1124,7 +1124,7 @@ int8_t stdlib_ndarray_mskfilter_s_u_5d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_u_6d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1225,7 +1225,7 @@ int8_t stdlib_ndarray_mskfilter_s_u_6d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_u_6d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1326,7 +1326,7 @@ int8_t stdlib_ndarray_mskfilter_s_u_6d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_u_7d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1427,7 +1427,7 @@ int8_t stdlib_ndarray_mskfilter_s_u_7d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_u_7d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1528,7 +1528,7 @@ int8_t stdlib_ndarray_mskfilter_s_u_7d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_u_8d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1629,7 +1629,7 @@ int8_t stdlib_ndarray_mskfilter_s_u_8d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_u_8d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1730,7 +1730,7 @@ int8_t stdlib_ndarray_mskfilter_s_u_8d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_u_9d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1831,7 +1831,7 @@ int8_t stdlib_ndarray_mskfilter_s_u_9d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_u_9d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1932,7 +1932,7 @@ int8_t stdlib_ndarray_mskfilter_s_u_9d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_u_10d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2033,7 +2033,7 @@ int8_t stdlib_ndarray_mskfilter_s_u_10d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_u_10d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2134,7 +2134,7 @@ int8_t stdlib_ndarray_mskfilter_s_u_10d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_u_nd( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2279,7 +2279,7 @@ static const struct ndarrayUnarymskfilterDispatchObject obj = { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_u( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); diff --git a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/s_z.c b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/s_z.c index f75d1eab0aa..67aeb67fba1 100644 --- a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/s_z.c +++ b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/s_z.c @@ -111,7 +111,7 @@ * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_z_0d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -215,7 +215,7 @@ int8_t stdlib_ndarray_mskfilter_s_z_0d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_z_1d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -316,7 +316,7 @@ int8_t stdlib_ndarray_mskfilter_s_z_1d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_z_2d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -418,7 +418,7 @@ int8_t stdlib_ndarray_mskfilter_s_z_2d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_z_2d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -519,7 +519,7 @@ int8_t stdlib_ndarray_mskfilter_s_z_2d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_z_3d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -620,7 +620,7 @@ int8_t stdlib_ndarray_mskfilter_s_z_3d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_z_3d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -721,7 +721,7 @@ int8_t stdlib_ndarray_mskfilter_s_z_3d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_z_4d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -822,7 +822,7 @@ int8_t stdlib_ndarray_mskfilter_s_z_4d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_z_4d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -923,7 +923,7 @@ int8_t stdlib_ndarray_mskfilter_s_z_4d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_z_5d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1024,7 +1024,7 @@ int8_t stdlib_ndarray_mskfilter_s_z_5d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_z_5d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1125,7 +1125,7 @@ int8_t stdlib_ndarray_mskfilter_s_z_5d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_z_6d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1226,7 +1226,7 @@ int8_t stdlib_ndarray_mskfilter_s_z_6d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_z_6d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1327,7 +1327,7 @@ int8_t stdlib_ndarray_mskfilter_s_z_6d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_z_7d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1428,7 +1428,7 @@ int8_t stdlib_ndarray_mskfilter_s_z_7d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_z_7d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1529,7 +1529,7 @@ int8_t stdlib_ndarray_mskfilter_s_z_7d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_z_8d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1630,7 +1630,7 @@ int8_t stdlib_ndarray_mskfilter_s_z_8d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_z_8d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1731,7 +1731,7 @@ int8_t stdlib_ndarray_mskfilter_s_z_8d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_z_9d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1832,7 +1832,7 @@ int8_t stdlib_ndarray_mskfilter_s_z_9d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_z_9d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1933,7 +1933,7 @@ int8_t stdlib_ndarray_mskfilter_s_z_9d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_z_10d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2034,7 +2034,7 @@ int8_t stdlib_ndarray_mskfilter_s_z_10d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_z_10d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2135,7 +2135,7 @@ int8_t stdlib_ndarray_mskfilter_s_z_10d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_z_nd( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2280,7 +2280,7 @@ static const struct ndarrayUnarymskfilterDispatchObject obj = { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_s_z( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); diff --git a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/t_c.c b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/t_c.c index d8813a6c15a..3833d76d42d 100644 --- a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/t_c.c +++ b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/t_c.c @@ -111,7 +111,7 @@ * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_c_0d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -215,7 +215,7 @@ int8_t stdlib_ndarray_mskfilter_t_c_0d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_c_1d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -316,7 +316,7 @@ int8_t stdlib_ndarray_mskfilter_t_c_1d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_c_2d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -418,7 +418,7 @@ int8_t stdlib_ndarray_mskfilter_t_c_2d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_c_2d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -519,7 +519,7 @@ int8_t stdlib_ndarray_mskfilter_t_c_2d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_c_3d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -620,7 +620,7 @@ int8_t stdlib_ndarray_mskfilter_t_c_3d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_c_3d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -721,7 +721,7 @@ int8_t stdlib_ndarray_mskfilter_t_c_3d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_c_4d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -822,7 +822,7 @@ int8_t stdlib_ndarray_mskfilter_t_c_4d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_c_4d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -923,7 +923,7 @@ int8_t stdlib_ndarray_mskfilter_t_c_4d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_c_5d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1024,7 +1024,7 @@ int8_t stdlib_ndarray_mskfilter_t_c_5d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_c_5d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1125,7 +1125,7 @@ int8_t stdlib_ndarray_mskfilter_t_c_5d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_c_6d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1226,7 +1226,7 @@ int8_t stdlib_ndarray_mskfilter_t_c_6d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_c_6d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1327,7 +1327,7 @@ int8_t stdlib_ndarray_mskfilter_t_c_6d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_c_7d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1428,7 +1428,7 @@ int8_t stdlib_ndarray_mskfilter_t_c_7d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_c_7d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1529,7 +1529,7 @@ int8_t stdlib_ndarray_mskfilter_t_c_7d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_c_8d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1630,7 +1630,7 @@ int8_t stdlib_ndarray_mskfilter_t_c_8d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_c_8d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1731,7 +1731,7 @@ int8_t stdlib_ndarray_mskfilter_t_c_8d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_c_9d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1832,7 +1832,7 @@ int8_t stdlib_ndarray_mskfilter_t_c_9d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_c_9d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1933,7 +1933,7 @@ int8_t stdlib_ndarray_mskfilter_t_c_9d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_c_10d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2034,7 +2034,7 @@ int8_t stdlib_ndarray_mskfilter_t_c_10d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_c_10d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2135,7 +2135,7 @@ int8_t stdlib_ndarray_mskfilter_t_c_10d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_c_nd( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2280,7 +2280,7 @@ static const struct ndarrayUnarymskfilterDispatchObject obj = { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_c( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); diff --git a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/t_d.c b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/t_d.c index c18427f7359..d8f9863952c 100644 --- a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/t_d.c +++ b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/t_d.c @@ -110,7 +110,7 @@ * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_d_0d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -214,7 +214,7 @@ int8_t stdlib_ndarray_mskfilter_t_d_0d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_d_1d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -315,7 +315,7 @@ int8_t stdlib_ndarray_mskfilter_t_d_1d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_d_2d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -417,7 +417,7 @@ int8_t stdlib_ndarray_mskfilter_t_d_2d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_d_2d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -518,7 +518,7 @@ int8_t stdlib_ndarray_mskfilter_t_d_2d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_d_3d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -619,7 +619,7 @@ int8_t stdlib_ndarray_mskfilter_t_d_3d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_d_3d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -720,7 +720,7 @@ int8_t stdlib_ndarray_mskfilter_t_d_3d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_d_4d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -821,7 +821,7 @@ int8_t stdlib_ndarray_mskfilter_t_d_4d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_d_4d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -922,7 +922,7 @@ int8_t stdlib_ndarray_mskfilter_t_d_4d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_d_5d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1023,7 +1023,7 @@ int8_t stdlib_ndarray_mskfilter_t_d_5d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_d_5d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1124,7 +1124,7 @@ int8_t stdlib_ndarray_mskfilter_t_d_5d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_d_6d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1225,7 +1225,7 @@ int8_t stdlib_ndarray_mskfilter_t_d_6d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_d_6d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1326,7 +1326,7 @@ int8_t stdlib_ndarray_mskfilter_t_d_6d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_d_7d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1427,7 +1427,7 @@ int8_t stdlib_ndarray_mskfilter_t_d_7d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_d_7d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1528,7 +1528,7 @@ int8_t stdlib_ndarray_mskfilter_t_d_7d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_d_8d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1629,7 +1629,7 @@ int8_t stdlib_ndarray_mskfilter_t_d_8d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_d_8d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1730,7 +1730,7 @@ int8_t stdlib_ndarray_mskfilter_t_d_8d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_d_9d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1831,7 +1831,7 @@ int8_t stdlib_ndarray_mskfilter_t_d_9d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_d_9d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1932,7 +1932,7 @@ int8_t stdlib_ndarray_mskfilter_t_d_9d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_d_10d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2033,7 +2033,7 @@ int8_t stdlib_ndarray_mskfilter_t_d_10d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_d_10d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2134,7 +2134,7 @@ int8_t stdlib_ndarray_mskfilter_t_d_10d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_d_nd( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2279,7 +2279,7 @@ static const struct ndarrayUnarymskfilterDispatchObject obj = { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); diff --git a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/t_f.c b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/t_f.c index b8bad8c7512..4edb5d90924 100644 --- a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/t_f.c +++ b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/t_f.c @@ -110,7 +110,7 @@ * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_f_0d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -214,7 +214,7 @@ int8_t stdlib_ndarray_mskfilter_t_f_0d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_f_1d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -315,7 +315,7 @@ int8_t stdlib_ndarray_mskfilter_t_f_1d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_f_2d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -417,7 +417,7 @@ int8_t stdlib_ndarray_mskfilter_t_f_2d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_f_2d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -518,7 +518,7 @@ int8_t stdlib_ndarray_mskfilter_t_f_2d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_f_3d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -619,7 +619,7 @@ int8_t stdlib_ndarray_mskfilter_t_f_3d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_f_3d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -720,7 +720,7 @@ int8_t stdlib_ndarray_mskfilter_t_f_3d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_f_4d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -821,7 +821,7 @@ int8_t stdlib_ndarray_mskfilter_t_f_4d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_f_4d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -922,7 +922,7 @@ int8_t stdlib_ndarray_mskfilter_t_f_4d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_f_5d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1023,7 +1023,7 @@ int8_t stdlib_ndarray_mskfilter_t_f_5d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_f_5d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1124,7 +1124,7 @@ int8_t stdlib_ndarray_mskfilter_t_f_5d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_f_6d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1225,7 +1225,7 @@ int8_t stdlib_ndarray_mskfilter_t_f_6d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_f_6d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1326,7 +1326,7 @@ int8_t stdlib_ndarray_mskfilter_t_f_6d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_f_7d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1427,7 +1427,7 @@ int8_t stdlib_ndarray_mskfilter_t_f_7d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_f_7d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1528,7 +1528,7 @@ int8_t stdlib_ndarray_mskfilter_t_f_7d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_f_8d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1629,7 +1629,7 @@ int8_t stdlib_ndarray_mskfilter_t_f_8d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_f_8d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1730,7 +1730,7 @@ int8_t stdlib_ndarray_mskfilter_t_f_8d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_f_9d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1831,7 +1831,7 @@ int8_t stdlib_ndarray_mskfilter_t_f_9d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_f_9d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1932,7 +1932,7 @@ int8_t stdlib_ndarray_mskfilter_t_f_9d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_f_10d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2033,7 +2033,7 @@ int8_t stdlib_ndarray_mskfilter_t_f_10d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_f_10d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2134,7 +2134,7 @@ int8_t stdlib_ndarray_mskfilter_t_f_10d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_f_nd( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2279,7 +2279,7 @@ static const struct ndarrayUnarymskfilterDispatchObject obj = { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_f( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); diff --git a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/t_i.c b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/t_i.c index a031a0cdb35..15031b3feba 100644 --- a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/t_i.c +++ b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/t_i.c @@ -110,7 +110,7 @@ * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_i_0d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -214,7 +214,7 @@ int8_t stdlib_ndarray_mskfilter_t_i_0d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_i_1d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -315,7 +315,7 @@ int8_t stdlib_ndarray_mskfilter_t_i_1d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_i_2d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -417,7 +417,7 @@ int8_t stdlib_ndarray_mskfilter_t_i_2d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_i_2d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -518,7 +518,7 @@ int8_t stdlib_ndarray_mskfilter_t_i_2d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_i_3d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -619,7 +619,7 @@ int8_t stdlib_ndarray_mskfilter_t_i_3d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_i_3d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -720,7 +720,7 @@ int8_t stdlib_ndarray_mskfilter_t_i_3d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_i_4d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -821,7 +821,7 @@ int8_t stdlib_ndarray_mskfilter_t_i_4d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_i_4d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -922,7 +922,7 @@ int8_t stdlib_ndarray_mskfilter_t_i_4d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_i_5d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1023,7 +1023,7 @@ int8_t stdlib_ndarray_mskfilter_t_i_5d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_i_5d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1124,7 +1124,7 @@ int8_t stdlib_ndarray_mskfilter_t_i_5d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_i_6d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1225,7 +1225,7 @@ int8_t stdlib_ndarray_mskfilter_t_i_6d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_i_6d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1326,7 +1326,7 @@ int8_t stdlib_ndarray_mskfilter_t_i_6d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_i_7d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1427,7 +1427,7 @@ int8_t stdlib_ndarray_mskfilter_t_i_7d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_i_7d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1528,7 +1528,7 @@ int8_t stdlib_ndarray_mskfilter_t_i_7d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_i_8d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1629,7 +1629,7 @@ int8_t stdlib_ndarray_mskfilter_t_i_8d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_i_8d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1730,7 +1730,7 @@ int8_t stdlib_ndarray_mskfilter_t_i_8d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_i_9d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1831,7 +1831,7 @@ int8_t stdlib_ndarray_mskfilter_t_i_9d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_i_9d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1932,7 +1932,7 @@ int8_t stdlib_ndarray_mskfilter_t_i_9d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_i_10d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2033,7 +2033,7 @@ int8_t stdlib_ndarray_mskfilter_t_i_10d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_i_10d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2134,7 +2134,7 @@ int8_t stdlib_ndarray_mskfilter_t_i_10d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_i_nd( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2279,7 +2279,7 @@ static const struct ndarrayUnarymskfilterDispatchObject obj = { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_i( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); diff --git a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/t_t.c b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/t_t.c index 82ce7561290..395dd955988 100644 --- a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/t_t.c +++ b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/t_t.c @@ -110,7 +110,7 @@ * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_t_0d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -214,7 +214,7 @@ int8_t stdlib_ndarray_mskfilter_t_t_0d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_t_1d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -315,7 +315,7 @@ int8_t stdlib_ndarray_mskfilter_t_t_1d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_t_2d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -417,7 +417,7 @@ int8_t stdlib_ndarray_mskfilter_t_t_2d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_t_2d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -518,7 +518,7 @@ int8_t stdlib_ndarray_mskfilter_t_t_2d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_t_3d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -619,7 +619,7 @@ int8_t stdlib_ndarray_mskfilter_t_t_3d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_t_3d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -720,7 +720,7 @@ int8_t stdlib_ndarray_mskfilter_t_t_3d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_t_4d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -821,7 +821,7 @@ int8_t stdlib_ndarray_mskfilter_t_t_4d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_t_4d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -922,7 +922,7 @@ int8_t stdlib_ndarray_mskfilter_t_t_4d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_t_5d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1023,7 +1023,7 @@ int8_t stdlib_ndarray_mskfilter_t_t_5d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_t_5d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1124,7 +1124,7 @@ int8_t stdlib_ndarray_mskfilter_t_t_5d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_t_6d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1225,7 +1225,7 @@ int8_t stdlib_ndarray_mskfilter_t_t_6d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_t_6d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1326,7 +1326,7 @@ int8_t stdlib_ndarray_mskfilter_t_t_6d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_t_7d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1427,7 +1427,7 @@ int8_t stdlib_ndarray_mskfilter_t_t_7d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_t_7d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1528,7 +1528,7 @@ int8_t stdlib_ndarray_mskfilter_t_t_7d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_t_8d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1629,7 +1629,7 @@ int8_t stdlib_ndarray_mskfilter_t_t_8d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_t_8d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1730,7 +1730,7 @@ int8_t stdlib_ndarray_mskfilter_t_t_8d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_t_9d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1831,7 +1831,7 @@ int8_t stdlib_ndarray_mskfilter_t_t_9d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_t_9d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1932,7 +1932,7 @@ int8_t stdlib_ndarray_mskfilter_t_t_9d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_t_10d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2033,7 +2033,7 @@ int8_t stdlib_ndarray_mskfilter_t_t_10d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_t_10d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2134,7 +2134,7 @@ int8_t stdlib_ndarray_mskfilter_t_t_10d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_t_nd( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2279,7 +2279,7 @@ static const struct ndarrayUnarymskfilterDispatchObject obj = { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_t( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); diff --git a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/t_u.c b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/t_u.c index a9608fd7c97..627a476ac02 100644 --- a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/t_u.c +++ b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/t_u.c @@ -110,7 +110,7 @@ * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_u_0d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -214,7 +214,7 @@ int8_t stdlib_ndarray_mskfilter_t_u_0d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_u_1d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -315,7 +315,7 @@ int8_t stdlib_ndarray_mskfilter_t_u_1d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_u_2d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -417,7 +417,7 @@ int8_t stdlib_ndarray_mskfilter_t_u_2d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_u_2d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -518,7 +518,7 @@ int8_t stdlib_ndarray_mskfilter_t_u_2d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_u_3d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -619,7 +619,7 @@ int8_t stdlib_ndarray_mskfilter_t_u_3d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_u_3d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -720,7 +720,7 @@ int8_t stdlib_ndarray_mskfilter_t_u_3d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_u_4d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -821,7 +821,7 @@ int8_t stdlib_ndarray_mskfilter_t_u_4d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_u_4d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -922,7 +922,7 @@ int8_t stdlib_ndarray_mskfilter_t_u_4d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_u_5d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1023,7 +1023,7 @@ int8_t stdlib_ndarray_mskfilter_t_u_5d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_u_5d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1124,7 +1124,7 @@ int8_t stdlib_ndarray_mskfilter_t_u_5d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_u_6d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1225,7 +1225,7 @@ int8_t stdlib_ndarray_mskfilter_t_u_6d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_u_6d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1326,7 +1326,7 @@ int8_t stdlib_ndarray_mskfilter_t_u_6d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_u_7d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1427,7 +1427,7 @@ int8_t stdlib_ndarray_mskfilter_t_u_7d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_u_7d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1528,7 +1528,7 @@ int8_t stdlib_ndarray_mskfilter_t_u_7d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_u_8d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1629,7 +1629,7 @@ int8_t stdlib_ndarray_mskfilter_t_u_8d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_u_8d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1730,7 +1730,7 @@ int8_t stdlib_ndarray_mskfilter_t_u_8d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_u_9d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1831,7 +1831,7 @@ int8_t stdlib_ndarray_mskfilter_t_u_9d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_u_9d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1932,7 +1932,7 @@ int8_t stdlib_ndarray_mskfilter_t_u_9d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_u_10d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2033,7 +2033,7 @@ int8_t stdlib_ndarray_mskfilter_t_u_10d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_u_10d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2134,7 +2134,7 @@ int8_t stdlib_ndarray_mskfilter_t_u_10d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_u_nd( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2279,7 +2279,7 @@ static const struct ndarrayUnarymskfilterDispatchObject obj = { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_u( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); diff --git a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/t_z.c b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/t_z.c index 6dd4abd9fd7..2972702858c 100644 --- a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/t_z.c +++ b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/t_z.c @@ -111,7 +111,7 @@ * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_z_0d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -215,7 +215,7 @@ int8_t stdlib_ndarray_mskfilter_t_z_0d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_z_1d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -316,7 +316,7 @@ int8_t stdlib_ndarray_mskfilter_t_z_1d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_z_2d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -418,7 +418,7 @@ int8_t stdlib_ndarray_mskfilter_t_z_2d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_z_2d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -519,7 +519,7 @@ int8_t stdlib_ndarray_mskfilter_t_z_2d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_z_3d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -620,7 +620,7 @@ int8_t stdlib_ndarray_mskfilter_t_z_3d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_z_3d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -721,7 +721,7 @@ int8_t stdlib_ndarray_mskfilter_t_z_3d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_z_4d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -822,7 +822,7 @@ int8_t stdlib_ndarray_mskfilter_t_z_4d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_z_4d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -923,7 +923,7 @@ int8_t stdlib_ndarray_mskfilter_t_z_4d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_z_5d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1024,7 +1024,7 @@ int8_t stdlib_ndarray_mskfilter_t_z_5d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_z_5d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1125,7 +1125,7 @@ int8_t stdlib_ndarray_mskfilter_t_z_5d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_z_6d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1226,7 +1226,7 @@ int8_t stdlib_ndarray_mskfilter_t_z_6d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_z_6d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1327,7 +1327,7 @@ int8_t stdlib_ndarray_mskfilter_t_z_6d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_z_7d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1428,7 +1428,7 @@ int8_t stdlib_ndarray_mskfilter_t_z_7d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_z_7d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1529,7 +1529,7 @@ int8_t stdlib_ndarray_mskfilter_t_z_7d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_z_8d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1630,7 +1630,7 @@ int8_t stdlib_ndarray_mskfilter_t_z_8d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_z_8d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1731,7 +1731,7 @@ int8_t stdlib_ndarray_mskfilter_t_z_8d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_z_9d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1832,7 +1832,7 @@ int8_t stdlib_ndarray_mskfilter_t_z_9d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_z_9d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1933,7 +1933,7 @@ int8_t stdlib_ndarray_mskfilter_t_z_9d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_z_10d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2034,7 +2034,7 @@ int8_t stdlib_ndarray_mskfilter_t_z_10d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_z_10d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2135,7 +2135,7 @@ int8_t stdlib_ndarray_mskfilter_t_z_10d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_z_nd( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2280,7 +2280,7 @@ static const struct ndarrayUnarymskfilterDispatchObject obj = { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_t_z( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); diff --git a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/u_d.c b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/u_d.c index 5c6e4800ddb..48931f71bd0 100644 --- a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/u_d.c +++ b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/u_d.c @@ -110,7 +110,7 @@ * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_u_d_0d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -214,7 +214,7 @@ int8_t stdlib_ndarray_mskfilter_u_d_0d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_u_d_1d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -315,7 +315,7 @@ int8_t stdlib_ndarray_mskfilter_u_d_1d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_u_d_2d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -417,7 +417,7 @@ int8_t stdlib_ndarray_mskfilter_u_d_2d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_u_d_2d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -518,7 +518,7 @@ int8_t stdlib_ndarray_mskfilter_u_d_2d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_u_d_3d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -619,7 +619,7 @@ int8_t stdlib_ndarray_mskfilter_u_d_3d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_u_d_3d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -720,7 +720,7 @@ int8_t stdlib_ndarray_mskfilter_u_d_3d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_u_d_4d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -821,7 +821,7 @@ int8_t stdlib_ndarray_mskfilter_u_d_4d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_u_d_4d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -922,7 +922,7 @@ int8_t stdlib_ndarray_mskfilter_u_d_4d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_u_d_5d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1023,7 +1023,7 @@ int8_t stdlib_ndarray_mskfilter_u_d_5d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_u_d_5d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1124,7 +1124,7 @@ int8_t stdlib_ndarray_mskfilter_u_d_5d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_u_d_6d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1225,7 +1225,7 @@ int8_t stdlib_ndarray_mskfilter_u_d_6d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_u_d_6d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1326,7 +1326,7 @@ int8_t stdlib_ndarray_mskfilter_u_d_6d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_u_d_7d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1427,7 +1427,7 @@ int8_t stdlib_ndarray_mskfilter_u_d_7d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_u_d_7d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1528,7 +1528,7 @@ int8_t stdlib_ndarray_mskfilter_u_d_7d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_u_d_8d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1629,7 +1629,7 @@ int8_t stdlib_ndarray_mskfilter_u_d_8d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_u_d_8d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1730,7 +1730,7 @@ int8_t stdlib_ndarray_mskfilter_u_d_8d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_u_d_9d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1831,7 +1831,7 @@ int8_t stdlib_ndarray_mskfilter_u_d_9d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_u_d_9d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1932,7 +1932,7 @@ int8_t stdlib_ndarray_mskfilter_u_d_9d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_u_d_10d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2033,7 +2033,7 @@ int8_t stdlib_ndarray_mskfilter_u_d_10d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_u_d_10d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2134,7 +2134,7 @@ int8_t stdlib_ndarray_mskfilter_u_d_10d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_u_d_nd( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2279,7 +2279,7 @@ static const struct ndarrayUnarymskfilterDispatchObject obj = { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_u_d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); diff --git a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/u_u.c b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/u_u.c index e08bbe64664..c0b3cea94e6 100644 --- a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/u_u.c +++ b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/u_u.c @@ -110,7 +110,7 @@ * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_u_u_0d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -214,7 +214,7 @@ int8_t stdlib_ndarray_mskfilter_u_u_0d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_u_u_1d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -315,7 +315,7 @@ int8_t stdlib_ndarray_mskfilter_u_u_1d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_u_u_2d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -417,7 +417,7 @@ int8_t stdlib_ndarray_mskfilter_u_u_2d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_u_u_2d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -518,7 +518,7 @@ int8_t stdlib_ndarray_mskfilter_u_u_2d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_u_u_3d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -619,7 +619,7 @@ int8_t stdlib_ndarray_mskfilter_u_u_3d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_u_u_3d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -720,7 +720,7 @@ int8_t stdlib_ndarray_mskfilter_u_u_3d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_u_u_4d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -821,7 +821,7 @@ int8_t stdlib_ndarray_mskfilter_u_u_4d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_u_u_4d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -922,7 +922,7 @@ int8_t stdlib_ndarray_mskfilter_u_u_4d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_u_u_5d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1023,7 +1023,7 @@ int8_t stdlib_ndarray_mskfilter_u_u_5d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_u_u_5d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1124,7 +1124,7 @@ int8_t stdlib_ndarray_mskfilter_u_u_5d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_u_u_6d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1225,7 +1225,7 @@ int8_t stdlib_ndarray_mskfilter_u_u_6d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_u_u_6d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1326,7 +1326,7 @@ int8_t stdlib_ndarray_mskfilter_u_u_6d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_u_u_7d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1427,7 +1427,7 @@ int8_t stdlib_ndarray_mskfilter_u_u_7d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_u_u_7d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1528,7 +1528,7 @@ int8_t stdlib_ndarray_mskfilter_u_u_7d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_u_u_8d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1629,7 +1629,7 @@ int8_t stdlib_ndarray_mskfilter_u_u_8d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_u_u_8d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1730,7 +1730,7 @@ int8_t stdlib_ndarray_mskfilter_u_u_8d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_u_u_9d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1831,7 +1831,7 @@ int8_t stdlib_ndarray_mskfilter_u_u_9d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_u_u_9d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1932,7 +1932,7 @@ int8_t stdlib_ndarray_mskfilter_u_u_9d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_u_u_10d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2033,7 +2033,7 @@ int8_t stdlib_ndarray_mskfilter_u_u_10d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_u_u_10d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2134,7 +2134,7 @@ int8_t stdlib_ndarray_mskfilter_u_u_10d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_u_u_nd( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2279,7 +2279,7 @@ static const struct ndarrayUnarymskfilterDispatchObject obj = { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_u_u( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); diff --git a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/u_z.c b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/u_z.c index 6514f3b9435..5f35e964679 100644 --- a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/u_z.c +++ b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/u_z.c @@ -111,7 +111,7 @@ * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_u_z_0d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -215,7 +215,7 @@ int8_t stdlib_ndarray_mskfilter_u_z_0d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_u_z_1d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -316,7 +316,7 @@ int8_t stdlib_ndarray_mskfilter_u_z_1d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_u_z_2d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -418,7 +418,7 @@ int8_t stdlib_ndarray_mskfilter_u_z_2d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_u_z_2d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -519,7 +519,7 @@ int8_t stdlib_ndarray_mskfilter_u_z_2d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_u_z_3d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -620,7 +620,7 @@ int8_t stdlib_ndarray_mskfilter_u_z_3d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_u_z_3d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -721,7 +721,7 @@ int8_t stdlib_ndarray_mskfilter_u_z_3d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_u_z_4d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -822,7 +822,7 @@ int8_t stdlib_ndarray_mskfilter_u_z_4d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_u_z_4d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -923,7 +923,7 @@ int8_t stdlib_ndarray_mskfilter_u_z_4d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_u_z_5d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1024,7 +1024,7 @@ int8_t stdlib_ndarray_mskfilter_u_z_5d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_u_z_5d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1125,7 +1125,7 @@ int8_t stdlib_ndarray_mskfilter_u_z_5d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_u_z_6d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1226,7 +1226,7 @@ int8_t stdlib_ndarray_mskfilter_u_z_6d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_u_z_6d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1327,7 +1327,7 @@ int8_t stdlib_ndarray_mskfilter_u_z_6d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_u_z_7d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1428,7 +1428,7 @@ int8_t stdlib_ndarray_mskfilter_u_z_7d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_u_z_7d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1529,7 +1529,7 @@ int8_t stdlib_ndarray_mskfilter_u_z_7d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_u_z_8d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1630,7 +1630,7 @@ int8_t stdlib_ndarray_mskfilter_u_z_8d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_u_z_8d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1731,7 +1731,7 @@ int8_t stdlib_ndarray_mskfilter_u_z_8d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_u_z_9d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1832,7 +1832,7 @@ int8_t stdlib_ndarray_mskfilter_u_z_9d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_u_z_9d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1933,7 +1933,7 @@ int8_t stdlib_ndarray_mskfilter_u_z_9d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_u_z_10d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2034,7 +2034,7 @@ int8_t stdlib_ndarray_mskfilter_u_z_10d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_u_z_10d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2135,7 +2135,7 @@ int8_t stdlib_ndarray_mskfilter_u_z_10d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_u_z_nd( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2280,7 +2280,7 @@ static const struct ndarrayUnarymskfilterDispatchObject obj = { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_u_z( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); diff --git a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/x_x.c b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/x_x.c index 53245c199a9..9b2c4980d55 100644 --- a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/x_x.c +++ b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/x_x.c @@ -111,7 +111,7 @@ * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_x_x_0d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -215,7 +215,7 @@ int8_t stdlib_ndarray_mskfilter_x_x_0d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_x_x_1d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -316,7 +316,7 @@ int8_t stdlib_ndarray_mskfilter_x_x_1d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_x_x_2d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -418,7 +418,7 @@ int8_t stdlib_ndarray_mskfilter_x_x_2d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_x_x_2d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -519,7 +519,7 @@ int8_t stdlib_ndarray_mskfilter_x_x_2d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_x_x_3d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -620,7 +620,7 @@ int8_t stdlib_ndarray_mskfilter_x_x_3d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_x_x_3d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -721,7 +721,7 @@ int8_t stdlib_ndarray_mskfilter_x_x_3d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_x_x_4d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -822,7 +822,7 @@ int8_t stdlib_ndarray_mskfilter_x_x_4d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_x_x_4d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -923,7 +923,7 @@ int8_t stdlib_ndarray_mskfilter_x_x_4d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_x_x_5d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1024,7 +1024,7 @@ int8_t stdlib_ndarray_mskfilter_x_x_5d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_x_x_5d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1125,7 +1125,7 @@ int8_t stdlib_ndarray_mskfilter_x_x_5d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_x_x_6d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1226,7 +1226,7 @@ int8_t stdlib_ndarray_mskfilter_x_x_6d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_x_x_6d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1327,7 +1327,7 @@ int8_t stdlib_ndarray_mskfilter_x_x_6d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_x_x_7d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1428,7 +1428,7 @@ int8_t stdlib_ndarray_mskfilter_x_x_7d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_x_x_7d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1529,7 +1529,7 @@ int8_t stdlib_ndarray_mskfilter_x_x_7d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_x_x_8d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1630,7 +1630,7 @@ int8_t stdlib_ndarray_mskfilter_x_x_8d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_x_x_8d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1731,7 +1731,7 @@ int8_t stdlib_ndarray_mskfilter_x_x_8d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_x_x_9d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1832,7 +1832,7 @@ int8_t stdlib_ndarray_mskfilter_x_x_9d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_x_x_9d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1933,7 +1933,7 @@ int8_t stdlib_ndarray_mskfilter_x_x_9d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_x_x_10d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2034,7 +2034,7 @@ int8_t stdlib_ndarray_mskfilter_x_x_10d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_x_x_10d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2135,7 +2135,7 @@ int8_t stdlib_ndarray_mskfilter_x_x_10d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_x_x_nd( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2280,7 +2280,7 @@ static const struct ndarrayUnarymskfilterDispatchObject obj = { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_x_x( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); diff --git a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/z_c.c b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/z_c.c index da131d2c4f5..66e7e83aeb0 100644 --- a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/z_c.c +++ b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/z_c.c @@ -112,7 +112,7 @@ * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_z_c_0d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -216,7 +216,7 @@ int8_t stdlib_ndarray_mskfilter_z_c_0d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_z_c_1d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -317,7 +317,7 @@ int8_t stdlib_ndarray_mskfilter_z_c_1d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_z_c_2d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -419,7 +419,7 @@ int8_t stdlib_ndarray_mskfilter_z_c_2d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_z_c_2d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -520,7 +520,7 @@ int8_t stdlib_ndarray_mskfilter_z_c_2d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_z_c_3d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -621,7 +621,7 @@ int8_t stdlib_ndarray_mskfilter_z_c_3d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_z_c_3d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -722,7 +722,7 @@ int8_t stdlib_ndarray_mskfilter_z_c_3d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_z_c_4d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -823,7 +823,7 @@ int8_t stdlib_ndarray_mskfilter_z_c_4d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_z_c_4d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -924,7 +924,7 @@ int8_t stdlib_ndarray_mskfilter_z_c_4d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_z_c_5d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1025,7 +1025,7 @@ int8_t stdlib_ndarray_mskfilter_z_c_5d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_z_c_5d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1126,7 +1126,7 @@ int8_t stdlib_ndarray_mskfilter_z_c_5d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_z_c_6d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1227,7 +1227,7 @@ int8_t stdlib_ndarray_mskfilter_z_c_6d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_z_c_6d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1328,7 +1328,7 @@ int8_t stdlib_ndarray_mskfilter_z_c_6d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_z_c_7d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1429,7 +1429,7 @@ int8_t stdlib_ndarray_mskfilter_z_c_7d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_z_c_7d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1530,7 +1530,7 @@ int8_t stdlib_ndarray_mskfilter_z_c_7d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_z_c_8d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1631,7 +1631,7 @@ int8_t stdlib_ndarray_mskfilter_z_c_8d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_z_c_8d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1732,7 +1732,7 @@ int8_t stdlib_ndarray_mskfilter_z_c_8d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_z_c_9d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1833,7 +1833,7 @@ int8_t stdlib_ndarray_mskfilter_z_c_9d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_z_c_9d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1934,7 +1934,7 @@ int8_t stdlib_ndarray_mskfilter_z_c_9d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_z_c_10d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2035,7 +2035,7 @@ int8_t stdlib_ndarray_mskfilter_z_c_10d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_z_c_10d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2136,7 +2136,7 @@ int8_t stdlib_ndarray_mskfilter_z_c_10d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_z_c_nd( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2281,7 +2281,7 @@ static const struct ndarrayUnarymskfilterDispatchObject obj = { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_z_c( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); diff --git a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/z_z.c b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/z_z.c index e4ce45cfdc3..6d613113329 100644 --- a/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/z_z.c +++ b/lib/node_modules/@stdlib/ndarray/base/mskfilter/src/z_z.c @@ -111,7 +111,7 @@ * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_z_z_0d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -215,7 +215,7 @@ int8_t stdlib_ndarray_mskfilter_z_z_0d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_z_z_1d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -316,7 +316,7 @@ int8_t stdlib_ndarray_mskfilter_z_z_1d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_z_z_2d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -418,7 +418,7 @@ int8_t stdlib_ndarray_mskfilter_z_z_2d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_z_z_2d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -519,7 +519,7 @@ int8_t stdlib_ndarray_mskfilter_z_z_2d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_z_z_3d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -620,7 +620,7 @@ int8_t stdlib_ndarray_mskfilter_z_z_3d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_z_z_3d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -721,7 +721,7 @@ int8_t stdlib_ndarray_mskfilter_z_z_3d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_z_z_4d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -822,7 +822,7 @@ int8_t stdlib_ndarray_mskfilter_z_z_4d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_z_z_4d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -923,7 +923,7 @@ int8_t stdlib_ndarray_mskfilter_z_z_4d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_z_z_5d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1024,7 +1024,7 @@ int8_t stdlib_ndarray_mskfilter_z_z_5d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_z_z_5d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1125,7 +1125,7 @@ int8_t stdlib_ndarray_mskfilter_z_z_5d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_z_z_6d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1226,7 +1226,7 @@ int8_t stdlib_ndarray_mskfilter_z_z_6d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_z_z_6d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1327,7 +1327,7 @@ int8_t stdlib_ndarray_mskfilter_z_z_6d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_z_z_7d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1428,7 +1428,7 @@ int8_t stdlib_ndarray_mskfilter_z_z_7d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_z_z_7d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1529,7 +1529,7 @@ int8_t stdlib_ndarray_mskfilter_z_z_7d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_z_z_8d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1630,7 +1630,7 @@ int8_t stdlib_ndarray_mskfilter_z_z_8d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_z_z_8d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1731,7 +1731,7 @@ int8_t stdlib_ndarray_mskfilter_z_z_8d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_z_z_9d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1832,7 +1832,7 @@ int8_t stdlib_ndarray_mskfilter_z_z_9d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_z_z_9d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -1933,7 +1933,7 @@ int8_t stdlib_ndarray_mskfilter_z_z_9d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_z_z_10d( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2034,7 +2034,7 @@ int8_t stdlib_ndarray_mskfilter_z_z_10d( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_z_z_10d_blocked( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2135,7 +2135,7 @@ int8_t stdlib_ndarray_mskfilter_z_z_10d_blocked( struct ndarray *arrays[] ) { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_z_z_nd( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" ); @@ -2280,7 +2280,7 @@ static const struct ndarrayUnarymskfilterDispatchObject obj = { * // Create an array containing the ndarrays: * struct ndarray *arrays[] = { x, mask, y }; * -* // Copy elements: +* // Apply mask to array: * int8_t status = stdlib_ndarray_mskfilter_z_z( arrays ); * if ( status != 0 ) { * fprintf( stderr, "Error during computation.\n" );