maybe I can illustrate the problem by showing how a c programmer might think
about the problem and the kinds of mistakes 'we' ( I) make when trying to do
this in R
cstruct<-function(int, bool){
+
+ myint<- int*2;
+
+ mybool<-!bool;
+ myvec<-rep(mybool,10)
+ mymat<-matrix(myint*10,nrow=3,ncol=3)
+ myframe<-data.frame(rep(myint,5),rep(bool,5))
+ returnlist<-list(myint,mybool,myvec,mymat,myframe)
+ return(returnlist)
+
+
+
+ }
# so I have a function that returns a list of hetergenous variables.
# an int, a bool, a vector of bools, a matrix of ints, a dataframe of ints
and bools
> test<-cstruct(3,T)
> test
[[1]]
[1] 6
[[2]]
[1] FALSE
[[3]]
[1] FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE
[[4]]
[,1] [,2] [,3]
[1,] 60 60 60
[2,] 60 60 60
[3,] 60 60 60
[[5]]
rep.myint..5. rep.bool..5.
1 6 TRUE
2 6 TRUE
3 6 TRUE
4 6 TRUE
5 6 TRUE
# Now I want to access the first element of my list which is an "an int"
# first mistake I always make is I just revert to thinking in the
# 'dot' structure of a c struct.
> test.myint
Error: object 'test.myint' not found
# Then I think its stored like a var in a dataframe, accessed by the $
> test$myint
NULL
# then I try to access the first element of the list
> test[1]
[[1]]
[1] 6
# That works.. but the [[1]] confuses me when I eval test[1] I want 6 back
# again thinking in C.
# so I try the third element
> test[3]
[[1]]
[1] FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE
# ok I get my vect of bools back. Now I want the first element
# of that thing
# well test[3] is that thing.. and I want element 1 of test[3]
> test[3][1]
[[1]]
[1] FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE
#hmm thats not what I expect. I wanted F back.
# frustrated I try this which i know is wrong
> test[3,1]
Error in test[3, 1] : incorrect number of dimensions
# crap.. maybe the $ is supposed to be used
> test$V3
NULL
# arrg.. how about 'dot"
> test.myvec
Error: object 'test.myvec' not found
Anyways, That's the kind of frustration. I have a list, third element is a
matrix
how do I referernce the 2 row 2 colum of the matrix in my list.. for
example.
and so forth..
On Sat, May 1, 2010 at 10:56 AM, Ted Harding
<ted.hard...@manchester.ac.uk>wrote:
> On 01-May-10 16:58:49, Giovanni Azua wrote:
> >
> > On May 1, 2010, at 6:48 PM, steven mosher wrote:
> >> I was talking with another guy on the list about this very topic.
> >>
> >> A simple example would help.
> >>
> >> first a sample C struct, and then how one would do the equivalent in
> >> R.
> >>
> >> In the end i suppose one want to do a an 'array' of these structs, or
> >> list
> >> of the structs.
> >
> > Or like in my use-case ... I needed a c-like struct to define the type
> > for aggregating the data to return from a function.
> >
> > Best regards,
> > Giovanni
>
> Assuming that I understand what you want, this is straightforward
> and can be found throughout the many functions available in R.
> The general form is:
>
> myfunction <- function(...){
> <code to compute objects A1, A2, ... , An>
> list(valA1=A1, valA2=A2, ... , valAn=An)
> }
>
> and then a call like
>
> myresults <- myfunction(...)
>
> will create a list "myresults" with compnents "valA1", ... ,"valAn"
> which you can access as desired on the lines of
>
> myresults$valA5
>
> As a simple example, the following is a function which explores
> by simulation the power of the Fisher Exact Test for comparing
> two proportions in a 2x2 table:
>
> power.fisher.test <- function(p1,p2,n1,n2,alpha=0.05,nsim=100){
> y1 <- rbinom(nsim,size=n1,prob=p1)
> y2 <- rbinom(nsim,size=n2,prob=p2)
> y <- cbind(y1,n1-y1,y2,n2-y2)
> p.value <- rep(0,nsim)
> for (i in 1:nsim)
> p.value[i] <- fisher.test(matrix(y[i,],2,2))$p.value
> list(Pwr=mean(p.value < alpha),SE.Pwr=sd(p.value < alpha)/sqrt(nsim))
> }
>
> So, given two binomials B(n1,p1) and B(n2,p2), what would be the
> power of the Fisher test to detect that p1 was different from p2,
> at given significance level alpha? This is investigated by repeating,
> nsim times:
> sample from Bin(n1,p1), sample from Bin(n2.p2)
> do a Fisher test and get its P-value; store it
> in a vector p.value of length nsim
> and then finally:
> estimate the power as the proportion Pwr of the nsim cases
> in which the P-value was less than alpha
> get the SE of this estimate
> return these two values as components Pwr and SE.Pwr of a list
>
> As it happens, here each component of the resulting list is of
> the same type (a single number); but in a different computation
> each component (and of course there could be more than two)
> could be anything -- even another list. So you can have lists
> of lists ... !
>
> Thus, instead of the simple returned list above:
>
> list(Pwr=mean(p.value < alpha),
> SE.Pwr=sd(p.value < alpha)/sqrt(nsim))
>
> you could have
>
> list(Binoms=list(Bin1=list(size=n1,prob=p1),
> Bin2=list(size=n2,prob=p2))
> Pwr=mean(p.value < alpha),
> SE.Pwr=sd(p.value < alpha)/sqrt(nsim))
>
> thus also returning the details of the Binomials for which the
> simulation was carried out. You could access these all together as:
>
> power.fisher.test(...)$Binoms
>
> or separately as
>
> power.fisher.test(...)$Binoms$Bin1
> or
> power.fisher.test(...)$Binoms$Bin2
>
> or even
> power.fisher.test(...)$Binoms$Bin1$size
> power.fisher.test(...)$Binoms$Bin1$prob
> etc.
>
> Ted.
>
> --------------------------------------------------------------------
> E-Mail: (Ted Harding) <ted.hard...@manchester.ac.uk>
> Fax-to-email: +44 (0)870 094 0861
> Date: 01-May-10 Time: 18:56:50
> ------------------------------ XFMail ------------------------------
>
> ______________________________________________
> R-help@r-project.org mailing list
> 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.
>
[[alternative HTML version deleted]]
______________________________________________
R-help@r-project.org mailing list
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.
