simple-squiggle/node_modules/mathjs/lib/esm/function/matrix/range.js

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;
}
}
});