Array of evenly spaced values.

@param begin the begin of the range
@param end   the end of the range
@return the range vector
426581
@Override
    public INDArray arange(double begin, double end, double step) {
        return Nd4j.create(ArrayUtil.toDoubles(ArrayUtil.range((int) begin, (int) end,  (int)step)));
    }
105591
public StrBuilder del(int start, int end) {
		if (start < 0) {
			start = 0;
		}
		if (end > this.position) {
			end = this.position;
		}
		if (start > end) {
			throw new StringIndexOutOfBoundsException("Start is greater than End.");
		}
		if (end == this.position) {
			this.position = start;
		}

		int len = end - start;
		if (len > 0) {
			System.arraycopy(value, start + len, value, start, this.position - end);
			this.position -= len;
		}
		return this;
	}
840335
function range(begin, end) {
  var interval = arguments.length <= 2 || arguments[2] === undefined ? 1 : arguments[2];

  var a = [];

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

  return a;
}
680711
@Override
    public final int[] buildSuffixArray(int[] input, int start, int length) {
        Tools.assertAlways(input.length >= start + length + 1, "no extra space after input end");
        MinMax minmax = Tools.minmax(input, start, length);
        Tools.assertAlways(minmax.min >= 0, "input must not be negative");
        I = new int[length + 1];
        this.start = start;
        if (preserveInput) {
            V = new int[length + 1];
            this.start = 0;
            System.arraycopy(input, start, V, 0, length);
        } else {
            V = input;
        }
        suffixsort(length, minmax.max + 1, minmax.min);

        final int[] tmp = I;
        V = I = null;
        return tmp;
    }
463400
final public void addPositionRange(int start, int end) {
    if (tokenPosition == null) {
      tokenPosition = new MtasPosition(start, end);
    } else {
      int[] positions = new int[end - start + 1];
      for (int i = start; i <= end; i++) {
        positions[i - start] = i;
      }
      tokenPosition.add(positions);
    }
  }
424789
function() {
                var A = this.start.elements, B = this.end.elements;
                return vector.create([B[0] - A[0], B[1] - A[1], B[2] - A[2]]);
              }
34403
public static Range fromInterval(int start, int end) {
        if (start < 0) {
            throw new IllegalArgumentException("Range start must be >= 0: " + start);
        }
        if (end < 0) {
            throw new IllegalArgumentException("Range end must be >= 0: " + end);
        }
        if (end < start) {
            throw new IllegalArgumentException("Range end must be >= start: " + end + "<" + start);
        }
        return new Range(start, end - start);
    }
404043
public Matcher matcher(char[] data, int start, int end) {
        Matcher m = new Matcher(this);
        m.setTarget(data, start, end);
        return m;
    }
632676
function RangeIterator(start, end, step) {
    this.start = start;
    this.end = (end !== undefined) ? end : Math.pow(2,32);    // or should this be Number.MAX_VALUE
    this.step = (step !== undefined)
        ? step
        : (this.end >= this.start)
            ? 1
            : -1;
    this.reset();
}
1148685
public static Collection<Integer> appendRange(int start, int stop, int step, Collection<Integer> values) {
		if (start < stop) {
			step = Math.abs(step);
		} else if (start > stop) {
			step = -Math.abs(step);
		} else {// start == end
			values.add(start);
			return values;
		}

		for (int i = start; (step > 0) ? i <= stop : i >= stop; i += step) {
			values.add(i);
		}
		return values;
	}
620733
public Query range(ByteString start, ByteString end) {
    RowRange.Builder rangeBuilder = RowRange.newBuilder();
    if (start != null) {
      rangeBuilder.setStartKeyClosed(start);
    }
    if (end != null) {
      rangeBuilder.setEndKeyOpen(end);
    }
    builder.getRowsBuilder().addRowRanges(rangeBuilder.build());
    return this;
  }
1225797
public function slice(array $array, $begin, $end = null): array
    {
        if ($end === null) {
            $end = count($array);
        } elseif ($end < 0) {
            $end = count($array) + $end;
        }
        $length = $end - $begin;
        return array_slice($array, $begin, $length);
    }
493928
protected void addRange(int start, int end) {
		this.icaseCache = null;
		// System.err.println("Token#addRange(): "+start+" "+end);
		int r1, r2;
		if (start <= end) {
			r1 = start;
			r2 = end;
		} else {
			r1 = end;
			r2 = start;
		}

		int pos = 0;
		if (this.ranges == null) {
			this.ranges = new int[2];
			this.ranges[0] = r1;
			this.ranges[1] = r2;
			this.setSorted(true);
		} else {
			pos = this.ranges.length;
			if (this.ranges[pos - 1] + 1 == r1) {
				this.ranges[pos - 1] = r2;
				return;
			}
			int[] temp = new int[pos + 2];
			System.arraycopy(this.ranges, 0, temp, 0, pos);
			this.ranges = temp;
			if (this.ranges[pos - 1] >= r1)
				this.setSorted(false);
			this.ranges[pos++] = r1;
			this.ranges[pos] = r2;
			if (!this.sorted)
				this.sortRanges();
		}
	}
928489
public Query range(String start, String end) {
    return range(wrapKey(start), wrapKey(end));
  }
1098084
public synchronized List<Message> getFromRange(final int startPosition, final int endPosition) {
        // cache this here, so all parts of the method operate on the same data
        final int firstMessageId = this.getFirstPosition();
        // input validation
        if ((startPosition < MessageStore.INITIAL_MESSAGE_POSITION)
                || (endPosition < MessageStore.INITIAL_MESSAGE_POSITION)) {
            throw new IllegalArgumentException("Message position cannot be negative.");
        } else if ((firstMessageId >= MessageStore.INITIAL_MESSAGE_POSITION) && (startPosition < firstMessageId)) {
            throw new IllegalArgumentException("Message at position " + startPosition
                    + " had already been discarded. First available message position is " + firstMessageId + ".");
        } else if (endPosition <= startPosition) {
            throw new IllegalArgumentException("Ending position must be larger than starting message position.");
        } else if (endPosition > this.getNextPosition()) {
            throw new IllegalArgumentException("Range end cannot be greater than the next message position.");
        }
        // and properly synchronized range retrieval
        return Collections.unmodifiableList(new LinkedList<>(this.store.subMap(startPosition, endPosition)
                .values()));
    }
625153
public static ValueArray createArray(int begin, int end, int step) {
        if (end < begin) {
            throw new IllegalArgumentException("End must be greater or equal to begin");
        }
        int nbClasses = (int) ((end - begin) / step);
        ValueInt[] getArray = new ValueInt[nbClasses];
        for (int i = 0; i < nbClasses; i++) {
            getArray[i] = ValueInt.get(i * step + begin);

        }        
        return ValueArray.get(getArray);
    }
178997
public static int[] sequence(int start, int end) {
    if(start >= end) {
      return EMPTY_INTS;
    }
    int[] ret = new int[end - start];
    for(int j = 0; start < end; start++, j++) {
      ret[j] = start;
    }
    return ret;
  }