simple-squiggle

range.js (7779B)

---

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