R devel - Apr 2005 - a couple of things about ":"

Dear R-devel,

A colleague was recently surprised by the behavior of the ":" operator
(as
sequence generator), so I decided to dig a little bit.  Here are a couple of
things I found.

-  ?":" seems a bit imprecise.  The Details section says:

`The operator : and the seq(from, to) form generate the sequence from,
from+1, ..., to.'

but `to' is not necessarily included in the output; e.g.,
> 0.5:3
[1] 0.5 1.5 2.5

Then it says: `The second form generates from, from+by, ..., up to the
sequence value less than or equal to to.'  That's not necessarily true,
either, if `by' is negative:
> 0.5:-3
[1]  0.5 -0.5 -1.5 -2.5

- It seems counter-intuitive to allow non-integer values as operand for
":".
It also seems a bit odd that 1:2 returns something with storage.mode
integer, whereas 0.5:2 gives doubles.  Would it make sense to disallow
non-integer operands to ":"?  I can't think of a situation when
non-integer
operands for ":" would be good...

Best,
Andy

On Thu, 7 Apr 2005, Liaw, Andy wrote:
> - It seems counter-intuitive to allow non-integer values as operand for
":".
> It also seems a bit odd that 1:2 returns something with storage.mode
> integer, whereas 0.5:2 gives doubles.  Would it make sense to disallow
> non-integer operands to ":"?  I can't think of a situation
when non-integer
> operands for ":" would be good...
>
It depends on what you mean by non-integer.  You certainly want to allow 
operand with storage.mode "double".  You might want to exclude 
non-integers, but then you have problems with rounding:

   a<-sqrt(2)
   b<-sqrt(3)
   (a^2):(b^2)

would fail.  Allowing non-integers up to some tolerance would be needed, 
but then there isn't much reason to forbid 0.5:2, and someone might have a 
use for it.


 	-thomas

> From: Thomas Lumley 
> 
> On Thu, 7 Apr 2005, Liaw, Andy wrote:
> 
> > - It seems counter-intuitive to allow non-integer values as 
> operand for ":".
> > It also seems a bit odd that 1:2 returns something with storage.mode
> > integer, whereas 0.5:2 gives doubles.  Would it make sense 
> to disallow
> > non-integer operands to ":"?  I can't think of a
situation
> when non-integer
> > operands for ":" would be good...
> >
> 
> It depends on what you mean by non-integer.  You certainly 
> want to allow 
> operand with storage.mode "double".  You might want to exclude 
> non-integers, but then you have problems with rounding:
> 
>    a<-sqrt(2)
>    b<-sqrt(3)
>    (a^2):(b^2)
> 
> would fail.  Allowing non-integers up to some tolerance would 
> be needed, 
I think the fact that we don't need to do as.integer(1):as.integer(3) in
order for ":" to return an integer vector must means that there's
some
tolerance built-in.  (I know, I should just check the source...)  Here are
some experiments (R-devel 2005-03-11 on WinXPPro):
> storage.mode((1 + .Machine$double.eps):3)
[1] "double"
> storage.mode((1 - .Machine$double.eps/4):3)
[1] "integer"
> storage.mode((1 + .Machine$double.eps/4):3)
[1] "integer"
> storage.mode((1 + .Machine$double.eps/3):3)
[1] "integer"
> storage.mode((1 - .Machine$double.eps/3):3)
[1] "double"
> but then there isn't much reason to forbid 0.5:2, and someone 
> might have a use for it.
IMHO that's more of a trap than a `feature'.  At least to me it's
not
immediately obvious what one should expect when the first operand is an
`obvious' non-integer such as 0.5.  For such sequences, I'd say one
should
really use seq() instead of ":".  (I'd go as far as saying that
something
like 0.5:2 is an abuse.)

BTW, here's something that surprised me:
> x <- 1:10
> i <- (1 + 1e-15):5
> i
[1] 1 2 3 4 5
> x[i]
[1] 1 2 3 4 5
> i <- (1 - 1e-15):5
> i
[1] 1 2 3 4 5
> x[i]
[1] 1 2 3 4

The reason for this, of course, is that (as ?"[" explains):
> as.integer(i)
[1] 0 1 2 3 4

My wish would be for ":" to coerce its operands to integers, perhaps
with a
bit more tolerance, and always return object of integer storage mode.

Cheers,
Andy
 
> 
>  	-thomas
> 
> 
>