Range constructor.

@param {Number|String} min
@param {Number|String} max
@param {Number} step
@constructor
347646
function Range(min, max, step) {
  var scope = null
    , re = /^([A-Za-z]|\d+)\.{2}([A-Za-z]|\d+)$/;

  if (typeof min === 'string' && min.match(re)) {
    step = max;
    scope = min.split('..');
    min = cast(scope[0]);
    max = cast(scope[1]);
  }

  this.min(min);
  this.max(max);
  this.step(step);
}
74031
function(a, min, max, msg) {
    return assert((this.assertNumberMinimum(a, min, msg) && this.assertNumberMaximum(a, max, msg)), msg);
  }
441796
public ValidatorBuilderFloat<PARENT> range(float min, float max) {

    return range(new Range<>(Float.valueOf(min), Float.valueOf(max)));
  }
62622
function(value, range) {
      var
        intRegExp = $.fn.form.settings.regExp.integer,
        min,
        max,
        parts
      ;
      if( !range || ['', '..'].indexOf(range) !== -1) {
        // do nothing
      }
      else if(range.indexOf('..') == -1) {
        if(intRegExp.test(range)) {
          min = max = range - 0;
        }
      }
      else {
        parts = range.split('..', 2);
        if(intRegExp.test(parts[0])) {
          min = parts[0] - 0;
        }
        if(intRegExp.test(parts[1])) {
          max = parts[1] - 0;
        }
      }
      return (
        intRegExp.test(value) &&
        (min === undefined || value >= min) &&
        (max === undefined || value <= max)
      );
    }
914823
function RANGE(from, to) {
        if (null == from || 1 != from.length || null == to || 1 != to.length) {
            throw 'Invalid args for RANGE';
        }

        return function (buffer, index, depth) {
            if (typeof depth === "undefined") { depth = 0; }
            var r;
            if (index < buffer.length && buffer.charAt(index) >= from && buffer.charAt(index) <= to) {
                return R.ok(paka.P.RANGE, index, 1, null);
            } else {
                r = R.error(paka.P.RANGE, index, null, 'Expects number in range [' + from + ', ' + to + ']');
                _update_last_error(r);
                return r;
            }
        };
    }
703249
function(min, max){
	min = min || 0.0;
	max = typeof max === 'number' ? max : 1.0;
	// swap if necessary
	if(min > max){
		var t= max;
		max = min;
		min = t;
	}
	this.min = min;
	this.max = max;
	this.currValue = min;
}
1230134
function Range(){
  if (!(this instanceof Range)) {
    return new Range();
  }

  // maximize int.
  var max = Math.pow(2, 32) - 1;
  // default options.
  this.options = {
    min: -max,
    max: max,
    res: {
      range  : /^[\s\d\-~,]+$/,
      blank  : /\s+/g,
      number : /^\-?\d+$/,
      min2num: /^~\-?\d+$/,
      num2max: /^\-?\d+~$/,
      num2num: /^\-?\d+~\-?\d+$/
    }
  };

  Object.freeze(this.options);
}
730195
function grow(area, min, max) {
  if( typeof min !== 'undefined' ) {
    min = parseInt( min );
    if( isNaN( min ) ) min = 2;
  }
  if( typeof max !== 'undefined' ) {
    max = parseInt( max );
    if( isNaN( max ) ) max = 8;
  }
  if( max < min ) max = min;

  var text = area.value;
  var lines = 1;
  var index = -1;
  for(;;) {
    index = text.indexOf( "\n", index + 1 );
    if( index === -1 ) break;
    lines++;
  }
  index = Math.max( min, Math.min( max, index ) );
  $.att( area, {rows: lines} );
}
920236
function detectStep (min, max) {
	var range = getTransformer(function (a, b) {
		return Math.abs(a - b);
	})(max, min);

	var step = getTransformer(function (a) {
		return a < 100 ? 0.01 : 1;
	})(range);

	return step;
}
917294
function (value, min, max) {
        min = min | 0;
        let length = ((value || '') + '').length;
        if (length < min) {
            return false;
        }
        if (max && length > max) {
            return false;
        }
        return true;
    }
403008
public void setMinMax(int min, int max)
    {
        if(min >= max)
            throw new IllegalArgumentException("The input minimum (" + min + ") must be less than the given max (" + max  + ")");
        this.min = min;
        this.max = max;
    }
1062413
function (x, min, max) {
    if (x <= min) {
      return 0;
    }
    if (x >= max) {
      return 1;
    }
    x = (x - min) / (max - min);
    return x * x * (3 - 2 * x);
  }
742096
function (num, min, max) {
        if (typeof num !== 'number' || num < min) {
            return min;
        }
        if (num === Infinity) {
            return _.isNil(max) ? min : max;
        }

        return num;
    }
446834
function _createEventRangeValidator(range) {
  var ctxRange = _createRangeArray(range);

  return function rangeValidator(range) {
    var leftIndex = 0;
    var rightIndex = 0;
    var left;
    var right;

    for (; leftIndex < ctxRange.length && rightIndex < range.length; ) {
      left = ctxRange[leftIndex];
      right = range[rightIndex];

      if (left.max < right.min) {
        ++leftIndex;
      } else if ((left.min <= right.min || left.max >= right.max) &&
                 ((left.min > right.min && (right.min !== Number.MIN_VALUE)) ||
                  (left.max < right.max) && (right.max !== Infinity))) {
        return false;
      } else {
        ++rightIndex;
      }
    }

    return (rightIndex >= range.length);
  };
}
733116
function range(begin, end, interval = 1) {
  var a = [];

  for (let i = begin; i < (begin+end); i += interval) {
    a.push(i);
  }

  return a;
}
104320
def clip(self, min=None, max=None):
        
        return self._constructor(
            self.values.clip(min=min, max=max)).__finalize__(self)
605272
public ValidatorBuilderInteger<PARENT> range(int min, int max) {

    return range(new Range<>(Integer.valueOf(min), Integer.valueOf(max)));
  }