step

        # Numeric.step

(from ruby core)
---
    step(to = nil, by = 1) {|n| ... } ->  self
    step(to = nil, by = 1)            ->  enumerator
    step(to = nil, by: 1) {|n| ... }  ->  self
    step(to = nil, by: 1)             ->  enumerator
    step(by: 1, to: ) {|n| ... }      ->  self
    step(by: 1, to: )                 ->  enumerator
    step(by: , to: nil) {|n| ... }    ->  self
    step(by: , to: nil)               ->  enumerator

---

    Generates a sequence of numbers; with a block given, traverses the sequence.

    Of the Core and Standard Library classes,
    Integer, Float, and Rational use this implementation.

    A quick example:

      squares = []
      1.step(by: 2, to: 10) {|i| squares.push(i*i) }
      squares # => [1, 9, 25, 49, 81]

    The generated sequence:

    - Begins with +self+.
    - Continues at intervals of +step+ (which may not be zero).
    - Ends with the last number that is within or equal to +limit+;
      that is, less than or equal to +limit+ if +step+ is positive,
      greater than or equal to +limit+ if +step+ is negative.
      If +limit+ is not given, the sequence is of infinite length.

    If a block is given, calls the block with each number in the sequence;
    returns +self+.  If no block is given, returns an Enumerator::ArithmeticSequence.

    <b>Keyword Arguments</b>

    With keyword arguments +by+ and +to+,
    their values (or defaults) determine the step and limit:

      # Both keywords given.
      squares = []
      4.step(by: 2, to: 10) {|i| squares.push(i*i) }    # => 4
      squares # => [16, 36, 64, 100]
      cubes = []
      3.step(by: -1.5, to: -3) {|i| cubes.push(i*i*i) } # => 3
      cubes   # => [27.0, 3.375, 0.0, -3.375, -27.0]
      squares = []
      1.2.step(by: 0.2, to: 2.0) {|f| squares.push(f*f) }
      squares # => [1.44, 1.9599999999999997, 2.5600000000000005, 3.24, 4.0]

      squares = []
      Rational(6/5).step(by: 0.2, to: 2.0) {|r| squares.push(r*r) }
      squares # => [1.0, 1.44, 1.9599999999999997, 2.5600000000000005, 3.24, 4.0]

      # Only keyword to given.
      squares = []
      4.step(to: 10) {|i| squares.push(i*i) }           # => 4
      squares # => [16, 25, 36, 49, 64, 81, 100]
      # Only by given.

      # Only keyword by given
      squares = []
      4.step(by:2) {|i| squares.push(i*i); break if i > 10 }
      squares # => [16, 36, 64, 100, 144]

      # No block given.
      e = 3.step(by: -1.5, to: -3) # => (3.step(by: -1.5, to: -3))
      e.class                      # => Enumerator::ArithmeticSequence

    <b>Positional Arguments</b>

    With optional positional arguments +limit+ and +step+,
    their values (or defaults) determine the step and limit:

      squares = []
      4.step(10, 2) {|i| squares.push(i*i) }    # => 4
      squares # => [16, 36, 64, 100]
      squares = []
      4.step(10) {|i| squares.push(i*i) }
      squares # => [16, 25, 36, 49, 64, 81, 100]
      squares = []
      4.step {|i| squares.push(i*i); break if i > 10 }  # => nil
      squares # => [16, 25, 36, 49, 64, 81, 100, 121]

**Implementation Notes**

    If all the arguments are integers, the loop operates using an integer
    counter.

    If any of the arguments are floating point numbers, all are converted
    to floats, and the loop is executed
    <i>floor(n + n*Float::EPSILON) + 1</i> times,
    where <i>n = (limit - self)/step</i>.