Re: [R] c(1:n, 1:(n-1), 1:(n-2), ... , 1)

[Frank Schwidom]

Hi

I have to correct myself, this last solution is not universally valid

here a better one:

tmp1 <- ( 1 - outer( max( x):1, x, FUN='-'))
tmp1[ tmp1 > 0]


On 2015-09-17 21:06:30, Frank Schwidom wrote:
> 
> how abount a more complicated one?
> 
> outer( 1:5, 1:5, '-')[ outer( 1:5, 1:5, '>')]
>  [1] 1 2 3 4 1 2 3 1 2 1
> 
> 
> On Thu, Sep 17, 2015 at 11:52:27AM -0700, David Winsemius wrote:
> > You can add this to the list of options to be tested, although my bet would 
> > be placed on `sequence(5:1)`:
> > 
> > > Reduce( function(x,y){c( 1:y, x)}, 1:5)
> >  [1] 1 2 3 4 5 1 2 3 4 1 2 3 1 2 1
> > 
> > 
> > On Sep 17, 2015, at 11:40 AM, Achim Zeileis wrote:
> > 
> > > On Thu, 17 Sep 2015, Peter Langfelder wrote:
> > > 
> > >> Not sure if this is slicker or easier to follow than your solution,
> > >> but it is shorter :)
> > >> 
> > >> do.call(c, lapply(n:1, function(n1) 1:n1))
> > > 
> > > Also not sure about efficiency but somewhat shorter...
> > > unlist(lapply(5:1, seq))
> > > 
> > >> Peter
> > >> 
> > >> On Thu, Sep 17, 2015 at 11:19 AM, Dan D  wrote:
> > >>> Can anyone think of a slick way to create an array that looks like 
> > >>> c(1:n,
> > >>> 1:(n-1), 1:(n-2), ... , 1)?
> > >>> 
> > >>> The following works, but it's inefficient and a little hard to follow:
> > >>> n<-5
> > >>> junk<-array(1:n,dim=c(n,n))
> > >>> junk[((lower.tri(t(junk),diag=T)))[n:1,]]
> > >>> 
> > >>> Any help would be greatly appreciated!
> > >>> 
> > >>> -Dan
> > >>> 
> > >>> 
> > 
> > David Winsemius
> > Alameda, CA, USA
> > 
> > __
> > R-help@r-project.org mailing list -- To UNSUBSCRIBE and more, see
> > https://stat.ethz.ch/mailman/listinfo/r-help
> > PLEASE do read the posting guide http://www.R-project.org/posting-guide.html
> > and provide commented, minimal, self-contained, reproducible code.
> >
> 
> __
> R-help@r-project.org mailing list -- To UNSUBSCRIBE and more, see
> https://stat.ethz.ch/mailman/listinfo/r-help
> PLEASE do read the posting guide http://www.R-project.org/posting-guide.html
> and provide commented, minimal, self-contained, reproducible code.
>

__
R-help@r-project.org mailing list -- To UNSUBSCRIBE and more, see
https://stat.ethz.ch/mailman/listinfo/r-help
PLEASE do read the posting guide http://www.R-project.org/posting-guide.html
and provide commented, minimal, self-contained, reproducible code.

Re: [R] c(1:n, 1:(n-1), 1:(n-2), ... , 1)

[Achim Zeileis]

On Thu, 17 Sep 2015, Peter Langfelder wrote:


Not sure if this is slicker or easier to follow than your solution,
but it is shorter :)

do.call(c, lapply(n:1, function(n1) 1:n1))


Also not sure about efficiency but somewhat shorter...
unlist(lapply(5:1, seq))


Peter

On Thu, Sep 17, 2015 at 11:19 AM, Dan D  wrote:

Can anyone think of a slick way to create an array that looks like c(1:n,
1:(n-1), 1:(n-2), ... , 1)?

The following works, but it's inefficient and a little hard to follow:
n<-5
junk<-array(1:n,dim=c(n,n))
junk[((lower.tri(t(junk),diag=T)))[n:1,]]

Any help would be greatly appreciated!

-Dan



--
View this message in context: 
http://r.789695.n4.nabble.com/c-1-n-1-n-1-1-n-2-1-tp4712390.html
Sent from the R help mailing list archive at Nabble.com.

__
R-help@r-project.org mailing list -- To UNSUBSCRIBE and more, see
https://stat.ethz.ch/mailman/listinfo/r-help
PLEASE do read the posting guide http://www.R-project.org/posting-guide.html
and provide commented, minimal, self-contained, reproducible code.


__
R-help@r-project.org mailing list -- To UNSUBSCRIBE and more, see
https://stat.ethz.ch/mailman/listinfo/r-help
PLEASE do read the posting guide http://www.R-project.org/posting-guide.html
and provide commented, minimal, self-contained, reproducible code.



__
R-help@r-project.org mailing list -- To UNSUBSCRIBE and more, see
https://stat.ethz.ch/mailman/listinfo/r-help
PLEASE do read the posting guide http://www.R-project.org/posting-guide.html
and provide commented, minimal, self-contained, reproducible code.

Re: [R] c(1:n, 1:(n-1), 1:(n-2), ... , 1)

[Peter Langfelder]

Not sure if this is slicker or easier to follow than your solution,
but it is shorter :)

do.call(c, lapply(n:1, function(n1) 1:n1))

Peter

On Thu, Sep 17, 2015 at 11:19 AM, Dan D  wrote:
> Can anyone think of a slick way to create an array that looks like c(1:n,
> 1:(n-1), 1:(n-2), ... , 1)?
>
> The following works, but it's inefficient and a little hard to follow:
> n<-5
> junk<-array(1:n,dim=c(n,n))
> junk[((lower.tri(t(junk),diag=T)))[n:1,]]
>
> Any help would be greatly appreciated!
>
> -Dan
>
>
>
> --
> View this message in context: 
> http://r.789695.n4.nabble.com/c-1-n-1-n-1-1-n-2-1-tp4712390.html
> Sent from the R help mailing list archive at Nabble.com.
>
> __
> R-help@r-project.org mailing list -- To UNSUBSCRIBE and more, see
> https://stat.ethz.ch/mailman/listinfo/r-help
> PLEASE do read the posting guide http://www.R-project.org/posting-guide.html
> and provide commented, minimal, self-contained, reproducible code.

__
R-help@r-project.org mailing list -- To UNSUBSCRIBE and more, see
https://stat.ethz.ch/mailman/listinfo/r-help
PLEASE do read the posting guide http://www.R-project.org/posting-guide.html
and provide commented, minimal, self-contained, reproducible code.

Re: [R] c(1:n, 1:(n-1), 1:(n-2), ... , 1)

[Frank Schwidom]

sequence( 5:1)

Regards.

On Thu, Sep 17, 2015 at 11:19:05AM -0700, Dan D wrote:
> Can anyone think of a slick way to create an array that looks like c(1:n,
> 1:(n-1), 1:(n-2), ... , 1)?
> 
> The following works, but it's inefficient and a little hard to follow:
> n<-5
> junk<-array(1:n,dim=c(n,n))
> junk[((lower.tri(t(junk),diag=T)))[n:1,]]
> 
> Any help would be greatly appreciated!
> 
> -Dan
> 
> 
> 
> --
> View this message in context: 
> http://r.789695.n4.nabble.com/c-1-n-1-n-1-1-n-2-1-tp4712390.html
> Sent from the R help mailing list archive at Nabble.com.
> 
> __
> R-help@r-project.org mailing list -- To UNSUBSCRIBE and more, see
> https://stat.ethz.ch/mailman/listinfo/r-help
> PLEASE do read the posting guide http://www.R-project.org/posting-guide.html
> and provide commented, minimal, self-contained, reproducible code.
>

__
R-help@r-project.org mailing list -- To UNSUBSCRIBE and more, see
https://stat.ethz.ch/mailman/listinfo/r-help
PLEASE do read the posting guide http://www.R-project.org/posting-guide.html
and provide commented, minimal, self-contained, reproducible code.

Re: [R] c(1:n, 1:(n-1), 1:(n-2), ... , 1)

[John McKown]

I'm not too sure this is any better:

n<-5
c<-0; # establish result as numeric
for(i in seq(n,1,-1)){ c<-c(c,seq(1,i)); str(c); }; #generate array
c<-c[2:length(c)]; #remove the leading 0

If you're a fan of recursive programming:

> mklist <- function(x) { if (x==1) return(1) else return(
c(seq(1,x),mklist(x-1)) ) ; }
> mklist(5);
 [1] 1 2 3 4 5 1 2 3 4 1 2 3 1 2 1
>

Of course, I've not done any error checking in my function definition. And,
for large values, it can nest too deeply and get

Error: evaluation nested too deeply: infinite recursion /
options(expressions=)?


On Thu, Sep 17, 2015 at 1:19 PM, Dan D  wrote:

> Can anyone think of a slick way to create an array that looks like c(1:n,
> 1:(n-1), 1:(n-2), ... , 1)?
>
> The following works, but it's inefficient and a little hard to follow:
> n<-5
> junk<-array(1:n,dim=c(n,n))
> junk[((lower.tri(t(junk),diag=T)))[n:1,]]
>
> Any help would be greatly appreciated!
>
> -Dan
>
>
>
> --
> View this message in context:
> http://r.789695.n4.nabble.com/c-1-n-1-n-1-1-n-2-1-tp4712390.html
> Sent from the R help mailing list archive at Nabble.com.
>
> __
> R-help@r-project.org mailing list -- To UNSUBSCRIBE and more, see
> https://stat.ethz.ch/mailman/listinfo/r-help
> PLEASE do read the posting guide
> http://www.R-project.org/posting-guide.html
> and provide commented, minimal, self-contained, reproducible code.
>



-- 

Schrodinger's backup: The condition of any backup is unknown until a
restore is attempted.

Yoda of Borg, we are. Futile, resistance is, yes. Assimilated, you will be.

He's about as useful as a wax frying pan.

10 to the 12th power microphones = 1 Megaphone

Maranatha! <><
John McKown

[[alternative HTML version deleted]]

__
R-help@r-project.org mailing list -- To UNSUBSCRIBE and more, see
https://stat.ethz.ch/mailman/listinfo/r-help
PLEASE do read the posting guide http://www.R-project.org/posting-guide.html
and provide commented, minimal, self-contained, reproducible code.

[R] c(1:n, 1:(n-1), 1:(n-2), ... , 1)

[Dan D]

Can anyone think of a slick way to create an array that looks like c(1:n,
1:(n-1), 1:(n-2), ... , 1)?

The following works, but it's inefficient and a little hard to follow:
n<-5
junk<-array(1:n,dim=c(n,n))
junk[((lower.tri(t(junk),diag=T)))[n:1,]]

Any help would be greatly appreciated!

-Dan



--
View this message in context: 
http://r.789695.n4.nabble.com/c-1-n-1-n-1-1-n-2-1-tp4712390.html
Sent from the R help mailing list archive at Nabble.com.

__
R-help@r-project.org mailing list -- To UNSUBSCRIBE and more, see
https://stat.ethz.ch/mailman/listinfo/r-help
PLEASE do read the posting guide http://www.R-project.org/posting-guide.html
and provide commented, minimal, self-contained, reproducible code.

Re: [R] c(1:n, 1:(n-1), 1:(n-2), ... , 1)

[David Winsemius]

You can add this to the list of options to be tested, although my bet would be 
placed on `sequence(5:1)`:

> Reduce( function(x,y){c( 1:y, x)}, 1:5)
 [1] 1 2 3 4 5 1 2 3 4 1 2 3 1 2 1


On Sep 17, 2015, at 11:40 AM, Achim Zeileis wrote:

> On Thu, 17 Sep 2015, Peter Langfelder wrote:
> 
>> Not sure if this is slicker or easier to follow than your solution,
>> but it is shorter :)
>> 
>> do.call(c, lapply(n:1, function(n1) 1:n1))
> 
> Also not sure about efficiency but somewhat shorter...
> unlist(lapply(5:1, seq))
> 
>> Peter
>> 
>> On Thu, Sep 17, 2015 at 11:19 AM, Dan D  wrote:
>>> Can anyone think of a slick way to create an array that looks like c(1:n,
>>> 1:(n-1), 1:(n-2), ... , 1)?
>>> 
>>> The following works, but it's inefficient and a little hard to follow:
>>> n<-5
>>> junk<-array(1:n,dim=c(n,n))
>>> junk[((lower.tri(t(junk),diag=T)))[n:1,]]
>>> 
>>> Any help would be greatly appreciated!
>>> 
>>> -Dan
>>> 
>>> 

David Winsemius
Alameda, CA, USA

__
R-help@r-project.org mailing list -- To UNSUBSCRIBE and more, see
https://stat.ethz.ch/mailman/listinfo/r-help
PLEASE do read the posting guide http://www.R-project.org/posting-guide.html
and provide commented, minimal, self-contained, reproducible code.

Re: [R] c(1:n, 1:(n-1), 1:(n-2), ... , 1)

[Frank Schwidom]

how abount a more complicated one?

outer( 1:5, 1:5, '-')[ outer( 1:5, 1:5, '>')]
 [1] 1 2 3 4 1 2 3 1 2 1


On Thu, Sep 17, 2015 at 11:52:27AM -0700, David Winsemius wrote:
> You can add this to the list of options to be tested, although my bet would 
> be placed on `sequence(5:1)`:
> 
> > Reduce( function(x,y){c( 1:y, x)}, 1:5)
>  [1] 1 2 3 4 5 1 2 3 4 1 2 3 1 2 1
> 
> 
> On Sep 17, 2015, at 11:40 AM, Achim Zeileis wrote:
> 
> > On Thu, 17 Sep 2015, Peter Langfelder wrote:
> > 
> >> Not sure if this is slicker or easier to follow than your solution,
> >> but it is shorter :)
> >> 
> >> do.call(c, lapply(n:1, function(n1) 1:n1))
> > 
> > Also not sure about efficiency but somewhat shorter...
> > unlist(lapply(5:1, seq))
> > 
> >> Peter
> >> 
> >> On Thu, Sep 17, 2015 at 11:19 AM, Dan D  wrote:
> >>> Can anyone think of a slick way to create an array that looks like c(1:n,
> >>> 1:(n-1), 1:(n-2), ... , 1)?
> >>> 
> >>> The following works, but it's inefficient and a little hard to follow:
> >>> n<-5
> >>> junk<-array(1:n,dim=c(n,n))
> >>> junk[((lower.tri(t(junk),diag=T)))[n:1,]]
> >>> 
> >>> Any help would be greatly appreciated!
> >>> 
> >>> -Dan
> >>> 
> >>> 
> 
> David Winsemius
> Alameda, CA, USA
> 
> __
> R-help@r-project.org mailing list -- To UNSUBSCRIBE and more, see
> https://stat.ethz.ch/mailman/listinfo/r-help
> PLEASE do read the posting guide http://www.R-project.org/posting-guide.html
> and provide commented, minimal, self-contained, reproducible code.
>

__
R-help@r-project.org mailing list -- To UNSUBSCRIBE and more, see
https://stat.ethz.ch/mailman/listinfo/r-help
PLEASE do read the posting guide http://www.R-project.org/posting-guide.html
and provide commented, minimal, self-contained, reproducible code.

Re: [R] c(1:n, 1:(n-1), 1:(n-2), ... , 1)

[Bert Gunter]

Note that:


>> Also not sure about efficiency but somewhat shorter...
>> unlist(lapply(5:1, seq))
>>
>>> Peter
>>>

is almost exactly sequence(5:1)

which is

unlist(lapply(5:1,seq_len))

which is "must preferred". See ?seq for details

Cheers,
Bert



>>> On Thu, Sep 17, 2015 at 11:19 AM, Dan D  wrote:
 Can anyone think of a slick way to create an array that looks like c(1:n,
 1:(n-1), 1:(n-2), ... , 1)?

 The following works, but it's inefficient and a little hard to follow:
 n<-5
 junk<-array(1:n,dim=c(n,n))
 junk[((lower.tri(t(junk),diag=T)))[n:1,]]

 Any help would be greatly appreciated!

 -Dan


>
> David Winsemius
> Alameda, CA, USA
>
> __
> R-help@r-project.org mailing list -- To UNSUBSCRIBE and more, see
> https://stat.ethz.ch/mailman/listinfo/r-help
> PLEASE do read the posting guide http://www.R-project.org/posting-guide.html
> and provide commented, minimal, self-contained, reproducible code.

__
R-help@r-project.org mailing list -- To UNSUBSCRIBE and more, see
https://stat.ethz.ch/mailman/listinfo/r-help
PLEASE do read the posting guide http://www.R-project.org/posting-guide.html
and provide commented, minimal, self-contained, reproducible code.

Re: [R] c(1:n, 1:(n-1), 1:(n-2), ... , 1)

[Dan D]

Very nice variety of solutions to create c(1:n, 1:(n-1), 1:(n-2), ... , 1)

#Testing the methods with n=1000 (microbenchmark)
n<-1000

# by far the nicest-looking, easiest to follow, and fastest is Frank
Schwidom's:
# it also requires the minimum amount of memory (as do several of the
others)
# 2.73 milliseconds (1x)
sequence(n:1)  

# not nearly as nice-looking but almost as fast:
# 2.82 milliseconds (1.03x)
do.call(c, lapply(n:1, function(n1) 1:n1)) 

# an improvement on look but 5x slower than do.call is:
# 13.3 milliseconds  (4.9x)
unlist(lapply(n:1, seq))

## the others are uglier and way slower [uses a full (n+1) x (n+1) matrix]
# 60.8 milliseconds (22.3x)
outer( 1:(n+1), 1:(n+1), '-')[ outer( 1:n, 1:(n+1), '>')]

# 71.8 milliseconds (26.3x) [uses a full (n x n) matrix]
junk<-array(1:n,dim=c(n,n))
junk[((lower.tri(t(junk),diag=T)))[n:1,]]

# 421.3 milliseconds (154x)
Reduce( function(x,y){c( 1:y, x)}, 1:n)

# 3200 milliseconds (1170x)
cc<-0; # establish result as numeric
for(i in seq(n,1,-1)){ cc<-c(cc,seq(1,i)); str(cc); }; #generate array
cc<-cc[2:length(cc)]; #remove the leading 0
} # 

# crashes:
mklist <- function(n) { 
 if (n==1) return(1) else return( c(seq(1,n),mklist(n-1)) ) 
}



--
View this message in context: 
http://r.789695.n4.nabble.com/c-1-n-1-n-1-1-n-2-1-tp4712390p4712399.html
Sent from the R help mailing list archive at Nabble.com.

__
R-help@r-project.org mailing list -- To UNSUBSCRIBE and more, see
https://stat.ethz.ch/mailman/listinfo/r-help
PLEASE do read the posting guide http://www.R-project.org/posting-guide.html
and provide commented, minimal, self-contained, reproducible code.

Re: [R] c(1:n, 1:(n-1), 1:(n-2), ... , 1)

[William Dunlap]

If you are interested in speed for long input vectors try the following,
which should give the same result as sequence().
mySequence <-function (nvec)
{
nvec <- as.integer(nvec)
seq_len(sum(nvec)) - rep(cumsum(c(0L, nvec[-length(nvec)])),
nvec)
}

E.g.,
> n <- rpois(1e6, 3)
> system.time(mySequence(n))
   user  system elapsed
   0.070.000.07
> system.time(sequence(n))
   user  system elapsed
   0.880.000.87
> identical(mySequence(n), sequence(n))
[1] TRUE


Bill Dunlap
TIBCO Software
wdunlap tibco.com


On Thu, Sep 17, 2015 at 12:53 PM, Dan D  wrote:
> Very nice variety of solutions to create c(1:n, 1:(n-1), 1:(n-2), ... , 1)
>
> #Testing the methods with n=1000 (microbenchmark)
> n<-1000
>
> # by far the nicest-looking, easiest to follow, and fastest is Frank
> Schwidom's:
> # it also requires the minimum amount of memory (as do several of the
> others)
> # 2.73 milliseconds (1x)
> sequence(n:1)
>
> # not nearly as nice-looking but almost as fast:
> # 2.82 milliseconds (1.03x)
> do.call(c, lapply(n:1, function(n1) 1:n1))
>
> # an improvement on look but 5x slower than do.call is:
> # 13.3 milliseconds  (4.9x)
> unlist(lapply(n:1, seq))
>
> ## the others are uglier and way slower [uses a full (n+1) x (n+1) matrix]
> # 60.8 milliseconds (22.3x)
> outer( 1:(n+1), 1:(n+1), '-')[ outer( 1:n, 1:(n+1), '>')]
>
> # 71.8 milliseconds (26.3x) [uses a full (n x n) matrix]
> junk<-array(1:n,dim=c(n,n))
> junk[((lower.tri(t(junk),diag=T)))[n:1,]]
>
> # 421.3 milliseconds (154x)
> Reduce( function(x,y){c( 1:y, x)}, 1:n)
>
> # 3200 milliseconds (1170x)
> cc<-0; # establish result as numeric
> for(i in seq(n,1,-1)){ cc<-c(cc,seq(1,i)); str(cc); }; #generate array
> cc<-cc[2:length(cc)]; #remove the leading 0
> } #
>
> # crashes:
> mklist <- function(n) {
>  if (n==1) return(1) else return( c(seq(1,n),mklist(n-1)) )
> }
>
>
>
> --
> View this message in context: 
> http://r.789695.n4.nabble.com/c-1-n-1-n-1-1-n-2-1-tp4712390p4712399.html
> Sent from the R help mailing list archive at Nabble.com.
>
> __
> R-help@r-project.org mailing list -- To UNSUBSCRIBE and more, see
> https://stat.ethz.ch/mailman/listinfo/r-help
> PLEASE do read the posting guide http://www.R-project.org/posting-guide.html
> and provide commented, minimal, self-contained, reproducible code.

__
R-help@r-project.org mailing list -- To UNSUBSCRIBE and more, see
https://stat.ethz.ch/mailman/listinfo/r-help
PLEASE do read the posting guide http://www.R-project.org/posting-guide.html
and provide commented, minimal, self-contained, reproducible code.