name stringlengths 11 23 | func_name stringclasses 8
values | type stringclasses 1
value | code stringclasses 216
values | comments stringclasses 8
values | call stringclasses 8
values | call_comments dict | input stringclasses 79
values | constants stringclasses 3
values | output stringclasses 192
values | muper int64 0 82 | io_number int64 0 10 |
|---|---|---|---|---|---|---|---|---|---|---|---|
zeroTo_mu_0_0 | zeroTo | high | function zeroTo( n ) {
var arr;
var i;
arr = [];
if ( n <= 0 ) {
return arr;
}
for ( i = 0; i < n; i++ ) {
arr.push( i );
}
return arr;
}
| zeroTo:\n/**\n* Generates a linearly spaced numeric array whose elements increment by 1 starting from zero.\n*\n* @param {number} n - number of elements\n* @returns {Array<number>} linearly spaced numeric array\n*\n* @example\n* var arr = zeroTo( 6 );\n* // returns [ 0, 1, 2, 3, 4, 5 ]\n*/ | [] | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "None",
"ctors": "None",
"defaults": "None",
"dtype": "None",
"dtypes": "None",
"for... | 0 | [] | [] | 0 | 0 |
zeroTo_mu_0_1 | zeroTo | high | function zeroTo( n ) {
var arr;
var i;
arr = [];
if ( n <= 0 ) {
return arr;
}
for ( i = 0; i < n; i++ ) {
arr.push( i );
}
return arr;
}
| zeroTo:\n/**\n* Generates a linearly spaced numeric array whose elements increment by 1 starting from zero.\n*\n* @param {number} n - number of elements\n* @returns {Array<number>} linearly spaced numeric array\n*\n* @example\n* var arr = zeroTo( 6 );\n* // returns [ 0, 1, 2, 3, 4, 5 ]\n*/ | [] | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "None",
"ctors": "None",
"defaults": "None",
"dtype": "None",
"dtypes": "None",
"for... | 5 | [] | [ 0, 1, 2, 3, 4 ] | 0 | 1 |
zeroTo_mu_0_2 | zeroTo | high | function zeroTo( n ) {
var arr;
var i;
arr = [];
if ( n <= 0 ) {
return arr;
}
for ( i = 0; i < n; i++ ) {
arr.push( i );
}
return arr;
}
| zeroTo:\n/**\n* Generates a linearly spaced numeric array whose elements increment by 1 starting from zero.\n*\n* @param {number} n - number of elements\n* @returns {Array<number>} linearly spaced numeric array\n*\n* @example\n* var arr = zeroTo( 6 );\n* // returns [ 0, 1, 2, 3, 4, 5 ]\n*/ | [] | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "None",
"ctors": "None",
"defaults": "None",
"dtype": "None",
"dtypes": "None",
"for... | 1, 'float32' | [] | [ 0 ] | 0 | 2 |
zeroTo_mu_0_3 | zeroTo | high | function zeroTo( n ) {
var arr;
var i;
arr = [];
if ( n <= 0 ) {
return arr;
}
for ( i = 0; i < n; i++ ) {
arr.push( i );
}
return arr;
}
| zeroTo:\n/**\n* Generates a linearly spaced numeric array whose elements increment by 1 starting from zero.\n*\n* @param {number} n - number of elements\n* @returns {Array<number>} linearly spaced numeric array\n*\n* @example\n* var arr = zeroTo( 6 );\n* // returns [ 0, 1, 2, 3, 4, 5 ]\n*/ | [] | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "None",
"ctors": "None",
"defaults": "None",
"dtype": "None",
"dtypes": "None",
"for... | 10, 'int32' | [] | [
0, 1, 2, 3, 4,
5, 6, 7, 8, 9
] | 0 | 3 |
zeroTo_mu_0_4 | zeroTo | high | function zeroTo( n ) {
var arr;
var i;
arr = [];
if ( n <= 0 ) {
return arr;
}
for ( i = 0; i < n; i++ ) {
arr.push( i );
}
return arr;
}
| zeroTo:\n/**\n* Generates a linearly spaced numeric array whose elements increment by 1 starting from zero.\n*\n* @param {number} n - number of elements\n* @returns {Array<number>} linearly spaced numeric array\n*\n* @example\n* var arr = zeroTo( 6 );\n* // returns [ 0, 1, 2, 3, 4, 5 ]\n*/ | [] | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "None",
"ctors": "None",
"defaults": "None",
"dtype": "None",
"dtypes": "None",
"for... | 1000000, 'float64' | [] | [
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,
36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59,
60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71,
72, 73, 74, 75, ... | 0 | 4 |
zeroTo_mu_0_5 | zeroTo | high | function zeroTo( n ) {
var arr;
var i;
arr = [];
if ( n <= 0 ) {
return arr;
}
for ( i = 0; i < n; i++ ) {
arr.push( i );
}
return arr;
}
| zeroTo:\n/**\n* Generates a linearly spaced numeric array whose elements increment by 1 starting from zero.\n*\n* @param {number} n - number of elements\n* @returns {Array<number>} linearly spaced numeric array\n*\n* @example\n* var arr = zeroTo( 6 );\n* // returns [ 0, 1, 2, 3, 4, 5 ]\n*/ | [] | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "None",
"ctors": "None",
"defaults": "None",
"dtype": "None",
"dtypes": "None",
"for... | 3, 'uint8' | [] | [ 0, 1, 2 ] | 0 | 5 |
zeroTo_mu_0_6 | zeroTo | high | function zeroTo( n ) {
var arr;
var i;
arr = [];
if ( n <= 0 ) {
return arr;
}
for ( i = 0; i < n; i++ ) {
arr.push( i );
}
return arr;
}
| zeroTo:\n/**\n* Generates a linearly spaced numeric array whose elements increment by 1 starting from zero.\n*\n* @param {number} n - number of elements\n* @returns {Array<number>} linearly spaced numeric array\n*\n* @example\n* var arr = zeroTo( 6 );\n* // returns [ 0, 1, 2, 3, 4, 5 ]\n*/ | [] | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "None",
"ctors": "None",
"defaults": "None",
"dtype": "None",
"dtypes": "None",
"for... | 2, 'bool' | [] | [ 0, 1 ] | 0 | 6 |
zeroTo_mu_0_7 | zeroTo | high | function zeroTo( n ) {
var arr;
var i;
arr = [];
if ( n <= 0 ) {
return arr;
}
for ( i = 0; i < n; i++ ) {
arr.push( i );
}
return arr;
}
| zeroTo:\n/**\n* Generates a linearly spaced numeric array whose elements increment by 1 starting from zero.\n*\n* @param {number} n - number of elements\n* @returns {Array<number>} linearly spaced numeric array\n*\n* @example\n* var arr = zeroTo( 6 );\n* // returns [ 0, 1, 2, 3, 4, 5 ]\n*/ | [] | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "None",
"ctors": "None",
"defaults": "None",
"dtype": "None",
"dtypes": "None",
"for... | 8, 'complex128' | [] | [
0, 1, 2, 3,
4, 5, 6, 7
] | 0 | 7 |
zeroTo_mu_0_8 | zeroTo | high | function zeroTo( n ) {
var arr;
var i;
arr = [];
if ( n <= 0 ) {
return arr;
}
for ( i = 0; i < n; i++ ) {
arr.push( i );
}
return arr;
}
| zeroTo:\n/**\n* Generates a linearly spaced numeric array whose elements increment by 1 starting from zero.\n*\n* @param {number} n - number of elements\n* @returns {Array<number>} linearly spaced numeric array\n*\n* @example\n* var arr = zeroTo( 6 );\n* // returns [ 0, 1, 2, 3, 4, 5 ]\n*/ | [] | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "None",
"ctors": "None",
"defaults": "None",
"dtype": "None",
"dtypes": "None",
"for... | 999999999, 'int32' | [] | RangeError | 0 | 8 |
zeroTo_mu_0_9 | zeroTo | high | function zeroTo( n ) {
var arr;
var i;
arr = [];
if ( n <= 0 ) {
return arr;
}
for ( i = 0; i < n; i++ ) {
arr.push( i );
}
return arr;
}
| zeroTo:\n/**\n* Generates a linearly spaced numeric array whose elements increment by 1 starting from zero.\n*\n* @param {number} n - number of elements\n* @returns {Array<number>} linearly spaced numeric array\n*\n* @example\n* var arr = zeroTo( 6 );\n* // returns [ 0, 1, 2, 3, 4, 5 ]\n*/ | [] | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "None",
"ctors": "None",
"defaults": "None",
"dtype": "None",
"dtypes": "None",
"for... | 0, 'int8' | [] | [] | 0 | 9 |
zeroTo_mu_1_0 | zeroTo | high | function zeroTo( n ) {
var arr;
var i;
arr = [];
if ( true ) {
return arr;
}
for ( i = 0; i < n; i++ ) {
arr.push( i );
}
return arr;
}
| zeroTo:\n/**\n* Generates a linearly spaced numeric array whose elements increment by 1 starting from zero.\n*\n* @param {number} n - number of elements\n* @returns {Array<number>} linearly spaced numeric array\n*\n* @example\n* var arr = zeroTo( 6 );\n* // returns [ 0, 1, 2, 3, 4, 5 ]\n*/ | [] | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "None",
"ctors": "None",
"defaults": "None",
"dtype": "None",
"dtypes": "None",
"for... | 0 | [] | [] | 1 | 0 |
zeroTo_mu_1_1 | zeroTo | high | function zeroTo( n ) {
var arr;
var i;
arr = [];
if ( true ) {
return arr;
}
for ( i = 0; i < n; i++ ) {
arr.push( i );
}
return arr;
}
| zeroTo:\n/**\n* Generates a linearly spaced numeric array whose elements increment by 1 starting from zero.\n*\n* @param {number} n - number of elements\n* @returns {Array<number>} linearly spaced numeric array\n*\n* @example\n* var arr = zeroTo( 6 );\n* // returns [ 0, 1, 2, 3, 4, 5 ]\n*/ | [] | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "None",
"ctors": "None",
"defaults": "None",
"dtype": "None",
"dtypes": "None",
"for... | 5 | [] | [] | 1 | 1 |
zeroTo_mu_1_2 | zeroTo | high | function zeroTo( n ) {
var arr;
var i;
arr = [];
if ( true ) {
return arr;
}
for ( i = 0; i < n; i++ ) {
arr.push( i );
}
return arr;
}
| zeroTo:\n/**\n* Generates a linearly spaced numeric array whose elements increment by 1 starting from zero.\n*\n* @param {number} n - number of elements\n* @returns {Array<number>} linearly spaced numeric array\n*\n* @example\n* var arr = zeroTo( 6 );\n* // returns [ 0, 1, 2, 3, 4, 5 ]\n*/ | [] | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "None",
"ctors": "None",
"defaults": "None",
"dtype": "None",
"dtypes": "None",
"for... | 1, 'float32' | [] | [] | 1 | 2 |
zeroTo_mu_1_3 | zeroTo | high | function zeroTo( n ) {
var arr;
var i;
arr = [];
if ( true ) {
return arr;
}
for ( i = 0; i < n; i++ ) {
arr.push( i );
}
return arr;
}
| zeroTo:\n/**\n* Generates a linearly spaced numeric array whose elements increment by 1 starting from zero.\n*\n* @param {number} n - number of elements\n* @returns {Array<number>} linearly spaced numeric array\n*\n* @example\n* var arr = zeroTo( 6 );\n* // returns [ 0, 1, 2, 3, 4, 5 ]\n*/ | [] | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "None",
"ctors": "None",
"defaults": "None",
"dtype": "None",
"dtypes": "None",
"for... | 10, 'int32' | [] | [] | 1 | 3 |
zeroTo_mu_1_4 | zeroTo | high | function zeroTo( n ) {
var arr;
var i;
arr = [];
if ( true ) {
return arr;
}
for ( i = 0; i < n; i++ ) {
arr.push( i );
}
return arr;
}
| zeroTo:\n/**\n* Generates a linearly spaced numeric array whose elements increment by 1 starting from zero.\n*\n* @param {number} n - number of elements\n* @returns {Array<number>} linearly spaced numeric array\n*\n* @example\n* var arr = zeroTo( 6 );\n* // returns [ 0, 1, 2, 3, 4, 5 ]\n*/ | [] | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "None",
"ctors": "None",
"defaults": "None",
"dtype": "None",
"dtypes": "None",
"for... | 1000000, 'float64' | [] | [] | 1 | 4 |
zeroTo_mu_1_5 | zeroTo | high | function zeroTo( n ) {
var arr;
var i;
arr = [];
if ( true ) {
return arr;
}
for ( i = 0; i < n; i++ ) {
arr.push( i );
}
return arr;
}
| zeroTo:\n/**\n* Generates a linearly spaced numeric array whose elements increment by 1 starting from zero.\n*\n* @param {number} n - number of elements\n* @returns {Array<number>} linearly spaced numeric array\n*\n* @example\n* var arr = zeroTo( 6 );\n* // returns [ 0, 1, 2, 3, 4, 5 ]\n*/ | [] | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "None",
"ctors": "None",
"defaults": "None",
"dtype": "None",
"dtypes": "None",
"for... | 3, 'uint8' | [] | [] | 1 | 5 |
zeroTo_mu_1_6 | zeroTo | high | function zeroTo( n ) {
var arr;
var i;
arr = [];
if ( true ) {
return arr;
}
for ( i = 0; i < n; i++ ) {
arr.push( i );
}
return arr;
}
| zeroTo:\n/**\n* Generates a linearly spaced numeric array whose elements increment by 1 starting from zero.\n*\n* @param {number} n - number of elements\n* @returns {Array<number>} linearly spaced numeric array\n*\n* @example\n* var arr = zeroTo( 6 );\n* // returns [ 0, 1, 2, 3, 4, 5 ]\n*/ | [] | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "None",
"ctors": "None",
"defaults": "None",
"dtype": "None",
"dtypes": "None",
"for... | 2, 'bool' | [] | [] | 1 | 6 |
zeroTo_mu_1_7 | zeroTo | high | function zeroTo( n ) {
var arr;
var i;
arr = [];
if ( true ) {
return arr;
}
for ( i = 0; i < n; i++ ) {
arr.push( i );
}
return arr;
}
| zeroTo:\n/**\n* Generates a linearly spaced numeric array whose elements increment by 1 starting from zero.\n*\n* @param {number} n - number of elements\n* @returns {Array<number>} linearly spaced numeric array\n*\n* @example\n* var arr = zeroTo( 6 );\n* // returns [ 0, 1, 2, 3, 4, 5 ]\n*/ | [] | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "None",
"ctors": "None",
"defaults": "None",
"dtype": "None",
"dtypes": "None",
"for... | 8, 'complex128' | [] | [] | 1 | 7 |
zeroTo_mu_1_8 | zeroTo | high | function zeroTo( n ) {
var arr;
var i;
arr = [];
if ( true ) {
return arr;
}
for ( i = 0; i < n; i++ ) {
arr.push( i );
}
return arr;
}
| zeroTo:\n/**\n* Generates a linearly spaced numeric array whose elements increment by 1 starting from zero.\n*\n* @param {number} n - number of elements\n* @returns {Array<number>} linearly spaced numeric array\n*\n* @example\n* var arr = zeroTo( 6 );\n* // returns [ 0, 1, 2, 3, 4, 5 ]\n*/ | [] | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "None",
"ctors": "None",
"defaults": "None",
"dtype": "None",
"dtypes": "None",
"for... | 999999999, 'int32' | [] | [] | 1 | 8 |
zeroTo_mu_1_9 | zeroTo | high | function zeroTo( n ) {
var arr;
var i;
arr = [];
if ( true ) {
return arr;
}
for ( i = 0; i < n; i++ ) {
arr.push( i );
}
return arr;
}
| zeroTo:\n/**\n* Generates a linearly spaced numeric array whose elements increment by 1 starting from zero.\n*\n* @param {number} n - number of elements\n* @returns {Array<number>} linearly spaced numeric array\n*\n* @example\n* var arr = zeroTo( 6 );\n* // returns [ 0, 1, 2, 3, 4, 5 ]\n*/ | [] | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "None",
"ctors": "None",
"defaults": "None",
"dtype": "None",
"dtypes": "None",
"for... | 0, 'int8' | [] | [] | 1 | 9 |
zeroTo_mu_2_0 | zeroTo | high | function zeroTo( n ) {
var arr;
var i;
arr = [];
if ( false ) {
return arr;
}
for ( i = 0; i < n; i++ ) {
arr.push( i );
}
return arr;
}
| zeroTo:\n/**\n* Generates a linearly spaced numeric array whose elements increment by 1 starting from zero.\n*\n* @param {number} n - number of elements\n* @returns {Array<number>} linearly spaced numeric array\n*\n* @example\n* var arr = zeroTo( 6 );\n* // returns [ 0, 1, 2, 3, 4, 5 ]\n*/ | [] | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "None",
"ctors": "None",
"defaults": "None",
"dtype": "None",
"dtypes": "None",
"for... | 0 | [] | [] | 2 | 0 |
zeroTo_mu_2_1 | zeroTo | high | function zeroTo( n ) {
var arr;
var i;
arr = [];
if ( false ) {
return arr;
}
for ( i = 0; i < n; i++ ) {
arr.push( i );
}
return arr;
}
| zeroTo:\n/**\n* Generates a linearly spaced numeric array whose elements increment by 1 starting from zero.\n*\n* @param {number} n - number of elements\n* @returns {Array<number>} linearly spaced numeric array\n*\n* @example\n* var arr = zeroTo( 6 );\n* // returns [ 0, 1, 2, 3, 4, 5 ]\n*/ | [] | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "None",
"ctors": "None",
"defaults": "None",
"dtype": "None",
"dtypes": "None",
"for... | 5 | [] | [ 0, 1, 2, 3, 4 ] | 2 | 1 |
zeroTo_mu_2_2 | zeroTo | high | function zeroTo( n ) {
var arr;
var i;
arr = [];
if ( false ) {
return arr;
}
for ( i = 0; i < n; i++ ) {
arr.push( i );
}
return arr;
}
| zeroTo:\n/**\n* Generates a linearly spaced numeric array whose elements increment by 1 starting from zero.\n*\n* @param {number} n - number of elements\n* @returns {Array<number>} linearly spaced numeric array\n*\n* @example\n* var arr = zeroTo( 6 );\n* // returns [ 0, 1, 2, 3, 4, 5 ]\n*/ | [] | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "None",
"ctors": "None",
"defaults": "None",
"dtype": "None",
"dtypes": "None",
"for... | 1, 'float32' | [] | [ 0 ] | 2 | 2 |
zeroTo_mu_2_3 | zeroTo | high | function zeroTo( n ) {
var arr;
var i;
arr = [];
if ( false ) {
return arr;
}
for ( i = 0; i < n; i++ ) {
arr.push( i );
}
return arr;
}
| zeroTo:\n/**\n* Generates a linearly spaced numeric array whose elements increment by 1 starting from zero.\n*\n* @param {number} n - number of elements\n* @returns {Array<number>} linearly spaced numeric array\n*\n* @example\n* var arr = zeroTo( 6 );\n* // returns [ 0, 1, 2, 3, 4, 5 ]\n*/ | [] | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "None",
"ctors": "None",
"defaults": "None",
"dtype": "None",
"dtypes": "None",
"for... | 10, 'int32' | [] | [
0, 1, 2, 3, 4,
5, 6, 7, 8, 9
] | 2 | 3 |
zeroTo_mu_2_4 | zeroTo | high | function zeroTo( n ) {
var arr;
var i;
arr = [];
if ( false ) {
return arr;
}
for ( i = 0; i < n; i++ ) {
arr.push( i );
}
return arr;
}
| zeroTo:\n/**\n* Generates a linearly spaced numeric array whose elements increment by 1 starting from zero.\n*\n* @param {number} n - number of elements\n* @returns {Array<number>} linearly spaced numeric array\n*\n* @example\n* var arr = zeroTo( 6 );\n* // returns [ 0, 1, 2, 3, 4, 5 ]\n*/ | [] | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "None",
"ctors": "None",
"defaults": "None",
"dtype": "None",
"dtypes": "None",
"for... | 1000000, 'float64' | [] | [
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,
36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59,
60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71,
72, 73, 74, 75, ... | 2 | 4 |
zeroTo_mu_2_5 | zeroTo | high | function zeroTo( n ) {
var arr;
var i;
arr = [];
if ( false ) {
return arr;
}
for ( i = 0; i < n; i++ ) {
arr.push( i );
}
return arr;
}
| zeroTo:\n/**\n* Generates a linearly spaced numeric array whose elements increment by 1 starting from zero.\n*\n* @param {number} n - number of elements\n* @returns {Array<number>} linearly spaced numeric array\n*\n* @example\n* var arr = zeroTo( 6 );\n* // returns [ 0, 1, 2, 3, 4, 5 ]\n*/ | [] | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "None",
"ctors": "None",
"defaults": "None",
"dtype": "None",
"dtypes": "None",
"for... | 3, 'uint8' | [] | [ 0, 1, 2 ] | 2 | 5 |
zeroTo_mu_2_6 | zeroTo | high | function zeroTo( n ) {
var arr;
var i;
arr = [];
if ( false ) {
return arr;
}
for ( i = 0; i < n; i++ ) {
arr.push( i );
}
return arr;
}
| zeroTo:\n/**\n* Generates a linearly spaced numeric array whose elements increment by 1 starting from zero.\n*\n* @param {number} n - number of elements\n* @returns {Array<number>} linearly spaced numeric array\n*\n* @example\n* var arr = zeroTo( 6 );\n* // returns [ 0, 1, 2, 3, 4, 5 ]\n*/ | [] | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "None",
"ctors": "None",
"defaults": "None",
"dtype": "None",
"dtypes": "None",
"for... | 2, 'bool' | [] | [ 0, 1 ] | 2 | 6 |
zeroTo_mu_2_7 | zeroTo | high | function zeroTo( n ) {
var arr;
var i;
arr = [];
if ( false ) {
return arr;
}
for ( i = 0; i < n; i++ ) {
arr.push( i );
}
return arr;
}
| zeroTo:\n/**\n* Generates a linearly spaced numeric array whose elements increment by 1 starting from zero.\n*\n* @param {number} n - number of elements\n* @returns {Array<number>} linearly spaced numeric array\n*\n* @example\n* var arr = zeroTo( 6 );\n* // returns [ 0, 1, 2, 3, 4, 5 ]\n*/ | [] | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "None",
"ctors": "None",
"defaults": "None",
"dtype": "None",
"dtypes": "None",
"for... | 8, 'complex128' | [] | [
0, 1, 2, 3,
4, 5, 6, 7
] | 2 | 7 |
zeroTo_mu_2_8 | zeroTo | high | function zeroTo( n ) {
var arr;
var i;
arr = [];
if ( false ) {
return arr;
}
for ( i = 0; i < n; i++ ) {
arr.push( i );
}
return arr;
}
| zeroTo:\n/**\n* Generates a linearly spaced numeric array whose elements increment by 1 starting from zero.\n*\n* @param {number} n - number of elements\n* @returns {Array<number>} linearly spaced numeric array\n*\n* @example\n* var arr = zeroTo( 6 );\n* // returns [ 0, 1, 2, 3, 4, 5 ]\n*/ | [] | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "None",
"ctors": "None",
"defaults": "None",
"dtype": "None",
"dtypes": "None",
"for... | 999999999, 'int32' | [] | RangeError | 2 | 8 |
zeroTo_mu_2_9 | zeroTo | high | function zeroTo( n ) {
var arr;
var i;
arr = [];
if ( false ) {
return arr;
}
for ( i = 0; i < n; i++ ) {
arr.push( i );
}
return arr;
}
| zeroTo:\n/**\n* Generates a linearly spaced numeric array whose elements increment by 1 starting from zero.\n*\n* @param {number} n - number of elements\n* @returns {Array<number>} linearly spaced numeric array\n*\n* @example\n* var arr = zeroTo( 6 );\n* // returns [ 0, 1, 2, 3, 4, 5 ]\n*/ | [] | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "None",
"ctors": "None",
"defaults": "None",
"dtype": "None",
"dtypes": "None",
"for... | 0, 'int8' | [] | [] | 2 | 9 |
zeroTo_mu_3_0 | zeroTo | high | function zeroTo( n ) {
var arr;
var i;
arr = [];
if ( n > 0 ) {
return arr;
}
for ( i = 0; i < n; i++ ) {
arr.push( i );
}
return arr;
}
| zeroTo:\n/**\n* Generates a linearly spaced numeric array whose elements increment by 1 starting from zero.\n*\n* @param {number} n - number of elements\n* @returns {Array<number>} linearly spaced numeric array\n*\n* @example\n* var arr = zeroTo( 6 );\n* // returns [ 0, 1, 2, 3, 4, 5 ]\n*/ | [] | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "None",
"ctors": "None",
"defaults": "None",
"dtype": "None",
"dtypes": "None",
"for... | 0 | [] | [] | 3 | 0 |
zeroTo_mu_3_1 | zeroTo | high | function zeroTo( n ) {
var arr;
var i;
arr = [];
if ( n > 0 ) {
return arr;
}
for ( i = 0; i < n; i++ ) {
arr.push( i );
}
return arr;
}
| zeroTo:\n/**\n* Generates a linearly spaced numeric array whose elements increment by 1 starting from zero.\n*\n* @param {number} n - number of elements\n* @returns {Array<number>} linearly spaced numeric array\n*\n* @example\n* var arr = zeroTo( 6 );\n* // returns [ 0, 1, 2, 3, 4, 5 ]\n*/ | [] | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "None",
"ctors": "None",
"defaults": "None",
"dtype": "None",
"dtypes": "None",
"for... | 5 | [] | [] | 3 | 1 |
zeroTo_mu_3_2 | zeroTo | high | function zeroTo( n ) {
var arr;
var i;
arr = [];
if ( n > 0 ) {
return arr;
}
for ( i = 0; i < n; i++ ) {
arr.push( i );
}
return arr;
}
| zeroTo:\n/**\n* Generates a linearly spaced numeric array whose elements increment by 1 starting from zero.\n*\n* @param {number} n - number of elements\n* @returns {Array<number>} linearly spaced numeric array\n*\n* @example\n* var arr = zeroTo( 6 );\n* // returns [ 0, 1, 2, 3, 4, 5 ]\n*/ | [] | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "None",
"ctors": "None",
"defaults": "None",
"dtype": "None",
"dtypes": "None",
"for... | 1, 'float32' | [] | [] | 3 | 2 |
zeroTo_mu_3_3 | zeroTo | high | function zeroTo( n ) {
var arr;
var i;
arr = [];
if ( n > 0 ) {
return arr;
}
for ( i = 0; i < n; i++ ) {
arr.push( i );
}
return arr;
}
| zeroTo:\n/**\n* Generates a linearly spaced numeric array whose elements increment by 1 starting from zero.\n*\n* @param {number} n - number of elements\n* @returns {Array<number>} linearly spaced numeric array\n*\n* @example\n* var arr = zeroTo( 6 );\n* // returns [ 0, 1, 2, 3, 4, 5 ]\n*/ | [] | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "None",
"ctors": "None",
"defaults": "None",
"dtype": "None",
"dtypes": "None",
"for... | 10, 'int32' | [] | [] | 3 | 3 |
zeroTo_mu_3_4 | zeroTo | high | function zeroTo( n ) {
var arr;
var i;
arr = [];
if ( n > 0 ) {
return arr;
}
for ( i = 0; i < n; i++ ) {
arr.push( i );
}
return arr;
}
| zeroTo:\n/**\n* Generates a linearly spaced numeric array whose elements increment by 1 starting from zero.\n*\n* @param {number} n - number of elements\n* @returns {Array<number>} linearly spaced numeric array\n*\n* @example\n* var arr = zeroTo( 6 );\n* // returns [ 0, 1, 2, 3, 4, 5 ]\n*/ | [] | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "None",
"ctors": "None",
"defaults": "None",
"dtype": "None",
"dtypes": "None",
"for... | 1000000, 'float64' | [] | [] | 3 | 4 |
zeroTo_mu_3_5 | zeroTo | high | function zeroTo( n ) {
var arr;
var i;
arr = [];
if ( n > 0 ) {
return arr;
}
for ( i = 0; i < n; i++ ) {
arr.push( i );
}
return arr;
}
| zeroTo:\n/**\n* Generates a linearly spaced numeric array whose elements increment by 1 starting from zero.\n*\n* @param {number} n - number of elements\n* @returns {Array<number>} linearly spaced numeric array\n*\n* @example\n* var arr = zeroTo( 6 );\n* // returns [ 0, 1, 2, 3, 4, 5 ]\n*/ | [] | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "None",
"ctors": "None",
"defaults": "None",
"dtype": "None",
"dtypes": "None",
"for... | 3, 'uint8' | [] | [] | 3 | 5 |
zeroTo_mu_3_6 | zeroTo | high | function zeroTo( n ) {
var arr;
var i;
arr = [];
if ( n > 0 ) {
return arr;
}
for ( i = 0; i < n; i++ ) {
arr.push( i );
}
return arr;
}
| zeroTo:\n/**\n* Generates a linearly spaced numeric array whose elements increment by 1 starting from zero.\n*\n* @param {number} n - number of elements\n* @returns {Array<number>} linearly spaced numeric array\n*\n* @example\n* var arr = zeroTo( 6 );\n* // returns [ 0, 1, 2, 3, 4, 5 ]\n*/ | [] | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "None",
"ctors": "None",
"defaults": "None",
"dtype": "None",
"dtypes": "None",
"for... | 2, 'bool' | [] | [] | 3 | 6 |
zeroTo_mu_3_7 | zeroTo | high | function zeroTo( n ) {
var arr;
var i;
arr = [];
if ( n > 0 ) {
return arr;
}
for ( i = 0; i < n; i++ ) {
arr.push( i );
}
return arr;
}
| zeroTo:\n/**\n* Generates a linearly spaced numeric array whose elements increment by 1 starting from zero.\n*\n* @param {number} n - number of elements\n* @returns {Array<number>} linearly spaced numeric array\n*\n* @example\n* var arr = zeroTo( 6 );\n* // returns [ 0, 1, 2, 3, 4, 5 ]\n*/ | [] | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "None",
"ctors": "None",
"defaults": "None",
"dtype": "None",
"dtypes": "None",
"for... | 8, 'complex128' | [] | [] | 3 | 7 |
zeroTo_mu_3_8 | zeroTo | high | function zeroTo( n ) {
var arr;
var i;
arr = [];
if ( n > 0 ) {
return arr;
}
for ( i = 0; i < n; i++ ) {
arr.push( i );
}
return arr;
}
| zeroTo:\n/**\n* Generates a linearly spaced numeric array whose elements increment by 1 starting from zero.\n*\n* @param {number} n - number of elements\n* @returns {Array<number>} linearly spaced numeric array\n*\n* @example\n* var arr = zeroTo( 6 );\n* // returns [ 0, 1, 2, 3, 4, 5 ]\n*/ | [] | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "None",
"ctors": "None",
"defaults": "None",
"dtype": "None",
"dtypes": "None",
"for... | 999999999, 'int32' | [] | [] | 3 | 8 |
zeroTo_mu_3_9 | zeroTo | high | function zeroTo( n ) {
var arr;
var i;
arr = [];
if ( n > 0 ) {
return arr;
}
for ( i = 0; i < n; i++ ) {
arr.push( i );
}
return arr;
}
| zeroTo:\n/**\n* Generates a linearly spaced numeric array whose elements increment by 1 starting from zero.\n*\n* @param {number} n - number of elements\n* @returns {Array<number>} linearly spaced numeric array\n*\n* @example\n* var arr = zeroTo( 6 );\n* // returns [ 0, 1, 2, 3, 4, 5 ]\n*/ | [] | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "None",
"ctors": "None",
"defaults": "None",
"dtype": "None",
"dtypes": "None",
"for... | 0, 'int8' | [] | [] | 3 | 9 |
zeroTo_mu_4_0 | zeroTo | high | function zeroTo( n ) {
var arr;
var i;
arr = [];
if ( n < 0 ) {
return arr;
}
for ( i = 0; i < n; i++ ) {
arr.push( i );
}
return arr;
}
| zeroTo:\n/**\n* Generates a linearly spaced numeric array whose elements increment by 1 starting from zero.\n*\n* @param {number} n - number of elements\n* @returns {Array<number>} linearly spaced numeric array\n*\n* @example\n* var arr = zeroTo( 6 );\n* // returns [ 0, 1, 2, 3, 4, 5 ]\n*/ | [] | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "None",
"ctors": "None",
"defaults": "None",
"dtype": "None",
"dtypes": "None",
"for... | 0 | [] | [] | 4 | 0 |
zeroTo_mu_4_1 | zeroTo | high | function zeroTo( n ) {
var arr;
var i;
arr = [];
if ( n < 0 ) {
return arr;
}
for ( i = 0; i < n; i++ ) {
arr.push( i );
}
return arr;
}
| zeroTo:\n/**\n* Generates a linearly spaced numeric array whose elements increment by 1 starting from zero.\n*\n* @param {number} n - number of elements\n* @returns {Array<number>} linearly spaced numeric array\n*\n* @example\n* var arr = zeroTo( 6 );\n* // returns [ 0, 1, 2, 3, 4, 5 ]\n*/ | [] | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "None",
"ctors": "None",
"defaults": "None",
"dtype": "None",
"dtypes": "None",
"for... | 5 | [] | [ 0, 1, 2, 3, 4 ] | 4 | 1 |
zeroTo_mu_4_2 | zeroTo | high | function zeroTo( n ) {
var arr;
var i;
arr = [];
if ( n < 0 ) {
return arr;
}
for ( i = 0; i < n; i++ ) {
arr.push( i );
}
return arr;
}
| zeroTo:\n/**\n* Generates a linearly spaced numeric array whose elements increment by 1 starting from zero.\n*\n* @param {number} n - number of elements\n* @returns {Array<number>} linearly spaced numeric array\n*\n* @example\n* var arr = zeroTo( 6 );\n* // returns [ 0, 1, 2, 3, 4, 5 ]\n*/ | [] | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "None",
"ctors": "None",
"defaults": "None",
"dtype": "None",
"dtypes": "None",
"for... | 1, 'float32' | [] | [ 0 ] | 4 | 2 |
zeroTo_mu_4_3 | zeroTo | high | function zeroTo( n ) {
var arr;
var i;
arr = [];
if ( n < 0 ) {
return arr;
}
for ( i = 0; i < n; i++ ) {
arr.push( i );
}
return arr;
}
| zeroTo:\n/**\n* Generates a linearly spaced numeric array whose elements increment by 1 starting from zero.\n*\n* @param {number} n - number of elements\n* @returns {Array<number>} linearly spaced numeric array\n*\n* @example\n* var arr = zeroTo( 6 );\n* // returns [ 0, 1, 2, 3, 4, 5 ]\n*/ | [] | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "None",
"ctors": "None",
"defaults": "None",
"dtype": "None",
"dtypes": "None",
"for... | 10, 'int32' | [] | [
0, 1, 2, 3, 4,
5, 6, 7, 8, 9
] | 4 | 3 |
zeroTo_mu_4_4 | zeroTo | high | function zeroTo( n ) {
var arr;
var i;
arr = [];
if ( n < 0 ) {
return arr;
}
for ( i = 0; i < n; i++ ) {
arr.push( i );
}
return arr;
}
| zeroTo:\n/**\n* Generates a linearly spaced numeric array whose elements increment by 1 starting from zero.\n*\n* @param {number} n - number of elements\n* @returns {Array<number>} linearly spaced numeric array\n*\n* @example\n* var arr = zeroTo( 6 );\n* // returns [ 0, 1, 2, 3, 4, 5 ]\n*/ | [] | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "None",
"ctors": "None",
"defaults": "None",
"dtype": "None",
"dtypes": "None",
"for... | 1000000, 'float64' | [] | [
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,
36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59,
60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71,
72, 73, 74, 75, ... | 4 | 4 |
zeroTo_mu_4_5 | zeroTo | high | function zeroTo( n ) {
var arr;
var i;
arr = [];
if ( n < 0 ) {
return arr;
}
for ( i = 0; i < n; i++ ) {
arr.push( i );
}
return arr;
}
| zeroTo:\n/**\n* Generates a linearly spaced numeric array whose elements increment by 1 starting from zero.\n*\n* @param {number} n - number of elements\n* @returns {Array<number>} linearly spaced numeric array\n*\n* @example\n* var arr = zeroTo( 6 );\n* // returns [ 0, 1, 2, 3, 4, 5 ]\n*/ | [] | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "None",
"ctors": "None",
"defaults": "None",
"dtype": "None",
"dtypes": "None",
"for... | 3, 'uint8' | [] | [ 0, 1, 2 ] | 4 | 5 |
zeroTo_mu_4_6 | zeroTo | high | function zeroTo( n ) {
var arr;
var i;
arr = [];
if ( n < 0 ) {
return arr;
}
for ( i = 0; i < n; i++ ) {
arr.push( i );
}
return arr;
}
| zeroTo:\n/**\n* Generates a linearly spaced numeric array whose elements increment by 1 starting from zero.\n*\n* @param {number} n - number of elements\n* @returns {Array<number>} linearly spaced numeric array\n*\n* @example\n* var arr = zeroTo( 6 );\n* // returns [ 0, 1, 2, 3, 4, 5 ]\n*/ | [] | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "None",
"ctors": "None",
"defaults": "None",
"dtype": "None",
"dtypes": "None",
"for... | 2, 'bool' | [] | [ 0, 1 ] | 4 | 6 |
zeroTo_mu_4_7 | zeroTo | high | function zeroTo( n ) {
var arr;
var i;
arr = [];
if ( n < 0 ) {
return arr;
}
for ( i = 0; i < n; i++ ) {
arr.push( i );
}
return arr;
}
| zeroTo:\n/**\n* Generates a linearly spaced numeric array whose elements increment by 1 starting from zero.\n*\n* @param {number} n - number of elements\n* @returns {Array<number>} linearly spaced numeric array\n*\n* @example\n* var arr = zeroTo( 6 );\n* // returns [ 0, 1, 2, 3, 4, 5 ]\n*/ | [] | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "None",
"ctors": "None",
"defaults": "None",
"dtype": "None",
"dtypes": "None",
"for... | 8, 'complex128' | [] | [
0, 1, 2, 3,
4, 5, 6, 7
] | 4 | 7 |
zeroTo_mu_4_8 | zeroTo | high | function zeroTo( n ) {
var arr;
var i;
arr = [];
if ( n < 0 ) {
return arr;
}
for ( i = 0; i < n; i++ ) {
arr.push( i );
}
return arr;
}
| zeroTo:\n/**\n* Generates a linearly spaced numeric array whose elements increment by 1 starting from zero.\n*\n* @param {number} n - number of elements\n* @returns {Array<number>} linearly spaced numeric array\n*\n* @example\n* var arr = zeroTo( 6 );\n* // returns [ 0, 1, 2, 3, 4, 5 ]\n*/ | [] | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "None",
"ctors": "None",
"defaults": "None",
"dtype": "None",
"dtypes": "None",
"for... | 999999999, 'int32' | [] | RangeError | 4 | 8 |
zeroTo_mu_4_9 | zeroTo | high | function zeroTo( n ) {
var arr;
var i;
arr = [];
if ( n < 0 ) {
return arr;
}
for ( i = 0; i < n; i++ ) {
arr.push( i );
}
return arr;
}
| zeroTo:\n/**\n* Generates a linearly spaced numeric array whose elements increment by 1 starting from zero.\n*\n* @param {number} n - number of elements\n* @returns {Array<number>} linearly spaced numeric array\n*\n* @example\n* var arr = zeroTo( 6 );\n* // returns [ 0, 1, 2, 3, 4, 5 ]\n*/ | [] | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "None",
"ctors": "None",
"defaults": "None",
"dtype": "None",
"dtypes": "None",
"for... | 0, 'int8' | [] | [] | 4 | 9 |
zeroTo_mu_5_0 | zeroTo | high | function zeroTo( n ) {
var arr;
var i;
arr = [];
if ( n <= 0 ) {
return arr;
}
for ( i = 0; false; i++ ) {
arr.push( i );
}
return arr;
}
| zeroTo:\n/**\n* Generates a linearly spaced numeric array whose elements increment by 1 starting from zero.\n*\n* @param {number} n - number of elements\n* @returns {Array<number>} linearly spaced numeric array\n*\n* @example\n* var arr = zeroTo( 6 );\n* // returns [ 0, 1, 2, 3, 4, 5 ]\n*/ | [] | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "None",
"ctors": "None",
"defaults": "None",
"dtype": "None",
"dtypes": "None",
"for... | 0 | [] | [] | 5 | 0 |
zeroTo_mu_5_1 | zeroTo | high | function zeroTo( n ) {
var arr;
var i;
arr = [];
if ( n <= 0 ) {
return arr;
}
for ( i = 0; false; i++ ) {
arr.push( i );
}
return arr;
}
| zeroTo:\n/**\n* Generates a linearly spaced numeric array whose elements increment by 1 starting from zero.\n*\n* @param {number} n - number of elements\n* @returns {Array<number>} linearly spaced numeric array\n*\n* @example\n* var arr = zeroTo( 6 );\n* // returns [ 0, 1, 2, 3, 4, 5 ]\n*/ | [] | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "None",
"ctors": "None",
"defaults": "None",
"dtype": "None",
"dtypes": "None",
"for... | 5 | [] | [] | 5 | 1 |
zeroTo_mu_5_2 | zeroTo | high | function zeroTo( n ) {
var arr;
var i;
arr = [];
if ( n <= 0 ) {
return arr;
}
for ( i = 0; false; i++ ) {
arr.push( i );
}
return arr;
}
| zeroTo:\n/**\n* Generates a linearly spaced numeric array whose elements increment by 1 starting from zero.\n*\n* @param {number} n - number of elements\n* @returns {Array<number>} linearly spaced numeric array\n*\n* @example\n* var arr = zeroTo( 6 );\n* // returns [ 0, 1, 2, 3, 4, 5 ]\n*/ | [] | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "None",
"ctors": "None",
"defaults": "None",
"dtype": "None",
"dtypes": "None",
"for... | 1, 'float32' | [] | [] | 5 | 2 |
zeroTo_mu_5_3 | zeroTo | high | function zeroTo( n ) {
var arr;
var i;
arr = [];
if ( n <= 0 ) {
return arr;
}
for ( i = 0; false; i++ ) {
arr.push( i );
}
return arr;
}
| zeroTo:\n/**\n* Generates a linearly spaced numeric array whose elements increment by 1 starting from zero.\n*\n* @param {number} n - number of elements\n* @returns {Array<number>} linearly spaced numeric array\n*\n* @example\n* var arr = zeroTo( 6 );\n* // returns [ 0, 1, 2, 3, 4, 5 ]\n*/ | [] | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "None",
"ctors": "None",
"defaults": "None",
"dtype": "None",
"dtypes": "None",
"for... | 10, 'int32' | [] | [] | 5 | 3 |
zeroTo_mu_5_4 | zeroTo | high | function zeroTo( n ) {
var arr;
var i;
arr = [];
if ( n <= 0 ) {
return arr;
}
for ( i = 0; false; i++ ) {
arr.push( i );
}
return arr;
}
| zeroTo:\n/**\n* Generates a linearly spaced numeric array whose elements increment by 1 starting from zero.\n*\n* @param {number} n - number of elements\n* @returns {Array<number>} linearly spaced numeric array\n*\n* @example\n* var arr = zeroTo( 6 );\n* // returns [ 0, 1, 2, 3, 4, 5 ]\n*/ | [] | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "None",
"ctors": "None",
"defaults": "None",
"dtype": "None",
"dtypes": "None",
"for... | 1000000, 'float64' | [] | [] | 5 | 4 |
zeroTo_mu_5_5 | zeroTo | high | function zeroTo( n ) {
var arr;
var i;
arr = [];
if ( n <= 0 ) {
return arr;
}
for ( i = 0; false; i++ ) {
arr.push( i );
}
return arr;
}
| zeroTo:\n/**\n* Generates a linearly spaced numeric array whose elements increment by 1 starting from zero.\n*\n* @param {number} n - number of elements\n* @returns {Array<number>} linearly spaced numeric array\n*\n* @example\n* var arr = zeroTo( 6 );\n* // returns [ 0, 1, 2, 3, 4, 5 ]\n*/ | [] | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "None",
"ctors": "None",
"defaults": "None",
"dtype": "None",
"dtypes": "None",
"for... | 3, 'uint8' | [] | [] | 5 | 5 |
zeroTo_mu_5_6 | zeroTo | high | function zeroTo( n ) {
var arr;
var i;
arr = [];
if ( n <= 0 ) {
return arr;
}
for ( i = 0; false; i++ ) {
arr.push( i );
}
return arr;
}
| zeroTo:\n/**\n* Generates a linearly spaced numeric array whose elements increment by 1 starting from zero.\n*\n* @param {number} n - number of elements\n* @returns {Array<number>} linearly spaced numeric array\n*\n* @example\n* var arr = zeroTo( 6 );\n* // returns [ 0, 1, 2, 3, 4, 5 ]\n*/ | [] | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "None",
"ctors": "None",
"defaults": "None",
"dtype": "None",
"dtypes": "None",
"for... | 2, 'bool' | [] | [] | 5 | 6 |
zeroTo_mu_5_7 | zeroTo | high | function zeroTo( n ) {
var arr;
var i;
arr = [];
if ( n <= 0 ) {
return arr;
}
for ( i = 0; false; i++ ) {
arr.push( i );
}
return arr;
}
| zeroTo:\n/**\n* Generates a linearly spaced numeric array whose elements increment by 1 starting from zero.\n*\n* @param {number} n - number of elements\n* @returns {Array<number>} linearly spaced numeric array\n*\n* @example\n* var arr = zeroTo( 6 );\n* // returns [ 0, 1, 2, 3, 4, 5 ]\n*/ | [] | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "None",
"ctors": "None",
"defaults": "None",
"dtype": "None",
"dtypes": "None",
"for... | 8, 'complex128' | [] | [] | 5 | 7 |
zeroTo_mu_5_8 | zeroTo | high | function zeroTo( n ) {
var arr;
var i;
arr = [];
if ( n <= 0 ) {
return arr;
}
for ( i = 0; false; i++ ) {
arr.push( i );
}
return arr;
}
| zeroTo:\n/**\n* Generates a linearly spaced numeric array whose elements increment by 1 starting from zero.\n*\n* @param {number} n - number of elements\n* @returns {Array<number>} linearly spaced numeric array\n*\n* @example\n* var arr = zeroTo( 6 );\n* // returns [ 0, 1, 2, 3, 4, 5 ]\n*/ | [] | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "None",
"ctors": "None",
"defaults": "None",
"dtype": "None",
"dtypes": "None",
"for... | 999999999, 'int32' | [] | [] | 5 | 8 |
zeroTo_mu_5_9 | zeroTo | high | function zeroTo( n ) {
var arr;
var i;
arr = [];
if ( n <= 0 ) {
return arr;
}
for ( i = 0; false; i++ ) {
arr.push( i );
}
return arr;
}
| zeroTo:\n/**\n* Generates a linearly spaced numeric array whose elements increment by 1 starting from zero.\n*\n* @param {number} n - number of elements\n* @returns {Array<number>} linearly spaced numeric array\n*\n* @example\n* var arr = zeroTo( 6 );\n* // returns [ 0, 1, 2, 3, 4, 5 ]\n*/ | [] | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "None",
"ctors": "None",
"defaults": "None",
"dtype": "None",
"dtypes": "None",
"for... | 0, 'int8' | [] | [] | 5 | 9 |
zeroTo_mu_6_0 | zeroTo | high | function zeroTo( n ) {
var arr;
var i;
arr = [];
if ( n <= 0 ) {
return arr;
}
for ( i = 0; i >= n; i++ ) {
arr.push( i );
}
return arr;
}
| zeroTo:\n/**\n* Generates a linearly spaced numeric array whose elements increment by 1 starting from zero.\n*\n* @param {number} n - number of elements\n* @returns {Array<number>} linearly spaced numeric array\n*\n* @example\n* var arr = zeroTo( 6 );\n* // returns [ 0, 1, 2, 3, 4, 5 ]\n*/ | [] | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "None",
"ctors": "None",
"defaults": "None",
"dtype": "None",
"dtypes": "None",
"for... | 0 | [] | [] | 6 | 0 |
zeroTo_mu_6_1 | zeroTo | high | function zeroTo( n ) {
var arr;
var i;
arr = [];
if ( n <= 0 ) {
return arr;
}
for ( i = 0; i >= n; i++ ) {
arr.push( i );
}
return arr;
}
| zeroTo:\n/**\n* Generates a linearly spaced numeric array whose elements increment by 1 starting from zero.\n*\n* @param {number} n - number of elements\n* @returns {Array<number>} linearly spaced numeric array\n*\n* @example\n* var arr = zeroTo( 6 );\n* // returns [ 0, 1, 2, 3, 4, 5 ]\n*/ | [] | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "None",
"ctors": "None",
"defaults": "None",
"dtype": "None",
"dtypes": "None",
"for... | 5 | [] | [] | 6 | 1 |
zeroTo_mu_6_2 | zeroTo | high | function zeroTo( n ) {
var arr;
var i;
arr = [];
if ( n <= 0 ) {
return arr;
}
for ( i = 0; i >= n; i++ ) {
arr.push( i );
}
return arr;
}
| zeroTo:\n/**\n* Generates a linearly spaced numeric array whose elements increment by 1 starting from zero.\n*\n* @param {number} n - number of elements\n* @returns {Array<number>} linearly spaced numeric array\n*\n* @example\n* var arr = zeroTo( 6 );\n* // returns [ 0, 1, 2, 3, 4, 5 ]\n*/ | [] | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "None",
"ctors": "None",
"defaults": "None",
"dtype": "None",
"dtypes": "None",
"for... | 1, 'float32' | [] | [] | 6 | 2 |
zeroTo_mu_6_3 | zeroTo | high | function zeroTo( n ) {
var arr;
var i;
arr = [];
if ( n <= 0 ) {
return arr;
}
for ( i = 0; i >= n; i++ ) {
arr.push( i );
}
return arr;
}
| zeroTo:\n/**\n* Generates a linearly spaced numeric array whose elements increment by 1 starting from zero.\n*\n* @param {number} n - number of elements\n* @returns {Array<number>} linearly spaced numeric array\n*\n* @example\n* var arr = zeroTo( 6 );\n* // returns [ 0, 1, 2, 3, 4, 5 ]\n*/ | [] | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "None",
"ctors": "None",
"defaults": "None",
"dtype": "None",
"dtypes": "None",
"for... | 10, 'int32' | [] | [] | 6 | 3 |
zeroTo_mu_6_4 | zeroTo | high | function zeroTo( n ) {
var arr;
var i;
arr = [];
if ( n <= 0 ) {
return arr;
}
for ( i = 0; i >= n; i++ ) {
arr.push( i );
}
return arr;
}
| zeroTo:\n/**\n* Generates a linearly spaced numeric array whose elements increment by 1 starting from zero.\n*\n* @param {number} n - number of elements\n* @returns {Array<number>} linearly spaced numeric array\n*\n* @example\n* var arr = zeroTo( 6 );\n* // returns [ 0, 1, 2, 3, 4, 5 ]\n*/ | [] | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "None",
"ctors": "None",
"defaults": "None",
"dtype": "None",
"dtypes": "None",
"for... | 1000000, 'float64' | [] | [] | 6 | 4 |
zeroTo_mu_6_5 | zeroTo | high | function zeroTo( n ) {
var arr;
var i;
arr = [];
if ( n <= 0 ) {
return arr;
}
for ( i = 0; i >= n; i++ ) {
arr.push( i );
}
return arr;
}
| zeroTo:\n/**\n* Generates a linearly spaced numeric array whose elements increment by 1 starting from zero.\n*\n* @param {number} n - number of elements\n* @returns {Array<number>} linearly spaced numeric array\n*\n* @example\n* var arr = zeroTo( 6 );\n* // returns [ 0, 1, 2, 3, 4, 5 ]\n*/ | [] | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "None",
"ctors": "None",
"defaults": "None",
"dtype": "None",
"dtypes": "None",
"for... | 3, 'uint8' | [] | [] | 6 | 5 |
zeroTo_mu_6_6 | zeroTo | high | function zeroTo( n ) {
var arr;
var i;
arr = [];
if ( n <= 0 ) {
return arr;
}
for ( i = 0; i >= n; i++ ) {
arr.push( i );
}
return arr;
}
| zeroTo:\n/**\n* Generates a linearly spaced numeric array whose elements increment by 1 starting from zero.\n*\n* @param {number} n - number of elements\n* @returns {Array<number>} linearly spaced numeric array\n*\n* @example\n* var arr = zeroTo( 6 );\n* // returns [ 0, 1, 2, 3, 4, 5 ]\n*/ | [] | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "None",
"ctors": "None",
"defaults": "None",
"dtype": "None",
"dtypes": "None",
"for... | 2, 'bool' | [] | [] | 6 | 6 |
zeroTo_mu_6_7 | zeroTo | high | function zeroTo( n ) {
var arr;
var i;
arr = [];
if ( n <= 0 ) {
return arr;
}
for ( i = 0; i >= n; i++ ) {
arr.push( i );
}
return arr;
}
| zeroTo:\n/**\n* Generates a linearly spaced numeric array whose elements increment by 1 starting from zero.\n*\n* @param {number} n - number of elements\n* @returns {Array<number>} linearly spaced numeric array\n*\n* @example\n* var arr = zeroTo( 6 );\n* // returns [ 0, 1, 2, 3, 4, 5 ]\n*/ | [] | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "None",
"ctors": "None",
"defaults": "None",
"dtype": "None",
"dtypes": "None",
"for... | 8, 'complex128' | [] | [] | 6 | 7 |
zeroTo_mu_6_8 | zeroTo | high | function zeroTo( n ) {
var arr;
var i;
arr = [];
if ( n <= 0 ) {
return arr;
}
for ( i = 0; i >= n; i++ ) {
arr.push( i );
}
return arr;
}
| zeroTo:\n/**\n* Generates a linearly spaced numeric array whose elements increment by 1 starting from zero.\n*\n* @param {number} n - number of elements\n* @returns {Array<number>} linearly spaced numeric array\n*\n* @example\n* var arr = zeroTo( 6 );\n* // returns [ 0, 1, 2, 3, 4, 5 ]\n*/ | [] | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "None",
"ctors": "None",
"defaults": "None",
"dtype": "None",
"dtypes": "None",
"for... | 999999999, 'int32' | [] | [] | 6 | 8 |
zeroTo_mu_6_9 | zeroTo | high | function zeroTo( n ) {
var arr;
var i;
arr = [];
if ( n <= 0 ) {
return arr;
}
for ( i = 0; i >= n; i++ ) {
arr.push( i );
}
return arr;
}
| zeroTo:\n/**\n* Generates a linearly spaced numeric array whose elements increment by 1 starting from zero.\n*\n* @param {number} n - number of elements\n* @returns {Array<number>} linearly spaced numeric array\n*\n* @example\n* var arr = zeroTo( 6 );\n* // returns [ 0, 1, 2, 3, 4, 5 ]\n*/ | [] | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "None",
"ctors": "None",
"defaults": "None",
"dtype": "None",
"dtypes": "None",
"for... | 0, 'int8' | [] | [] | 6 | 9 |
zeroTo_mu_7_0 | zeroTo | high | function zeroTo( n ) {
var arr;
var i;
arr = [];
if ( n <= 0 ) {
return arr;
}
for ( i = 0; i <= n; i++ ) {
arr.push( i );
}
return arr;
}
| zeroTo:\n/**\n* Generates a linearly spaced numeric array whose elements increment by 1 starting from zero.\n*\n* @param {number} n - number of elements\n* @returns {Array<number>} linearly spaced numeric array\n*\n* @example\n* var arr = zeroTo( 6 );\n* // returns [ 0, 1, 2, 3, 4, 5 ]\n*/ | [] | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "None",
"ctors": "None",
"defaults": "None",
"dtype": "None",
"dtypes": "None",
"for... | 0 | [] | [] | 7 | 0 |
zeroTo_mu_7_1 | zeroTo | high | function zeroTo( n ) {
var arr;
var i;
arr = [];
if ( n <= 0 ) {
return arr;
}
for ( i = 0; i <= n; i++ ) {
arr.push( i );
}
return arr;
}
| zeroTo:\n/**\n* Generates a linearly spaced numeric array whose elements increment by 1 starting from zero.\n*\n* @param {number} n - number of elements\n* @returns {Array<number>} linearly spaced numeric array\n*\n* @example\n* var arr = zeroTo( 6 );\n* // returns [ 0, 1, 2, 3, 4, 5 ]\n*/ | [] | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "None",
"ctors": "None",
"defaults": "None",
"dtype": "None",
"dtypes": "None",
"for... | 5 | [] | [ 0, 1, 2, 3, 4, 5 ] | 7 | 1 |
zeroTo_mu_7_2 | zeroTo | high | function zeroTo( n ) {
var arr;
var i;
arr = [];
if ( n <= 0 ) {
return arr;
}
for ( i = 0; i <= n; i++ ) {
arr.push( i );
}
return arr;
}
| zeroTo:\n/**\n* Generates a linearly spaced numeric array whose elements increment by 1 starting from zero.\n*\n* @param {number} n - number of elements\n* @returns {Array<number>} linearly spaced numeric array\n*\n* @example\n* var arr = zeroTo( 6 );\n* // returns [ 0, 1, 2, 3, 4, 5 ]\n*/ | [] | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "None",
"ctors": "None",
"defaults": "None",
"dtype": "None",
"dtypes": "None",
"for... | 1, 'float32' | [] | [ 0, 1 ] | 7 | 2 |
zeroTo_mu_7_3 | zeroTo | high | function zeroTo( n ) {
var arr;
var i;
arr = [];
if ( n <= 0 ) {
return arr;
}
for ( i = 0; i <= n; i++ ) {
arr.push( i );
}
return arr;
}
| zeroTo:\n/**\n* Generates a linearly spaced numeric array whose elements increment by 1 starting from zero.\n*\n* @param {number} n - number of elements\n* @returns {Array<number>} linearly spaced numeric array\n*\n* @example\n* var arr = zeroTo( 6 );\n* // returns [ 0, 1, 2, 3, 4, 5 ]\n*/ | [] | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "None",
"ctors": "None",
"defaults": "None",
"dtype": "None",
"dtypes": "None",
"for... | 10, 'int32' | [] | [
0, 1, 2, 3, 4,
5, 6, 7, 8, 9,
10
] | 7 | 3 |
zeroTo_mu_7_4 | zeroTo | high | function zeroTo( n ) {
var arr;
var i;
arr = [];
if ( n <= 0 ) {
return arr;
}
for ( i = 0; i <= n; i++ ) {
arr.push( i );
}
return arr;
}
| zeroTo:\n/**\n* Generates a linearly spaced numeric array whose elements increment by 1 starting from zero.\n*\n* @param {number} n - number of elements\n* @returns {Array<number>} linearly spaced numeric array\n*\n* @example\n* var arr = zeroTo( 6 );\n* // returns [ 0, 1, 2, 3, 4, 5 ]\n*/ | [] | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "None",
"ctors": "None",
"defaults": "None",
"dtype": "None",
"dtypes": "None",
"for... | 1000000, 'float64' | [] | [
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,
36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59,
60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71,
72, 73, 74, 75, ... | 7 | 4 |
zeroTo_mu_7_5 | zeroTo | high | function zeroTo( n ) {
var arr;
var i;
arr = [];
if ( n <= 0 ) {
return arr;
}
for ( i = 0; i <= n; i++ ) {
arr.push( i );
}
return arr;
}
| zeroTo:\n/**\n* Generates a linearly spaced numeric array whose elements increment by 1 starting from zero.\n*\n* @param {number} n - number of elements\n* @returns {Array<number>} linearly spaced numeric array\n*\n* @example\n* var arr = zeroTo( 6 );\n* // returns [ 0, 1, 2, 3, 4, 5 ]\n*/ | [] | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "None",
"ctors": "None",
"defaults": "None",
"dtype": "None",
"dtypes": "None",
"for... | 3, 'uint8' | [] | [ 0, 1, 2, 3 ] | 7 | 5 |
zeroTo_mu_7_6 | zeroTo | high | function zeroTo( n ) {
var arr;
var i;
arr = [];
if ( n <= 0 ) {
return arr;
}
for ( i = 0; i <= n; i++ ) {
arr.push( i );
}
return arr;
}
| zeroTo:\n/**\n* Generates a linearly spaced numeric array whose elements increment by 1 starting from zero.\n*\n* @param {number} n - number of elements\n* @returns {Array<number>} linearly spaced numeric array\n*\n* @example\n* var arr = zeroTo( 6 );\n* // returns [ 0, 1, 2, 3, 4, 5 ]\n*/ | [] | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "None",
"ctors": "None",
"defaults": "None",
"dtype": "None",
"dtypes": "None",
"for... | 2, 'bool' | [] | [ 0, 1, 2 ] | 7 | 6 |
zeroTo_mu_7_7 | zeroTo | high | function zeroTo( n ) {
var arr;
var i;
arr = [];
if ( n <= 0 ) {
return arr;
}
for ( i = 0; i <= n; i++ ) {
arr.push( i );
}
return arr;
}
| zeroTo:\n/**\n* Generates a linearly spaced numeric array whose elements increment by 1 starting from zero.\n*\n* @param {number} n - number of elements\n* @returns {Array<number>} linearly spaced numeric array\n*\n* @example\n* var arr = zeroTo( 6 );\n* // returns [ 0, 1, 2, 3, 4, 5 ]\n*/ | [] | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "None",
"ctors": "None",
"defaults": "None",
"dtype": "None",
"dtypes": "None",
"for... | 8, 'complex128' | [] | [
0, 1, 2, 3, 4,
5, 6, 7, 8
] | 7 | 7 |
zeroTo_mu_7_8 | zeroTo | high | function zeroTo( n ) {
var arr;
var i;
arr = [];
if ( n <= 0 ) {
return arr;
}
for ( i = 0; i <= n; i++ ) {
arr.push( i );
}
return arr;
}
| zeroTo:\n/**\n* Generates a linearly spaced numeric array whose elements increment by 1 starting from zero.\n*\n* @param {number} n - number of elements\n* @returns {Array<number>} linearly spaced numeric array\n*\n* @example\n* var arr = zeroTo( 6 );\n* // returns [ 0, 1, 2, 3, 4, 5 ]\n*/ | [] | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "None",
"ctors": "None",
"defaults": "None",
"dtype": "None",
"dtypes": "None",
"for... | 999999999, 'int32' | [] | RangeError | 7 | 8 |
zeroTo_mu_7_9 | zeroTo | high | function zeroTo( n ) {
var arr;
var i;
arr = [];
if ( n <= 0 ) {
return arr;
}
for ( i = 0; i <= n; i++ ) {
arr.push( i );
}
return arr;
}
| zeroTo:\n/**\n* Generates a linearly spaced numeric array whose elements increment by 1 starting from zero.\n*\n* @param {number} n - number of elements\n* @returns {Array<number>} linearly spaced numeric array\n*\n* @example\n* var arr = zeroTo( 6 );\n* // returns [ 0, 1, 2, 3, 4, 5 ]\n*/ | [] | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "None",
"ctors": "None",
"defaults": "None",
"dtype": "None",
"dtypes": "None",
"for... | 0, 'int8' | [] | [] | 7 | 9 |
mskfilter_mu_0_0 | mskfilter | high | function mskfilter( x, mask ) {
var xget;
var mget;
var out;
var dt;
var i;
// Validate input:
if ( !isCollection( x ) ) {
throw new TypeError( format(
'invalid argument. First argument must be an array-like object. Value: `%s`.',
x
) );
}
if ( !isCollection( mask ) ) {
throw new TypeError( format... | mskfilter:\n/**\n* mskfilter\n* Returns a new array by applying a mask to a provided input array.\n*\n* @param {Collection} x - input array\n* @param {Collection} mask - mask array\n* @throws {TypeError} first argument must be a collection\n* @throws {TypeError} second argument must be a collection\n* @throws {Error} m... | [('isCollection', "var isCollection = require( '@stdlib/assert/is-collection' );"), ('countTruthy', "var countTruthy = require( '@stdlib/array/base/count-truthy' );"), ('zeros', "var zeros = require( '@stdlib/array/zeros' );"), ('dtype', "var dtype = require( '@stdlib/array/dtype' );"), ('format', "var format = require... | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "/**\\n* Counts the number of truthy values in an array.\\n*\\n* @param {Collection} x - input... | [1, 2, 3, 4], [0, 1, 0, 1] | [] | [ 2, 4 ] | 0 | 0 |
mskfilter_mu_0_1 | mskfilter | high | function mskfilter( x, mask ) {
var xget;
var mget;
var out;
var dt;
var i;
// Validate input:
if ( !isCollection( x ) ) {
throw new TypeError( format(
'invalid argument. First argument must be an array-like object. Value: `%s`.',
x
) );
}
if ( !isCollection( mask ) ) {
throw new TypeError( format... | mskfilter:\n/**\n* mskfilter\n* Returns a new array by applying a mask to a provided input array.\n*\n* @param {Collection} x - input array\n* @param {Collection} mask - mask array\n* @throws {TypeError} first argument must be a collection\n* @throws {TypeError} second argument must be a collection\n* @throws {Error} m... | [('isCollection', "var isCollection = require( '@stdlib/assert/is-collection' );"), ('countTruthy', "var countTruthy = require( '@stdlib/array/base/count-truthy' );"), ('zeros', "var zeros = require( '@stdlib/array/zeros' );"), ('dtype', "var dtype = require( '@stdlib/array/dtype' );"), ('format', "var format = require... | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "/**\\n* Counts the number of truthy values in an array.\\n*\\n* @param {Collection} x - input... | [10, 20, 30], [1, 1, 1] | [] | [ 10, 20, 30 ] | 0 | 1 |
mskfilter_mu_0_2 | mskfilter | high | function mskfilter( x, mask ) {
var xget;
var mget;
var out;
var dt;
var i;
// Validate input:
if ( !isCollection( x ) ) {
throw new TypeError( format(
'invalid argument. First argument must be an array-like object. Value: `%s`.',
x
) );
}
if ( !isCollection( mask ) ) {
throw new TypeError( format... | mskfilter:\n/**\n* mskfilter\n* Returns a new array by applying a mask to a provided input array.\n*\n* @param {Collection} x - input array\n* @param {Collection} mask - mask array\n* @throws {TypeError} first argument must be a collection\n* @throws {TypeError} second argument must be a collection\n* @throws {Error} m... | [('isCollection', "var isCollection = require( '@stdlib/assert/is-collection' );"), ('countTruthy', "var countTruthy = require( '@stdlib/array/base/count-truthy' );"), ('zeros', "var zeros = require( '@stdlib/array/zeros' );"), ('dtype', "var dtype = require( '@stdlib/array/dtype' );"), ('format', "var format = require... | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "/**\\n* Counts the number of truthy values in an array.\\n*\\n* @param {Collection} x - input... | [0.1, 0.2, 0.3, 0.4, 0.5], [1, 0, 1, 0, 1] | [] | [ 0.1, 0.3, 0.5 ] | 0 | 2 |
mskfilter_mu_0_3 | mskfilter | high | function mskfilter( x, mask ) {
var xget;
var mget;
var out;
var dt;
var i;
// Validate input:
if ( !isCollection( x ) ) {
throw new TypeError( format(
'invalid argument. First argument must be an array-like object. Value: `%s`.',
x
) );
}
if ( !isCollection( mask ) ) {
throw new TypeError( format... | mskfilter:\n/**\n* mskfilter\n* Returns a new array by applying a mask to a provided input array.\n*\n* @param {Collection} x - input array\n* @param {Collection} mask - mask array\n* @throws {TypeError} first argument must be a collection\n* @throws {TypeError} second argument must be a collection\n* @throws {Error} m... | [('isCollection', "var isCollection = require( '@stdlib/assert/is-collection' );"), ('countTruthy', "var countTruthy = require( '@stdlib/array/base/count-truthy' );"), ('zeros', "var zeros = require( '@stdlib/array/zeros' );"), ('dtype', "var dtype = require( '@stdlib/array/dtype' );"), ('format', "var format = require... | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "/**\\n* Counts the number of truthy values in an array.\\n*\\n* @param {Collection} x - input... | ['a', 'b', 'c', 'd'], [True, False, True, False] | [] | ReferenceError | 0 | 3 |
mskfilter_mu_0_4 | mskfilter | high | function mskfilter( x, mask ) {
var xget;
var mget;
var out;
var dt;
var i;
// Validate input:
if ( !isCollection( x ) ) {
throw new TypeError( format(
'invalid argument. First argument must be an array-like object. Value: `%s`.',
x
) );
}
if ( !isCollection( mask ) ) {
throw new TypeError( format... | mskfilter:\n/**\n* mskfilter\n* Returns a new array by applying a mask to a provided input array.\n*\n* @param {Collection} x - input array\n* @param {Collection} mask - mask array\n* @throws {TypeError} first argument must be a collection\n* @throws {TypeError} second argument must be a collection\n* @throws {Error} m... | [('isCollection', "var isCollection = require( '@stdlib/assert/is-collection' );"), ('countTruthy', "var countTruthy = require( '@stdlib/array/base/count-truthy' );"), ('zeros', "var zeros = require( '@stdlib/array/zeros' );"), ('dtype', "var dtype = require( '@stdlib/array/dtype' );"), ('format', "var format = require... | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "/**\\n* Counts the number of truthy values in an array.\\n*\\n* @param {Collection} x - input... | [100], [0] | [] | [] | 0 | 4 |
mskfilter_mu_0_5 | mskfilter | high | function mskfilter( x, mask ) {
var xget;
var mget;
var out;
var dt;
var i;
// Validate input:
if ( !isCollection( x ) ) {
throw new TypeError( format(
'invalid argument. First argument must be an array-like object. Value: `%s`.',
x
) );
}
if ( !isCollection( mask ) ) {
throw new TypeError( format... | mskfilter:\n/**\n* mskfilter\n* Returns a new array by applying a mask to a provided input array.\n*\n* @param {Collection} x - input array\n* @param {Collection} mask - mask array\n* @throws {TypeError} first argument must be a collection\n* @throws {TypeError} second argument must be a collection\n* @throws {Error} m... | [('isCollection', "var isCollection = require( '@stdlib/assert/is-collection' );"), ('countTruthy', "var countTruthy = require( '@stdlib/array/base/count-truthy' );"), ('zeros', "var zeros = require( '@stdlib/array/zeros' );"), ('dtype', "var dtype = require( '@stdlib/array/dtype' );"), ('format', "var format = require... | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "/**\\n* Counts the number of truthy values in an array.\\n*\\n* @param {Collection} x - input... | [-1, -2, -3, 0], [0, 1, 1, 0] | [] | [ -2, -3 ] | 0 | 5 |
mskfilter_mu_0_6 | mskfilter | high | function mskfilter( x, mask ) {
var xget;
var mget;
var out;
var dt;
var i;
// Validate input:
if ( !isCollection( x ) ) {
throw new TypeError( format(
'invalid argument. First argument must be an array-like object. Value: `%s`.',
x
) );
}
if ( !isCollection( mask ) ) {
throw new TypeError( format... | mskfilter:\n/**\n* mskfilter\n* Returns a new array by applying a mask to a provided input array.\n*\n* @param {Collection} x - input array\n* @param {Collection} mask - mask array\n* @throws {TypeError} first argument must be a collection\n* @throws {TypeError} second argument must be a collection\n* @throws {Error} m... | [('isCollection', "var isCollection = require( '@stdlib/assert/is-collection' );"), ('countTruthy', "var countTruthy = require( '@stdlib/array/base/count-truthy' );"), ('zeros', "var zeros = require( '@stdlib/array/zeros' );"), ('dtype', "var dtype = require( '@stdlib/array/dtype' );"), ('format', "var format = require... | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "/**\\n* Counts the number of truthy values in an array.\\n*\\n* @param {Collection} x - input... | [1, 2, 3, 4, 5, 6], [1, 0, 1, 0, 1, 0] | [] | [ 1, 3, 5 ] | 0 | 6 |
mskfilter_mu_0_7 | mskfilter | high | function mskfilter( x, mask ) {
var xget;
var mget;
var out;
var dt;
var i;
// Validate input:
if ( !isCollection( x ) ) {
throw new TypeError( format(
'invalid argument. First argument must be an array-like object. Value: `%s`.',
x
) );
}
if ( !isCollection( mask ) ) {
throw new TypeError( format... | mskfilter:\n/**\n* mskfilter\n* Returns a new array by applying a mask to a provided input array.\n*\n* @param {Collection} x - input array\n* @param {Collection} mask - mask array\n* @throws {TypeError} first argument must be a collection\n* @throws {TypeError} second argument must be a collection\n* @throws {Error} m... | [('isCollection', "var isCollection = require( '@stdlib/assert/is-collection' );"), ('countTruthy', "var countTruthy = require( '@stdlib/array/base/count-truthy' );"), ('zeros', "var zeros = require( '@stdlib/array/zeros' );"), ('dtype', "var dtype = require( '@stdlib/array/dtype' );"), ('format', "var format = require... | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "/**\\n* Counts the number of truthy values in an array.\\n*\\n* @param {Collection} x - input... | ['apple', 'banana', 'cherry'], [0, 1, 0] | [] | [ 'banana' ] | 0 | 7 |
mskfilter_mu_0_8 | mskfilter | high | function mskfilter( x, mask ) {
var xget;
var mget;
var out;
var dt;
var i;
// Validate input:
if ( !isCollection( x ) ) {
throw new TypeError( format(
'invalid argument. First argument must be an array-like object. Value: `%s`.',
x
) );
}
if ( !isCollection( mask ) ) {
throw new TypeError( format... | mskfilter:\n/**\n* mskfilter\n* Returns a new array by applying a mask to a provided input array.\n*\n* @param {Collection} x - input array\n* @param {Collection} mask - mask array\n* @throws {TypeError} first argument must be a collection\n* @throws {TypeError} second argument must be a collection\n* @throws {Error} m... | [('isCollection', "var isCollection = require( '@stdlib/assert/is-collection' );"), ('countTruthy', "var countTruthy = require( '@stdlib/array/base/count-truthy' );"), ('zeros', "var zeros = require( '@stdlib/array/zeros' );"), ('dtype', "var dtype = require( '@stdlib/array/dtype' );"), ('format', "var format = require... | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "/**\\n* Counts the number of truthy values in an array.\\n*\\n* @param {Collection} x - input... | [None, 'x', 0, False], [0, 1, 0, 1] | [] | ReferenceError | 0 | 8 |
mskfilter_mu_0_9 | mskfilter | high | function mskfilter( x, mask ) {
var xget;
var mget;
var out;
var dt;
var i;
// Validate input:
if ( !isCollection( x ) ) {
throw new TypeError( format(
'invalid argument. First argument must be an array-like object. Value: `%s`.',
x
) );
}
if ( !isCollection( mask ) ) {
throw new TypeError( format... | mskfilter:\n/**\n* mskfilter\n* Returns a new array by applying a mask to a provided input array.\n*\n* @param {Collection} x - input array\n* @param {Collection} mask - mask array\n* @throws {TypeError} first argument must be a collection\n* @throws {TypeError} second argument must be a collection\n* @throws {Error} m... | [('isCollection', "var isCollection = require( '@stdlib/assert/is-collection' );"), ('countTruthy', "var countTruthy = require( '@stdlib/array/base/count-truthy' );"), ('zeros', "var zeros = require( '@stdlib/array/zeros' );"), ('dtype', "var dtype = require( '@stdlib/array/dtype' );"), ('format', "var format = require... | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "/**\\n* Counts the number of truthy values in an array.\\n*\\n* @param {Collection} x - input... | [[1, 2], [3, 4], [5, 6]], [1, 0, 1] | [] | [ [ 1, 2 ], [ 5, 6 ] ] | 0 | 9 |
mskfilter_mu_1_0 | mskfilter | high | function mskfilter( x, mask ) {
var xget;
var mget;
var out;
var dt;
var i;
// Validate input:
if ( true ) {
throw new TypeError( format(
'invalid argument. First argument must be an array-like object. Value: `%s`.',
x
) );
}
if ( !isCollection( mask ) ) {
throw new TypeError( format(
'invalid ... | mskfilter:\n/**\n* mskfilter\n* Returns a new array by applying a mask to a provided input array.\n*\n* @param {Collection} x - input array\n* @param {Collection} mask - mask array\n* @throws {TypeError} first argument must be a collection\n* @throws {TypeError} second argument must be a collection\n* @throws {Error} m... | [('isCollection', "var isCollection = require( '@stdlib/assert/is-collection' );"), ('countTruthy', "var countTruthy = require( '@stdlib/array/base/count-truthy' );"), ('zeros', "var zeros = require( '@stdlib/array/zeros' );"), ('dtype', "var dtype = require( '@stdlib/array/dtype' );"), ('format', "var format = require... | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "/**\\n* Counts the number of truthy values in an array.\\n*\\n* @param {Collection} x - input... | [1, 2, 3, 4], [0, 1, 0, 1] | [] | TypeError | 1 | 0 |
mskfilter_mu_1_1 | mskfilter | high | function mskfilter( x, mask ) {
var xget;
var mget;
var out;
var dt;
var i;
// Validate input:
if ( true ) {
throw new TypeError( format(
'invalid argument. First argument must be an array-like object. Value: `%s`.',
x
) );
}
if ( !isCollection( mask ) ) {
throw new TypeError( format(
'invalid ... | mskfilter:\n/**\n* mskfilter\n* Returns a new array by applying a mask to a provided input array.\n*\n* @param {Collection} x - input array\n* @param {Collection} mask - mask array\n* @throws {TypeError} first argument must be a collection\n* @throws {TypeError} second argument must be a collection\n* @throws {Error} m... | [('isCollection', "var isCollection = require( '@stdlib/assert/is-collection' );"), ('countTruthy', "var countTruthy = require( '@stdlib/array/base/count-truthy' );"), ('zeros', "var zeros = require( '@stdlib/array/zeros' );"), ('dtype', "var dtype = require( '@stdlib/array/dtype' );"), ('format', "var format = require... | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "/**\\n* Counts the number of truthy values in an array.\\n*\\n* @param {Collection} x - input... | [10, 20, 30], [1, 1, 1] | [] | TypeError | 1 | 1 |
mskfilter_mu_1_2 | mskfilter | high | function mskfilter( x, mask ) {
var xget;
var mget;
var out;
var dt;
var i;
// Validate input:
if ( true ) {
throw new TypeError( format(
'invalid argument. First argument must be an array-like object. Value: `%s`.',
x
) );
}
if ( !isCollection( mask ) ) {
throw new TypeError( format(
'invalid ... | mskfilter:\n/**\n* mskfilter\n* Returns a new array by applying a mask to a provided input array.\n*\n* @param {Collection} x - input array\n* @param {Collection} mask - mask array\n* @throws {TypeError} first argument must be a collection\n* @throws {TypeError} second argument must be a collection\n* @throws {Error} m... | [('isCollection', "var isCollection = require( '@stdlib/assert/is-collection' );"), ('countTruthy', "var countTruthy = require( '@stdlib/array/base/count-truthy' );"), ('zeros', "var zeros = require( '@stdlib/array/zeros' );"), ('dtype', "var dtype = require( '@stdlib/array/dtype' );"), ('format', "var format = require... | {
"Complex128": "None",
"Complex64": "None",
"Float64Array": "None",
"Int32Array": "None",
"afill": "None",
"arraylike2object": "None",
"ceil": "None",
"contains": "None",
"convert": "None",
"countTruthy": "/**\\n* Counts the number of truthy values in an array.\\n*\\n* @param {Collection} x - input... | [0.1, 0.2, 0.3, 0.4, 0.5], [1, 0, 1, 0, 1] | [] | TypeError | 1 | 2 |
End of preview. Expand in Data Studio
README.md exists but content is empty.
- Downloads last month
- 2