Forum: Ruby C(++) For Loop Equivalents

Announcement (2017-05-07): www.ruby-forum.com is now read-only since I unfortunately do not have the time to support and maintain the forum any more. Please see rubyonrails.org/community and ruby-lang.org/en/community for other Rails- und Ruby-related community platforms.
9117ece51252c8658aff6444fb6e6354?d=identicon&s=25 Steve Pugh (studlee2)
on 2007-03-20 01:31
(Received via mailing list)
What is the most efficient way in Ruby to create a conditional loop in
Ruby that looks like this in C(++):

for(int i=0; i*j/2<maxNum; i++)
{
  //cool method stuff
}


I was looking at the .upto() method but it doesn't like the comparison
operator :-/

Thanks!
31ab75f7ddda241830659630746cdd3a?d=identicon&s=25 Austin Ziegler (austin)
on 2007-03-20 01:37
(Received via mailing list)
On 3/19/07, studlee2 <studlee2@gmail.com> wrote:
> operator :-/
Wouldn't it be better to figure out what you're trying to do than look
for a general construct?

  >> max = 200
  => 200
  >> j = 35
  => 35
  >> i = 0
  => 0
  >> 0.upto(max) { |i| break if (i * j / 2) >= max }
  => nil
  >> i
  => 12

That will do the job.

-austin
1c1e3bdfe006a22214102fcd6434a012?d=identicon&s=25 Daniel Sheppard (Guest)
on 2007-03-20 02:20
(Received via mailing list)
> What is the most efficient way in Ruby to create a conditional loop in
> Ruby that looks like this in C(++):
>
> for(int i=0; i*j/2<maxNum; i++)
> {
>   //cool method stuff
> }

In the general case, you can 'while' anywhere where you'd normally 'for'

i=0
while i*j/2<maxNum
  //cool method stuff
  i++
end

But 'most efficient way' to do a conditional loop depends on your
context (and also what you're trying to make efficient - runtime?
writetime? readtime?).

Dan.
Cd3312ac93f768b1b449af457c0fca06?d=identicon&s=25 Daniel Finnie (Guest)
on 2007-03-20 02:28
(Received via mailing list)
Use the step method:

----------------------------------------------------------- Numeric#step
      num.step(limit, step ) {|i| block }     => num
------------------------------------------------------------------------
      Invokes _block_ with the sequence of numbers starting at _num_,
      incremented by _step_ on each call. The loop finishes when the
      value to be passed to the block is greater than _limit_ (if _step_
      is positive) or less than _limit_ (if _step_ is negative). 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 _floor(n +
      n*epsilon)+ 1_ times, where _n = (limit - num)/step_. Otherwise,
      the loop starts at _num_, uses either the +<+ or +>+ operator to
      compare the counter against _limit_, and increments itself using
      the +++ operator.

         1.step(10, 2) { |i| print i, " " }
         Math::E.step(Math::PI, 0.2) { |f| print f, " " }

      _produces:_

         1 3 5 7 9
         2.71828182845905 2.91828182845905 3.11828182845905

So your example would become:
0.step(i*j/2, 1) # (I'm not too sure about the details of C++ and if
defining i in the beginning would make i*j/2 be 0 no matter what)
Or, you could do
0.upto(i*j/2) # assumes step is one.

Finally, you could do
for i in 0..(i*j/2) do |i|
  # blah...
end
Afabd225e57b433553138fead5a820d4?d=identicon&s=25 Raj Sahae (rajsahae)
on 2007-03-20 06:05
(Received via mailing list)
studlee2 wrote:
> operator :-/
>
> Thanks
Why not just do:
((maxNum*2)/(i*j)).times do |n|
    #cool method stuff
end
Ee04bc0ca6dcdad4a7e8a8e1d4efb5d0?d=identicon&s=25 Michael W. Ryder (Guest)
on 2007-03-20 06:30
(Received via mailing list)
Raj Sahae wrote:
>> I was looking at the .upto() method but it doesn't like the comparison
>> operator :-/
>>
>> Thanks
> Why not just do:
> ((maxNum*2)/(i*j)).times do |n|
>    #cool method stuff
> end
>

He would need to initialize i before your code as it could be any value,
not just 0.  By the same token the increment could be any number, not
just 1.
A further problem with your method is that the loop is executed until
i*j/2 is greater than maxNum.  As you don't know if the loop somehow
modifies the value of j you can not optimize it out.  A simple example
would be where the program reads some numbers from a file and adds them
to j.  i is incremented by one each time a number is read.  You want the
program to exit when i*j/2 is larger than maxNum.
6087a044557d6b59ab52e7dd20f94da8?d=identicon&s=25 Peña, Botp (Guest)
on 2007-03-20 11:26
(Received via mailing list)
From: Michael W. Ryder [mailto:_mwryder@worldnet.att.net] :

# He would need to initialize i before your code as it could be
# any value,
# not just 0.  By the same token the increment could be any number, not
# just 1.

fwiw, this is a simple example (intended for nubies only).

C:\family\ruby>cat -n test.rb
     1  #---------------------------
     2  #emulate c++ for (the better)
     3  #for(int i=0; i*j/2<maxNum; i++)
     4  # {
     5  #  //cool method stuff
     6  # }
     7  #---------------------------
     8
     9  # using normal while loop
    10  puts "using while..."
    11  j=20
    12  i=0
    13  maxnum=100
    14  while i*j/2 < maxnum do
    15     puts i
    16     i+=1
    17  end
    18
    19  # let's make our own for() and call it for_simple :)
    20  # note, there's no condition here
    21  # we're leaving it up to yield/blocks since that
    22  # is the ideal way, imho
    23  def for_simple (init=0,incr=1)
    24     i = init
    25     loop do
    26        yield i
    27        i += incr
    28     end
    29  end
    30
    31  # now let's test it
    32  puts <<TEXT
    33  Test I.
    34  using our own simple for()...  note advantage,
    35  we don't need to track the counter...
    36  TEXT
    37
    38  for_simple do |i|
    39     break unless i*j/2 < maxnum
    40     puts i
    41  end
    42
    43  puts <<TEXT
    44  Test II.
    45  here we initialize to 2 and increment by 2
    46  again, we don't need to track the counter...
    47  TEXT
    48
    49  for_simple(2,2) do |i|
    50     break unless i*j/2 < maxnum
    51     puts i
    52  end
    53
    54  puts <<TEXT
    55  Test III.
    56  again, here we initialize to 200 and decrement by 20
    57  again, we don't need to track the counter...
    58  and note, we change keyword unless to if
    59  ruby just simply rocks..
    60  TEXT
    61
    62  for_simple(200,-20) do |i|
    63     break if i*j/2 < maxnum
    64     puts i
    65  end

C:\family\ruby>ruby test.rb
using while...
0
1
2
3
4
5
6
7
8
9
Test I.
using our own simple for()...  note advantage,
we don't need to track the counter...
0
1
2
3
4
5
6
7
8
9
Test II.
here we initialize to 2 and increment by 2
again, we don't need to track the counter...
2
4
6
8
Test III.
again, here we initialize to 200 and decrement by 20
again, we don't need to track the counter...
and note, we change keyword unless to if
ruby just simply rocks..
200
180
160
140
120
100
80
60
40
20

C:\family\ruby>

Hth.
kind regards -botp
Ee04bc0ca6dcdad4a7e8a8e1d4efb5d0?d=identicon&s=25 Michael W. Ryder (Guest)
on 2007-03-20 20:01
(Received via mailing list)
Peña wrote:
>      1  #---------------------------
>     12  i=0
>     23  def for_simple (init=0,incr=1)
>     34  using our own simple for()...  note advantage,
>     45  here we initialize to 2 and increment by 2
>     56  again, here we initialize to 200 and decrement by 20
> C:\family\ruby>ruby test.rb
> 9
> 7
> again, here we initialize to 200 and decrement by 20
> 60
> 40
> 20
>
> C:\family\ruby>
>
> Hth.
> kind regards -botp
>
>

Now is it possible, like in Scheme, to assign a variable to a string and
have Ruby evaluate the string?  For example, f = "i*j/2".  This would
allow one to make a more generic version of your methods.  Ideally you
would have for_opt (i=0, f, inc=1) and have the method evaluate each of
the variables if necessary.  This would allow one to copy working C code
without having to remember to do a lot of extraneous coding.
0a3117ace9ffd686054dfec667e9a976?d=identicon&s=25 Albert Ng (Guest)
on 2007-03-20 21:45
(Received via mailing list)
Is there any reason you can't use the syntactical sugar "for"? Or maybe
construct a range:

(i...((maxNum*2)/j) ).each_with_index do |stuff| end
This topic is locked and can not be replied to.