crazy loop error.

Dear R-users,
This is a loop which is part of a bigger script. I managed to isolate the
error in this loop and simplified it to the bare minimum and made it
self-contained.

a<-c(2,3,4,5,5,5,6,6,6,7)

for(n in 1:10)
{
print(paste("n: ",n))
z1<-a[n]
#make a list container
ldata<-list()
t=1

while(z1==a[n])
{

#add dataframes to list
ldata[[t]]<-paste("hello")

n=n+1
t=t+1

}
print("------End of while loop-------")

for(y in 1:length(ldata))
{
print(ldata[[y]])
}

print(paste("n: ",n))
print("******End of for loop********")
}


This script has a vector "a", for-loop, and a nested while-loop.
The for-loop runs from 1 to length of a. At every number of a, it enters the
while-loop and a hello is saved into list ldata.
If the next number in the vector a is a different number from previous then
the while-loop is exited and saved hello is printed.
If the next number in vector a is same as before then it loops inside the
while-loop and several hellos are printed together.

Then run-time error is

Error in while (z1 == a[n]) { : missing value where TRUE/FALSE needed

Thats because an NA creeps in somewhere. The problem can be seen far before
that. The full output from the run is below.
A lot of stuff was printed to help with the debugging. At n=4, there are
three repeats of 5, therefore hello is printed 3 times. n then becomes 7.
Then when the for-loop returns to top, n miraculously becomes 5. Hows
that!!?? Then on, everything goes wrong. I cannot figure out the problem.

[1] "n:  1"
[1] "------End of while loop-------"
[1] "hello"
[1] "n:  2"
[1] "******End of for loop********"
[1] "n:  2"
[1] "------End of while loop-------"
[1] "hello"
[1] "n:  3"
[1] "******End of for loop********"
[1] "n:  3"
[1] "------End of while loop-------"
[1] "hello"
[1] "n:  4"
[1] "******End of for loop********"
[1] "n:  4"
[1] "------End of while loop-------"
[1] "hello"
[1] "hello"
[1] "hello"
[1] "n:  7"
[1] "******End of for loop********"
[1] "n:  5"
[1] "------End of while loop-------"
[1] "hello"
[1] "hello"
[1] "n:  7"
[1] "******End of for loop********"
[1] "n:  6"
[1] "------End of while loop-------"
[1] "hello"
[1] "n:  7"
[1] "******End of for loop********"
[1] "n:  7"
[1] "------End of while loop-------"
[1] "hello"
[1] "hello"
[1] "hello"
[1] "n:  10"
[1] "******End of for loop********"
[1] "n:  8"
[1] "------End of while loop-------"
[1] "hello"
[1] "hello"
[1] "n:  10"
[1] "******End of for loop********"
[1] "n:  9"
[1] "------End of while loop-------"
[1] "hello"
[1] "n:  10"
[1] "******End of for loop********"
[1] "n:  10"
Error in while (z1 == a[n]) { : missing value where TRUE/FALSE needed

Mr Stuck-up.....
Thanks for any help.
Roy

	[[alternative HTML version deleted]]

Dear R-users,
This is a loop which is part of a bigger script. I managed to isolate the
error in this loop and simplified it to the bare minimum and made it
self-contained.

a<-c(2,3,4,5,5,5,6,6,6,7)

for(n in 1:10)
{
print(paste("n: ",n))
z1<-a[n]
#make a list container
ldata<-list()
t=1

while(z1==a[n])
{

#add dataframes to list
ldata[[t]]<-paste("hello")

n=n+1
t=t+1

}
print("------End of while loop-------")

for(y in 1:length(ldata))
{
print(ldata[[y]])
}

print(paste("n: ",n))
print("******End of for loop********")
}


This script has a vector "a", for-loop, and a nested while-loop.
The for-loop runs from 1 to length of a. At every number of a, it enters the
while-loop and a hello is saved into list ldata.
If the next number in the vector a is a different number from previous then
the while-loop is exited and saved hello is printed.
If the next number in vector a is same as before then it loops inside the
while-loop and several hellos are printed together.

Then run-time error is

Error in while (z1 == a[n]) { : missing value where TRUE/FALSE needed

Thats because an NA creeps in somewhere. The problem can be seen far before
that. The full output from the run is below.
A lot of stuff was printed to help with the debugging. At n=4, there are
three repeats of 5, therefore hello is printed 3 times. n then becomes 7.
Then when the for-loop returns to top, n miraculously becomes 5. Hows
that!!??

Thanks for the reply Erik, As you mentioned, grouping consecutive 
elements of 'a' was my idea. 
I am unaware of any R'ish way to do it. It would be nice if someone in 
the community knows this.

Thanks for the reply Erik, As you mentioned, grouping consecutive elements
of 'a' was my idea.
I am unaware of any R'ish way to do it. It would be nice if someone in the
community knows this.

The error resulting in the NA was pretty easy to fix, and my loop works, but
the results are still wrong (new script below).
Ideally it should print single "hello" for the single letters and grouped '3
hellos' for the fives, grouped '2 hellos' for the sixes etc.

Based on the run results, if the value of n is being tracked, it changes
quite unpredictably.
Can someone explain how the value of n changes from end of the loop to the
top without anything being done to it?

Thanks for the reply Erik, As you mentioned, grouping consecutive 

of 'a' was my idea.
I am unaware of any R'ish way to do it. It would be nice if someone in 

community knows this.

The error resulting in the NA was pretty easy to fix, and my loop works, 

the results are still wrong (new script below).
Ideally it should print single "hello" for the single letters and 

hellos' for the fives, grouped '2 hellos' for the sixes etc.

Based on the run results, if the value of n is being tracked, it changes
quite unpredictably.
Can someone explain how the value of n changes from end of the loop to 

top without anything being done to it?

I cannot figure out what I am doing wrong.

a<-c(2,3,5,5,5,6,6,7)

for(n in 1:length(a))
{
print(paste("n: ",n))
z1<-a[n]
print(paste("z1:",z1))
#make a list container
ldata<-list()
t=1

while(z1==a[n])
{

#add dataframes to list
ldata[[t]]<-paste("hello")

n=n+1
t=t+1

if(n>length(a))
{
break;
}
}
print("------End of while loop-------")

for(y in 1:length(ldata))
{
print(ldata[[y]])
}

print(paste("n: ",n))
print("******End of for loop********")
}


Thanks,
Roy

   [[alternative HTML version deleted]]

to foreach loop in Perl. If v is a vector, then

  for (n in v)

first creates the vector v and then always performs length(v) iterations.

On Mon, Jan 24, 2011 at 11:18:35PM +0100, Roy Mathew wrote:

Thanks for the reply Erik, As you mentioned, grouping consecutive elements
of 'a' was my idea.
I am unaware of any R'ish way to do it. It would be nice if someone in the
community knows this.

The error resulting in the NA was pretty easy to fix, and my loop works, but
the results are still wrong (new script below).
Ideally it should print single "hello" for the single letters and grouped '3
hellos' for the fives, grouped '2 hellos' for the sixes etc.

Based on the run results, if the value of n is being tracked, it changes
quite unpredictably.
Can someone explain how the value of n changes from end of the loop to the
top without anything being done to it?

Hi.

A for-loop in R is different from a for-loop in C. It is similar
to foreach loop in Perl. If v is a vector, then

 for (n in v)

first creates the vector v and then always performs length(v) iterations.
Before iteration i, n is assigned v[i] even if n is changed in the
previous iteration.

If you want to control the loop variable during execution, it is possible
to use a while loop, where you have full control. While loop may be better
also if v has a very large length, since, for example

 for (n in 1:1000000)

creates a vector of length 1000000 in memory.

It should also be noted that the for-loop

 for (n in 1:k)

performs 2 iterations, if k is 0, since 1:0 is a vector of length 2.
If k may be 0, then it is better to use

 for (n in seq(length=k))

since seq(length=0) has length 0.

Hope this helps.

Petr Savicky.

On Tue, 25 Jan 2011, Petr Savicky wrote:

On Mon, Jan 24, 2011 at 11:18:35PM +0100, Roy Mathew wrote:

Thanks for the reply Erik, As you mentioned, grouping consecutive 
elements
of 'a' was my idea.
I am unaware of any R'ish way to do it. It would be nice if someone 
in the
community knows this.

The error resulting in the NA was pretty easy to fix, and my loop 
works, but
the results are still wrong (new script below).
Ideally it should print single "hello" for the single letters and 
grouped '3
hellos' for the fives, grouped '2 hellos' for the sixes etc.

Based on the run results, if the value of n is being tracked, it 
changes
quite unpredictably.
Can someone explain how the value of n changes from end of the loop 
to the
top without anything being done to it?

Hi.

A for-loop in R is different from a for-loop in C. It is similar
to foreach loop in Perl. If v is a vector, then

 for (n in v)

first creates the vector v and then always performs length(v) 
iterations.
Before iteration i, n is assigned v[i] even if n is changed in the
previous iteration.

And also if v is changed during the loop.

If you want to control the loop variable during execution, it is 
possible
to use a while loop, where you have full control. While loop may be 
better
also if v has a very large length, since, for example

 for (n in 1:1000000)

creates a vector of length 1000000 in memory.

It should also be noted that the for-loop

 for (n in 1:k)

performs 2 iterations, if k is 0, since 1:0 is a vector of length 2.
If k may be 0, then it is better to use

 for (n in seq(length=k))

since seq(length=0) has length 0.

Since you keep mentioning that, it is actually much better to use 
seq_len(k) (and seq_along(x) instead of your earlier recommendation of 
seq(along=x)).  And if you are using seq() in other cases in programs, 
consider seq.int() instead.

Hope this helps.

Petr Savicky.

ooh.. I have another question.
What if I want to add the value in the vector a to the hello each time 

prints.
Here is your output

a <- c(2,3,5,5,5,6,6,7)
mapply(rep, "hello", rle(a)$lengths, USE.NAMES = FALSE)

[[1]]
[1] "hello"

[[2]]
[1] "hello"

[[3]]
[1] "hello" "hello" "hello"

[[4]]
[1] "hello" "hello"

[[5]]
[1] "hello"

If I want something like this, based on values in vector a.

[[1]]
[1] "hello 2"

[[2]]
[1] "hello 3"

[[3]]
[1] "hello 5" "hello 5" "hello 5"

[[4]]
[1] "hello 6" "hello 6"

[[5]]
[1] "hello 7"

What i am actually doing is hmm.. I have a bunch of text files which is
output from another program. I want to extract some specific information
from these files and write to a new file and save it.
All these files have a certain variable k which maybe 2, or 3 or 5 etc. 

vector a shows the k values of 8 of such files. I want the contents of 

files with k value 5 to be written into one file.

Thanks,
Roy



On Mon, Jan 24, 2011 at 11:43 PM, Erik Iverson <eriki at ccbr.umn.edu> 

Roy Mathew wrote:

Thanks for the reply Erik, As you mentioned, grouping consecutive 

of 'a' was my idea. I am unaware of any R'ish way to do it. It would 

if someone in the community knows this.

Is this the idea you're trying to execute?  It uses ?rle and ?mapply.


a <- c(2,3,5,5,5,6,6,7)
mapply(rep, "hello", rle(a)$lengths, USE.NAMES = FALSE)

[[1]]
[1] "hello"

[[2]]
[1] "hello"

[[3]]
[1] "hello" "hello" "hello"

[[4]]
[1] "hello" "hello"

[[5]]
[1] "hello"

-- 
Best Regards,
Roy

   [[alternative HTML version deleted]]

Mr Ripley,

May I ask why seq_len() and seq_along() are better than seq()?

Thanks,
Ivan

Le 1/25/2011 09:58, Prof Brian Ripley a ?crit :

On Tue, 25 Jan 2011, Petr Savicky wrote:

On Mon, Jan 24, 2011 at 11:18:35PM +0100, Roy Mathew wrote:

Thanks for the reply Erik, As you mentioned, grouping consecutive
elements
of 'a' was my idea.
I am unaware of any R'ish way to do it. It would be nice if someone in
the
community knows this.

The error resulting in the NA was pretty easy to fix, and my loop works,
but
the results are still wrong (new script below).
Ideally it should print single "hello" for the single letters and
grouped '3
hellos' for the fives, grouped '2 hellos' for the sixes etc.

Based on the run results, if the value of n is being tracked, it changes
quite unpredictably.
Can someone explain how the value of n changes from end of the loop to
the
top without anything being done to it?

Hi.

A for-loop in R is different from a for-loop in C. It is similar
to foreach loop in Perl. If v is a vector, then

?for (n in v)

first creates the vector v and then always performs length(v) iterations.
Before iteration i, n is assigned v[i] even if n is changed in the
previous iteration.

And also if v is changed during the loop.

If you want to control the loop variable during execution, it is possible
to use a while loop, where you have full control. While loop may be
better
also if v has a very large length, since, for example

?for (n in 1:1000000)

creates a vector of length 1000000 in memory.

It should also be noted that the for-loop

?for (n in 1:k)

performs 2 iterations, if k is 0, since 1:0 is a vector of length 2.
If k may be 0, then it is better to use

?for (n in seq(length=k))

since seq(length=0) has length 0.

Since you keep mentioning that, it is actually much better to use
seq_len(k) (and seq_along(x) instead of your earlier recommendation of
seq(along=x)). ?And if you are using seq() in other cases in programs,
consider seq.int() instead.

Hope this helps.

Petr Savicky.

--
Ivan CALANDRA
PhD Student
University of Hamburg
Biozentrum Grindel und Zoologisches Museum
Abt. S?ugetiere
Martin-Luther-King-Platz 3
D-20146 Hamburg, GERMANY
+49(0)40 42838 6231
ivan.calandra at uni-hamburg.de

**********
http://www.for771.uni-bonn.de
http://webapp5.rrz.uni-hamburg.de/mammals/eng/1525_8_1.php

Well, I'm not Prof. Ripley, but the answer is: Look at the code.
seq_len, seq.int, and seq_along call Primitives, which are implemented
in C, and therefore MUCH faster than seq(), which is implemented as
pure R code (and is also a generic, so requires method dispatch).
Though for small n (up to a few thousand, say), it probably doesn't
make much difference.(Here, to be corrected by Prof. Ripley is
needed).

-- Bert

On Tue, Jan 25, 2011 at 2:22 AM, Ivan Calandra
<ivan.calandra at uni-hamburg.de>  wrote:

Mr Ripley,

May I ask why seq_len() and seq_along() are better than seq()?

Thanks,
Ivan

Le 1/25/2011 09:58, Prof Brian Ripley a ?crit :

On Tue, 25 Jan 2011, Petr Savicky wrote:

On Mon, Jan 24, 2011 at 11:18:35PM +0100, Roy Mathew wrote:

Thanks for the reply Erik, As you mentioned, grouping consecutive
elements
of 'a' was my idea.
I am unaware of any R'ish way to do it. It would be nice if someone in
the
community knows this.

The error resulting in the NA was pretty easy to fix, and my loop works,
but
the results are still wrong (new script below).
Ideally it should print single "hello" for the single letters and
grouped '3
hellos' for the fives, grouped '2 hellos' for the sixes etc.

Based on the run results, if the value of n is being tracked, it changes
quite unpredictably.
Can someone explain how the value of n changes from end of the loop to
the
top without anything being done to it?

Hi.

A for-loop in R is different from a for-loop in C. It is similar
to foreach loop in Perl. If v is a vector, then

  for (n in v)

first creates the vector v and then always performs length(v) iterations.
Before iteration i, n is assigned v[i] even if n is changed in the
previous iteration.

And also if v is changed during the loop.

If you want to control the loop variable during execution, it is possible
to use a while loop, where you have full control. While loop may be
better
also if v has a very large length, since, for example

  for (n in 1:1000000)

creates a vector of length 1000000 in memory.

It should also be noted that the for-loop

  for (n in 1:k)

performs 2 iterations, if k is 0, since 1:0 is a vector of length 2.
If k may be 0, then it is better to use

  for (n in seq(length=k))

since seq(length=0) has length 0.

Since you keep mentioning that, it is actually much better to use
seq_len(k) (and seq_along(x) instead of your earlier recommendation of
seq(along=x)).  And if you are using seq() in other cases in programs,
consider seq.int() instead.

Hope this helps.

Petr Savicky.

--
Ivan CALANDRA
PhD Student
University of Hamburg
Biozentrum Grindel und Zoologisches Museum
Abt. S?ugetiere
Martin-Luther-King-Platz 3
D-20146 Hamburg, GERMANY
+49(0)40 42838 6231
ivan.calandra at uni-hamburg.de

**********
http://www.for771.uni-bonn.de
http://webapp5.rrz.uni-hamburg.de/mammals/eng/1525_8_1.php

If k may be 0, then it is better to use

for (n in seq(length=k))

since seq(length=0) has length 0.

Since you keep mentioning that, it is actually much better to use 
seq_len(k) (and seq_along(x) instead of your earlier recommendation of 
seq(along=x)).  And if you are using seq() in other cases in programs, 
consider seq.int() instead.