281 lines
7.6 KiB
JavaScript
281 lines
7.6 KiB
JavaScript
import { factory } from '../../utils/factory.js';
|
|
import { noBignumber, noMatrix } from '../../utils/noop.js';
|
|
var name = 'range';
|
|
var dependencies = ['typed', 'config', '?matrix', '?bignumber', 'smaller', 'smallerEq', 'larger', 'largerEq'];
|
|
export var createRange = /* #__PURE__ */factory(name, dependencies, _ref => {
|
|
var {
|
|
typed,
|
|
config,
|
|
matrix,
|
|
bignumber,
|
|
smaller,
|
|
smallerEq,
|
|
larger,
|
|
largerEq
|
|
} = _ref;
|
|
|
|
/**
|
|
* Create an array from a range.
|
|
* By default, the range end is excluded. This can be customized by providing
|
|
* an extra parameter `includeEnd`.
|
|
*
|
|
* Syntax:
|
|
*
|
|
* math.range(str [, includeEnd]) // Create a range from a string,
|
|
* // where the string contains the
|
|
* // start, optional step, and end,
|
|
* // separated by a colon.
|
|
* math.range(start, end [, includeEnd]) // Create a range with start and
|
|
* // end and a step size of 1.
|
|
* math.range(start, end, step [, includeEnd]) // Create a range with start, step,
|
|
* // and end.
|
|
*
|
|
* Where:
|
|
*
|
|
* - `str: string`
|
|
* A string 'start:end' or 'start:step:end'
|
|
* - `start: {number | BigNumber}`
|
|
* Start of the range
|
|
* - `end: number | BigNumber`
|
|
* End of the range, excluded by default, included when parameter includeEnd=true
|
|
* - `step: number | BigNumber`
|
|
* Step size. Default value is 1.
|
|
* - `includeEnd: boolean`
|
|
* Option to specify whether to include the end or not. False by default.
|
|
*
|
|
* Examples:
|
|
*
|
|
* math.range(2, 6) // [2, 3, 4, 5]
|
|
* math.range(2, -3, -1) // [2, 1, 0, -1, -2]
|
|
* math.range('2:1:6') // [2, 3, 4, 5]
|
|
* math.range(2, 6, true) // [2, 3, 4, 5, 6]
|
|
*
|
|
* See also:
|
|
*
|
|
* ones, zeros, size, subset
|
|
*
|
|
* @param {*} args Parameters describing the ranges `start`, `end`, and optional `step`.
|
|
* @return {Array | Matrix} range
|
|
*/
|
|
return typed(name, {
|
|
// TODO: simplify signatures when typed-function supports default values and optional arguments
|
|
// TODO: a number or boolean should not be converted to string here
|
|
string: _strRange,
|
|
'string, boolean': _strRange,
|
|
'number, number': function numberNumber(start, end) {
|
|
return _out(_rangeEx(start, end, 1));
|
|
},
|
|
'number, number, number': function numberNumberNumber(start, end, step) {
|
|
return _out(_rangeEx(start, end, step));
|
|
},
|
|
'number, number, boolean': function numberNumberBoolean(start, end, includeEnd) {
|
|
return includeEnd ? _out(_rangeInc(start, end, 1)) : _out(_rangeEx(start, end, 1));
|
|
},
|
|
'number, number, number, boolean': function numberNumberNumberBoolean(start, end, step, includeEnd) {
|
|
return includeEnd ? _out(_rangeInc(start, end, step)) : _out(_rangeEx(start, end, step));
|
|
},
|
|
'BigNumber, BigNumber': function BigNumberBigNumber(start, end) {
|
|
var BigNumber = start.constructor;
|
|
return _out(_bigRangeEx(start, end, new BigNumber(1)));
|
|
},
|
|
'BigNumber, BigNumber, BigNumber': function BigNumberBigNumberBigNumber(start, end, step) {
|
|
return _out(_bigRangeEx(start, end, step));
|
|
},
|
|
'BigNumber, BigNumber, boolean': function BigNumberBigNumberBoolean(start, end, includeEnd) {
|
|
var BigNumber = start.constructor;
|
|
return includeEnd ? _out(_bigRangeInc(start, end, new BigNumber(1))) : _out(_bigRangeEx(start, end, new BigNumber(1)));
|
|
},
|
|
'BigNumber, BigNumber, BigNumber, boolean': function BigNumberBigNumberBigNumberBoolean(start, end, step, includeEnd) {
|
|
return includeEnd ? _out(_bigRangeInc(start, end, step)) : _out(_bigRangeEx(start, end, step));
|
|
}
|
|
});
|
|
|
|
function _out(arr) {
|
|
if (config.matrix === 'Matrix') {
|
|
return matrix ? matrix(arr) : noMatrix();
|
|
}
|
|
|
|
return arr;
|
|
}
|
|
|
|
function _strRange(str, includeEnd) {
|
|
var r = _parse(str);
|
|
|
|
if (!r) {
|
|
throw new SyntaxError('String "' + str + '" is no valid range');
|
|
}
|
|
|
|
var fn;
|
|
|
|
if (config.number === 'BigNumber') {
|
|
if (bignumber === undefined) {
|
|
noBignumber();
|
|
}
|
|
|
|
fn = includeEnd ? _bigRangeInc : _bigRangeEx;
|
|
return _out(fn(bignumber(r.start), bignumber(r.end), bignumber(r.step)));
|
|
} else {
|
|
fn = includeEnd ? _rangeInc : _rangeEx;
|
|
return _out(fn(r.start, r.end, r.step));
|
|
}
|
|
}
|
|
/**
|
|
* Create a range with numbers. End is excluded
|
|
* @param {number} start
|
|
* @param {number} end
|
|
* @param {number} step
|
|
* @returns {Array} range
|
|
* @private
|
|
*/
|
|
|
|
|
|
function _rangeEx(start, end, step) {
|
|
var array = [];
|
|
var x = start;
|
|
|
|
if (step > 0) {
|
|
while (smaller(x, end)) {
|
|
array.push(x);
|
|
x += step;
|
|
}
|
|
} else if (step < 0) {
|
|
while (larger(x, end)) {
|
|
array.push(x);
|
|
x += step;
|
|
}
|
|
}
|
|
|
|
return array;
|
|
}
|
|
/**
|
|
* Create a range with numbers. End is included
|
|
* @param {number} start
|
|
* @param {number} end
|
|
* @param {number} step
|
|
* @returns {Array} range
|
|
* @private
|
|
*/
|
|
|
|
|
|
function _rangeInc(start, end, step) {
|
|
var array = [];
|
|
var x = start;
|
|
|
|
if (step > 0) {
|
|
while (smallerEq(x, end)) {
|
|
array.push(x);
|
|
x += step;
|
|
}
|
|
} else if (step < 0) {
|
|
while (largerEq(x, end)) {
|
|
array.push(x);
|
|
x += step;
|
|
}
|
|
}
|
|
|
|
return array;
|
|
}
|
|
/**
|
|
* Create a range with big numbers. End is excluded
|
|
* @param {BigNumber} start
|
|
* @param {BigNumber} end
|
|
* @param {BigNumber} step
|
|
* @returns {Array} range
|
|
* @private
|
|
*/
|
|
|
|
|
|
function _bigRangeEx(start, end, step) {
|
|
var zero = bignumber(0);
|
|
var array = [];
|
|
var x = start;
|
|
|
|
if (step.gt(zero)) {
|
|
while (smaller(x, end)) {
|
|
array.push(x);
|
|
x = x.plus(step);
|
|
}
|
|
} else if (step.lt(zero)) {
|
|
while (larger(x, end)) {
|
|
array.push(x);
|
|
x = x.plus(step);
|
|
}
|
|
}
|
|
|
|
return array;
|
|
}
|
|
/**
|
|
* Create a range with big numbers. End is included
|
|
* @param {BigNumber} start
|
|
* @param {BigNumber} end
|
|
* @param {BigNumber} step
|
|
* @returns {Array} range
|
|
* @private
|
|
*/
|
|
|
|
|
|
function _bigRangeInc(start, end, step) {
|
|
var zero = bignumber(0);
|
|
var array = [];
|
|
var x = start;
|
|
|
|
if (step.gt(zero)) {
|
|
while (smallerEq(x, end)) {
|
|
array.push(x);
|
|
x = x.plus(step);
|
|
}
|
|
} else if (step.lt(zero)) {
|
|
while (largerEq(x, end)) {
|
|
array.push(x);
|
|
x = x.plus(step);
|
|
}
|
|
}
|
|
|
|
return array;
|
|
}
|
|
/**
|
|
* Parse a string into a range,
|
|
* The string contains the start, optional step, and end, separated by a colon.
|
|
* If the string does not contain a valid range, null is returned.
|
|
* For example str='0:2:11'.
|
|
* @param {string} str
|
|
* @return {{start: number, end: number, step: number} | null} range Object containing properties start, end, step
|
|
* @private
|
|
*/
|
|
|
|
|
|
function _parse(str) {
|
|
var args = str.split(':'); // number
|
|
|
|
var nums = args.map(function (arg) {
|
|
// use Number and not parseFloat as Number returns NaN on invalid garbage in the string
|
|
return Number(arg);
|
|
});
|
|
var invalid = nums.some(function (num) {
|
|
return isNaN(num);
|
|
});
|
|
|
|
if (invalid) {
|
|
return null;
|
|
}
|
|
|
|
switch (nums.length) {
|
|
case 2:
|
|
return {
|
|
start: nums[0],
|
|
end: nums[1],
|
|
step: 1
|
|
};
|
|
|
|
case 3:
|
|
return {
|
|
start: nums[0],
|
|
end: nums[2],
|
|
step: nums[1]
|
|
};
|
|
|
|
default:
|
|
return null;
|
|
}
|
|
}
|
|
}); |