Is this a bug in `[`?

Previous Topic Next Topic
 
classic Classic list List threaded Threaded
8 messages Options
Reply | Threaded
Open this post in threaded view
|

Is this a bug in `[`?

Rui Barradas
Hello,

Maybe I am not understanding how negative indexing works but

1) This is right.

(1:10)[-1]
#[1]  2  3  4  5  6  7  8  9 10

2) Are these right? They are at least surprising to me.

(1:10)[-0]
#integer(0)

(1:10)[-seq_len(0)]
#integer(0)


It was the last example that made me ask, seq_len(0) whould avoid an
if/else or something similar.


Thanks in advance,

Rui Barradas

______________________________________________
[hidden email] mailing list
https://stat.ethz.ch/mailman/listinfo/r-devel
Reply | Threaded
Open this post in threaded view
|

Re: Is this a bug in `[`?

Iñaki Úcar
El sáb., 4 ago. 2018 a las 15:32, Rui Barradas
(<[hidden email]>) escribió:

>
> Hello,
>
> Maybe I am not understanding how negative indexing works but
>
> 1) This is right.
>
> (1:10)[-1]
> #[1]  2  3  4  5  6  7  8  9 10
>
> 2) Are these right? They are at least surprising to me.
>
> (1:10)[-0]
> #integer(0)
>
> (1:10)[-seq_len(0)]
> #integer(0)
>
>
> It was the last example that made me ask, seq_len(0) whould avoid an
> if/else or something similar.

I think it's ok, because there is no negative zero integer, so -0 is 0.

1.0/-0L # Inf
1.0/-0.0 # - Inf

And the same can be said for integer(0), which is the result of
seq_len(0): there is no negative empty integer.

Iñaki

>
>
> Thanks in advance,
>
> Rui Barradas
>
> ______________________________________________
> [hidden email] mailing list
> https://stat.ethz.ch/mailman/listinfo/r-devel

______________________________________________
[hidden email] mailing list
https://stat.ethz.ch/mailman/listinfo/r-devel
Reply | Threaded
Open this post in threaded view
|

Re: Is this a bug in `[`?

Rui Barradas


Às 15:51 de 04/08/2018, Iñaki Úcar escreveu:

> El sáb., 4 ago. 2018 a las 15:32, Rui Barradas
> (<[hidden email]>) escribió:
>>
>> Hello,
>>
>> Maybe I am not understanding how negative indexing works but
>>
>> 1) This is right.
>>
>> (1:10)[-1]
>> #[1]  2  3  4  5  6  7  8  9 10
>>
>> 2) Are these right? They are at least surprising to me.
>>
>> (1:10)[-0]
>> #integer(0)
>>
>> (1:10)[-seq_len(0)]
>> #integer(0)
>>
>>
>> It was the last example that made me ask, seq_len(0) whould avoid an
>> if/else or something similar.
>
> I think it's ok, because there is no negative zero integer, so -0 is 0.

Ok, this makes sense, I should have thought about that.

>
> 1.0/-0L # Inf
> 1.0/-0.0 # - Inf
>
> And the same can be said for integer(0), which is the result of
> seq_len(0): there is no negative empty integer.

I'm not completely convinced about this one, though.
I would expect -seq_len(n) to remove the first n elements from the
vector, therefore, when n == 0, it would remove none.

And integer(0) is not the same as 0.

(1:10)[-0] == (1:10)[0] == integer(0) # empty

(1:10)[-seq_len(0)] == (1:10)[-integer(0)]


And I have just reminded myself to run

identical(-integer(0), integer(0))

It returns TRUE so my intuition is wrong, R is right.
End of story.

Thanks for the help,

Rui Barradas

>
> Iñaki
>
>>
>>
>> Thanks in advance,
>>
>> Rui Barradas
>>
>> ______________________________________________
>> [hidden email] mailing list
>> https://stat.ethz.ch/mailman/listinfo/r-devel

______________________________________________
[hidden email] mailing list
https://stat.ethz.ch/mailman/listinfo/r-devel
Reply | Threaded
Open this post in threaded view
|

Re: Is this a bug in `[`?

Kenny Bell-2
This should more clearly illustrate the issue:

c(1, 2, 3, 4)[-seq_len(4)]
#> numeric(0)
c(1, 2, 3, 4)[-seq_len(3)]
#> [1] 4
c(1, 2, 3, 4)[-seq_len(2)]
#> [1] 3 4
c(1, 2, 3, 4)[-seq_len(1)]
#> [1] 2 3 4
c(1, 2, 3, 4)[-seq_len(0)]
#> numeric(0)
Created on 2018-08-05 by the reprex package (v0.2.0.9000).

On Sun, Aug 5, 2018 at 3:58 AM Rui Barradas <[hidden email]> wrote:

>
>
> Às 15:51 de 04/08/2018, Iñaki Úcar escreveu:
> > El sáb., 4 ago. 2018 a las 15:32, Rui Barradas
> > (<[hidden email]>) escribió:
> >>
> >> Hello,
> >>
> >> Maybe I am not understanding how negative indexing works but
> >>
> >> 1) This is right.
> >>
> >> (1:10)[-1]
> >> #[1]  2  3  4  5  6  7  8  9 10
> >>
> >> 2) Are these right? They are at least surprising to me.
> >>
> >> (1:10)[-0]
> >> #integer(0)
> >>
> >> (1:10)[-seq_len(0)]
> >> #integer(0)
> >>
> >>
> >> It was the last example that made me ask, seq_len(0) whould avoid an
> >> if/else or something similar.
> >
> > I think it's ok, because there is no negative zero integer, so -0 is 0.
>
> Ok, this makes sense, I should have thought about that.
>
> >
> > 1.0/-0L # Inf
> > 1.0/-0.0 # - Inf
> >
> > And the same can be said for integer(0), which is the result of
> > seq_len(0): there is no negative empty integer.
>
> I'm not completely convinced about this one, though.
> I would expect -seq_len(n) to remove the first n elements from the
> vector, therefore, when n == 0, it would remove none.
>
> And integer(0) is not the same as 0.
>
> (1:10)[-0] == (1:10)[0] == integer(0) # empty
>
> (1:10)[-seq_len(0)] == (1:10)[-integer(0)]
>
>
> And I have just reminded myself to run
>
> identical(-integer(0), integer(0))
>
> It returns TRUE so my intuition is wrong, R is right.
> End of story.
>
> Thanks for the help,
>
> Rui Barradas
>
> >
> > Iñaki
> >
> >>
> >>
> >> Thanks in advance,
> >>
> >> Rui Barradas
> >>
> >> ______________________________________________
> >> [hidden email] mailing list
> >> https://stat.ethz.ch/mailman/listinfo/r-devel
>
> ______________________________________________
> [hidden email] mailing list
> https://stat.ethz.ch/mailman/listinfo/r-devel
>

        [[alternative HTML version deleted]]

______________________________________________
[hidden email] mailing list
https://stat.ethz.ch/mailman/listinfo/r-devel
Reply | Threaded
Open this post in threaded view
|

Re: Is this a bug in `[`?

Rui Barradas
Thanks.
This is exactly the doubt I had.

Rui Barradas

Às 05:26 de 05/08/2018, Kenny Bell escreveu:

> This should more clearly illustrate the issue:
>
> c(1, 2, 3, 4)[-seq_len(4)]
> #> numeric(0)
> c(1, 2, 3, 4)[-seq_len(3)]
> #> [1] 4
> c(1, 2, 3, 4)[-seq_len(2)]
> #> [1] 3 4
> c(1, 2, 3, 4)[-seq_len(1)]
> #> [1] 2 3 4
> c(1, 2, 3, 4)[-seq_len(0)]
> #> numeric(0)
> Created on 2018-08-05 by the reprex package (v0.2.0.9000).
>
> On Sun, Aug 5, 2018 at 3:58 AM Rui Barradas <[hidden email]
> <mailto:[hidden email]>> wrote:
>
>
>
>     Às 15:51 de 04/08/2018, Iñaki Úcar escreveu:
>      > El sáb., 4 ago. 2018 a las 15:32, Rui Barradas
>      > (<[hidden email] <mailto:[hidden email]>>) escribió:
>      >>
>      >> Hello,
>      >>
>      >> Maybe I am not understanding how negative indexing works but
>      >>
>      >> 1) This is right.
>      >>
>      >> (1:10)[-1]
>      >> #[1]  2  3  4  5  6  7  8  9 10
>      >>
>      >> 2) Are these right? They are at least surprising to me.
>      >>
>      >> (1:10)[-0]
>      >> #integer(0)
>      >>
>      >> (1:10)[-seq_len(0)]
>      >> #integer(0)
>      >>
>      >>
>      >> It was the last example that made me ask, seq_len(0) whould avoid an
>      >> if/else or something similar.
>      >
>      > I think it's ok, because there is no negative zero integer, so -0
>     is 0.
>
>     Ok, this makes sense, I should have thought about that.
>
>      >
>      > 1.0/-0L # Inf
>      > 1.0/-0.0 # - Inf
>      >
>      > And the same can be said for integer(0), which is the result of
>      > seq_len(0): there is no negative empty integer.
>
>     I'm not completely convinced about this one, though.
>     I would expect -seq_len(n) to remove the first n elements from the
>     vector, therefore, when n == 0, it would remove none.
>
>     And integer(0) is not the same as 0.
>
>     (1:10)[-0] == (1:10)[0] == integer(0) # empty
>
>     (1:10)[-seq_len(0)] == (1:10)[-integer(0)]
>
>
>     And I have just reminded myself to run
>
>     identical(-integer(0), integer(0))
>
>     It returns TRUE so my intuition is wrong, R is right.
>     End of story.
>
>     Thanks for the help,
>
>     Rui Barradas
>
>      >
>      > Iñaki
>      >
>      >>
>      >>
>      >> Thanks in advance,
>      >>
>      >> Rui Barradas
>      >>
>      >> ______________________________________________
>      >> [hidden email] <mailto:[hidden email]> mailing list
>      >> https://stat.ethz.ch/mailman/listinfo/r-devel
>
>     ______________________________________________
>     [hidden email] <mailto:[hidden email]> mailing list
>     https://stat.ethz.ch/mailman/listinfo/r-devel
>

______________________________________________
[hidden email] mailing list
https://stat.ethz.ch/mailman/listinfo/r-devel
Reply | Threaded
Open this post in threaded view
|

Re: Is this a bug in `[`?

Patrick Burns
This is Circle 8..1.13 of the R Inferno.


On 05/08/2018 06:57, Rui Barradas wrote:

> Thanks.
> This is exactly the doubt I had.
>
> Rui Barradas
>
> Às 05:26 de 05/08/2018, Kenny Bell escreveu:
>> This should more clearly illustrate the issue:
>>
>> c(1, 2, 3, 4)[-seq_len(4)]
>> #> numeric(0)
>> c(1, 2, 3, 4)[-seq_len(3)]
>> #> [1] 4
>> c(1, 2, 3, 4)[-seq_len(2)]
>> #> [1] 3 4
>> c(1, 2, 3, 4)[-seq_len(1)]
>> #> [1] 2 3 4
>> c(1, 2, 3, 4)[-seq_len(0)]
>> #> numeric(0)
>> Created on 2018-08-05 by the reprex package (v0.2.0.9000).
>>
>> On Sun, Aug 5, 2018 at 3:58 AM Rui Barradas <[hidden email]
>> <mailto:[hidden email]>> wrote:
>>
>>
>>
>>     Às 15:51 de 04/08/2018, Iñaki Úcar escreveu:
>>      > El sáb., 4 ago. 2018 a las 15:32, Rui Barradas
>>      > (<[hidden email] <mailto:[hidden email]>>) escribió:
>>      >>
>>      >> Hello,
>>      >>
>>      >> Maybe I am not understanding how negative indexing works but
>>      >>
>>      >> 1) This is right.
>>      >>
>>      >> (1:10)[-1]
>>      >> #[1]  2  3  4  5  6  7  8  9 10
>>      >>
>>      >> 2) Are these right? They are at least surprising to me.
>>      >>
>>      >> (1:10)[-0]
>>      >> #integer(0)
>>      >>
>>      >> (1:10)[-seq_len(0)]
>>      >> #integer(0)
>>      >>
>>      >>
>>      >> It was the last example that made me ask, seq_len(0) whould
>> avoid an
>>      >> if/else or something similar.
>>      >
>>      > I think it's ok, because there is no negative zero integer, so -0
>>     is 0.
>>
>>     Ok, this makes sense, I should have thought about that.
>>
>>      >
>>      > 1.0/-0L # Inf
>>      > 1.0/-0.0 # - Inf
>>      >
>>      > And the same can be said for integer(0), which is the result of
>>      > seq_len(0): there is no negative empty integer.
>>
>>     I'm not completely convinced about this one, though.
>>     I would expect -seq_len(n) to remove the first n elements from the
>>     vector, therefore, when n == 0, it would remove none.
>>
>>     And integer(0) is not the same as 0.
>>
>>     (1:10)[-0] == (1:10)[0] == integer(0) # empty
>>
>>     (1:10)[-seq_len(0)] == (1:10)[-integer(0)]
>>
>>
>>     And I have just reminded myself to run
>>
>>     identical(-integer(0), integer(0))
>>
>>     It returns TRUE so my intuition is wrong, R is right.
>>     End of story.
>>
>>     Thanks for the help,
>>
>>     Rui Barradas
>>
>>      >
>>      > Iñaki
>>      >
>>      >>
>>      >>
>>      >> Thanks in advance,
>>      >>
>>      >> Rui Barradas
>>      >>
>>      >> ______________________________________________
>>      >> [hidden email] <mailto:[hidden email]> mailing list
>>      >> https://stat.ethz.ch/mailman/listinfo/r-devel
>>
>>     ______________________________________________
>>     [hidden email] <mailto:[hidden email]> mailing list
>>     https://stat.ethz.ch/mailman/listinfo/r-devel
>>
>
> ______________________________________________
> [hidden email] mailing list
> https://stat.ethz.ch/mailman/listinfo/r-devel
>

--
Patrick Burns
[hidden email]
twitter: @burnsstat @portfolioprobe
http://www.portfolioprobe.com/blog
http://www.burns-stat.com
(home of:
  'Impatient R'
  'The R Inferno'
  'Tao Te Programming')

______________________________________________
[hidden email] mailing list
https://stat.ethz.ch/mailman/listinfo/r-devel
Reply | Threaded
Open this post in threaded view
|

Re: Is this a bug in `[`?

Rui Barradas
Thanks,

This is what I needed.
I had read the R Inferno a long time ago and apparently forgot this one.

Rui Barradas

Às 08:46 de 05/08/2018, Patrick Burns escreveu:

> This is Circle 8..1.13 of the R Inferno.
>
>
> On 05/08/2018 06:57, Rui Barradas wrote:
>> Thanks.
>> This is exactly the doubt I had.
>>
>> Rui Barradas
>>
>> Às 05:26 de 05/08/2018, Kenny Bell escreveu:
>>> This should more clearly illustrate the issue:
>>>
>>> c(1, 2, 3, 4)[-seq_len(4)]
>>> #> numeric(0)
>>> c(1, 2, 3, 4)[-seq_len(3)]
>>> #> [1] 4
>>> c(1, 2, 3, 4)[-seq_len(2)]
>>> #> [1] 3 4
>>> c(1, 2, 3, 4)[-seq_len(1)]
>>> #> [1] 2 3 4
>>> c(1, 2, 3, 4)[-seq_len(0)]
>>> #> numeric(0)
>>> Created on 2018-08-05 by the reprex package (v0.2.0.9000).
>>>
>>> On Sun, Aug 5, 2018 at 3:58 AM Rui Barradas <[hidden email]
>>> <mailto:[hidden email]>> wrote:
>>>
>>>
>>>
>>>     Às 15:51 de 04/08/2018, Iñaki Úcar escreveu:
>>>      > El sáb., 4 ago. 2018 a las 15:32, Rui Barradas
>>>      > (<[hidden email] <mailto:[hidden email]>>) escribió:
>>>      >>
>>>      >> Hello,
>>>      >>
>>>      >> Maybe I am not understanding how negative indexing works but
>>>      >>
>>>      >> 1) This is right.
>>>      >>
>>>      >> (1:10)[-1]
>>>      >> #[1]  2  3  4  5  6  7  8  9 10
>>>      >>
>>>      >> 2) Are these right? They are at least surprising to me.
>>>      >>
>>>      >> (1:10)[-0]
>>>      >> #integer(0)
>>>      >>
>>>      >> (1:10)[-seq_len(0)]
>>>      >> #integer(0)
>>>      >>
>>>      >>
>>>      >> It was the last example that made me ask, seq_len(0) whould
>>> avoid an
>>>      >> if/else or something similar.
>>>      >
>>>      > I think it's ok, because there is no negative zero integer, so -0
>>>     is 0.
>>>
>>>     Ok, this makes sense, I should have thought about that.
>>>
>>>      >
>>>      > 1.0/-0L # Inf
>>>      > 1.0/-0.0 # - Inf
>>>      >
>>>      > And the same can be said for integer(0), which is the result of
>>>      > seq_len(0): there is no negative empty integer.
>>>
>>>     I'm not completely convinced about this one, though.
>>>     I would expect -seq_len(n) to remove the first n elements from the
>>>     vector, therefore, when n == 0, it would remove none.
>>>
>>>     And integer(0) is not the same as 0.
>>>
>>>     (1:10)[-0] == (1:10)[0] == integer(0) # empty
>>>
>>>     (1:10)[-seq_len(0)] == (1:10)[-integer(0)]
>>>
>>>
>>>     And I have just reminded myself to run
>>>
>>>     identical(-integer(0), integer(0))
>>>
>>>     It returns TRUE so my intuition is wrong, R is right.
>>>     End of story.
>>>
>>>     Thanks for the help,
>>>
>>>     Rui Barradas
>>>
>>>      >
>>>      > Iñaki
>>>      >
>>>      >>
>>>      >>
>>>      >> Thanks in advance,
>>>      >>
>>>      >> Rui Barradas
>>>      >>
>>>      >> ______________________________________________
>>>      >> [hidden email] <mailto:[hidden email]> mailing
>>> list
>>>      >> https://stat.ethz.ch/mailman/listinfo/r-devel
>>>
>>>     ______________________________________________
>>>     [hidden email] <mailto:[hidden email]> mailing list
>>>     https://stat.ethz.ch/mailman/listinfo/r-devel
>>>
>>
>> ______________________________________________
>> [hidden email] mailing list
>> https://stat.ethz.ch/mailman/listinfo/r-devel
>>
>

______________________________________________
[hidden email] mailing list
https://stat.ethz.ch/mailman/listinfo/r-devel
Reply | Threaded
Open this post in threaded view
|

Re: Is this a bug in `[`?

Iñaki Úcar
In reply to this post by Kenny Bell-2
El dom., 5 ago. 2018 a las 6:27, Kenny Bell (<[hidden email]>) escribió:

>
> This should more clearly illustrate the issue:
>
> c(1, 2, 3, 4)[-seq_len(4)]
> #> numeric(0)
> c(1, 2, 3, 4)[-seq_len(3)]
> #> [1] 4
> c(1, 2, 3, 4)[-seq_len(2)]
> #> [1] 3 4
> c(1, 2, 3, 4)[-seq_len(1)]
> #> [1] 2 3 4
> c(1, 2, 3, 4)[-seq_len(0)]
> #> numeric(0)
> Created on 2018-08-05 by the reprex package (v0.2.0.9000).

IMO, the problem is that you are reading it sequentially: "-" remove
"seq_" a sequence "len(0)" of length zero. But that's not how R works
(how programming languages work in general). Instead, the sequence is
evaluated in the first place, and then the sign may apply as long as
you provided something that can hold a sign. And an empty element has
no sign, so the sign is lost.

Iñaki

>
> On Sun, Aug 5, 2018 at 3:58 AM Rui Barradas <[hidden email]> wrote:
>>
>>
>>
>> Às 15:51 de 04/08/2018, Iñaki Úcar escreveu:
>> > El sáb., 4 ago. 2018 a las 15:32, Rui Barradas
>> > (<[hidden email]>) escribió:
>> >>
>> >> Hello,
>> >>
>> >> Maybe I am not understanding how negative indexing works but
>> >>
>> >> 1) This is right.
>> >>
>> >> (1:10)[-1]
>> >> #[1]  2  3  4  5  6  7  8  9 10
>> >>
>> >> 2) Are these right? They are at least surprising to me.
>> >>
>> >> (1:10)[-0]
>> >> #integer(0)
>> >>
>> >> (1:10)[-seq_len(0)]
>> >> #integer(0)
>> >>
>> >>
>> >> It was the last example that made me ask, seq_len(0) whould avoid an
>> >> if/else or something similar.
>> >
>> > I think it's ok, because there is no negative zero integer, so -0 is 0.
>>
>> Ok, this makes sense, I should have thought about that.
>>
>> >
>> > 1.0/-0L # Inf
>> > 1.0/-0.0 # - Inf
>> >
>> > And the same can be said for integer(0), which is the result of
>> > seq_len(0): there is no negative empty integer.
>>
>> I'm not completely convinced about this one, though.
>> I would expect -seq_len(n) to remove the first n elements from the
>> vector, therefore, when n == 0, it would remove none.
>>
>> And integer(0) is not the same as 0.
>>
>> (1:10)[-0] == (1:10)[0] == integer(0) # empty
>>
>> (1:10)[-seq_len(0)] == (1:10)[-integer(0)]
>>
>>
>> And I have just reminded myself to run
>>
>> identical(-integer(0), integer(0))
>>
>> It returns TRUE so my intuition is wrong, R is right.
>> End of story.
>>
>> Thanks for the help,
>>
>> Rui Barradas
>>
>> >
>> > Iñaki
>> >
>> >>
>> >>
>> >> Thanks in advance,
>> >>
>> >> Rui Barradas
>> >>
>> >> ______________________________________________
>> >> [hidden email] mailing list
>> >> https://stat.ethz.ch/mailman/listinfo/r-devel
>>
>> ______________________________________________
>> [hidden email] mailing list
>> https://stat.ethz.ch/mailman/listinfo/r-devel

______________________________________________
[hidden email] mailing list
https://stat.ethz.ch/mailman/listinfo/r-devel