Hi, I really appreciate the new functionalities of aggregate()! At first some comments: a) including the cases is very useful b) in terms of the NaN rows in a matrix, well I'm not that sure, in my function I skip them at the moment, but perhaps sometimes it's exactly those combinations one likes to know. Is there already a way that generates a copy of a matrix without lines including missings? c) what about the mcov() function as 'aggregator function'? Second, I'm of the opinion that there is a quite important and user friendly option missing: It's about combinatorics. Although one has e.g. 5 discrete variables one wants e.g. ONLY ALL BIVARIATE combinations. This should be done by GRETL and not by hand. I found a solution that looks like this (including the nice pack and unpack functions!). In the GRETL function this could look like: aggregate(X, Y, mean,2) where the last argument is 'nelem(Y)' as standard. <hansl> open pizza4.gdt set echo off series ages = age<=20 ? 0 : (age>20 && age <=40) ? 1 : 2 list X = pizza income list Y = female college ages # by hand bivariate interaction, rather easy with three variables... list Y1 = female college list Y2 = female ages list Y3 = college ages matrix m2a = aggregate(X, Y1, mean) matrix m2b = aggregate(X, Y2, mean) matrix m2c = aggregate(X, Y3, mean) # all three matrix m3 = aggregate(X, Y, mean) # comparison to my solution bundle MVS = null MVS["LIDs"] = getIDs(Y) # for automatic bivariate interaction scalar inter = 3 matrix codes ={} loop for i=2..inter -q Com$i =COMBIS(MVS[LIDs],i,&MVS) loop for c=1..cols(Com$i) -q string listName = "L$i_$c" list @listName = Com$i[,c] agg(X,@listName,&codes) # or if u want to store the matrices in a bundle agg(X,@listName,&codes,1,&MVS) endloop endloop # FUNCTIONS ************************************************************************ #********************* function 1 ***************************************************** function scalar choose(scalar n, scalar k) scalar binC = gammafun(n+1)/(gammafun(k+1)*gammafun(n-k+1)) return binC end function #********************* function 2 ***************************************************** function matrix COMBIS (matrix x, scalar m, bundle *bun[null]) scalar n = rows(x) if (n < m) print "Not possible!" endif scalar e = 0 scalar h = m matrix a = seq(1,m) matrix r = x[a] scalar lenr = rows(r) scalar count = choose(n, m) # choose is 'n over k' matrix dimuse = {m, count} # gerneral structur of output matrix matrix out = mshape(r, lenr, count) if (m > 0) scalar i = 2 scalar nmmp1 = n - m + 1 loop while (a[1] != nmmp1) -q if (e < n - h) scalar h = 1 scalar e = a[m] matrix j = 1 else scalar e = a[m - h] scalar h += 1 matrix j = seq(1,h) endif a[m - h + j] = e + j r = x[a] out[, i] = r i+= 1 endloop endif if !isnull(bun) sprintf num "%g", m bun["combis_@num"]=out endif return out end function #********************* function 3 ***************************************************** function series pack(list X, matrix *pwrof2) /* a check should be necessary that all series in X are discrete; for the moment, let's just skip it */ series ret = 0 pwrtot = 1 k = nelem(X) # first build the nvalues vector # starting values are pwrof2 = {} n = 1 k = 1 loop foreach i X --quiet ret += k*X.$i # some fun to generate a unique number n = 2^ceil(log2(1+max(X.$i))) k *= n # save the key for unpacking pwrof2 |= n end loop return ret end function #********************* function 4 ***************************************************** function matrix unpack(scalar x, matrix pwr) # this function retrurnes the conditions for the factor steps # number of codes which has to be decrypted # for each factor one code (not for each factor step!) k = rows(pwr) matrix ret = zeros(k,1) loop i=1..k --quiet h = pwr[i] a = x % h ret[i] = a # prepare for next factor x = (x-a)/h end loop return ret end function #********************* function 5 ***************************************************** function void agg(list endos, list groups, matrix *codes, scalar func[1], bundle *bun[null], scalar MLE[0], series *Indices[null]) matrix calc = {} scalar m = nelem(endos) scalar COLsneeded = func*m u = pack(groups, &codes) n_u = values(u) matrix calc = zeros(rows(n_u),1+nelem(groups)+COLsneeded) matrix calc_start = zeros(rows(n_u),1) sprintf lName "%s", strsub(varname(groups),",","_") loop i = 1..rows(n_u) -q r = n_u[i] smpl u==r --res --rep scalar Ns = $nobs calc[i,1] = Ns matrix c = unpack(r, codes) step1 = nelem(groups) +1 calc[i,2:step1] = c' step2 = step1 +1 step3 = step1 + m if func==1 calc[i,step2:step3] = meanc({endos}) step3++ elif func==2 calc[i,step2:step3] = meanc({endos}) step4 = step3 + m step3++ calc[i,step3:step4] = sd({endos}) steps = step4+1 endif if !isnull(Indices) calc_start[i,1]=r endif end loop if !isnull(Indices) string NAMEcolMVS = "ID cases " else string NAMEcolMVS = "cases " endif NAMEcolMVS += strsub(varname(groups),","," ") string NAMEcolENDOS = strsub(varname(endos),","," ") colnames(calc_start,"ID") matrix take1 = seq(1,nelem(groups)+1) if !isnull(Indices) matrix adding = calc_start~calc[,take1] colnames(adding,NAMEcolMVS) if !isnull(bun) bun["MVS_@lName"]=adding else print "Infos" eval adding endif else matrix adding = calc[,take1] colnames(adding,NAMEcolMVS) if !isnull(bun) bun["MVS_@lName"]=adding else print "Infos" eval adding endif endif matrix take2 = seq(1,nelem(endos)) loop for f=1..func -q if f==1 take2 = take2.+cols(take1) matrix adding2 = calc[,take2] colnames(adding2,NAMEcolENDOS) if !isnull(bun) bun["means_@lName"]=adding2 else print "means" eval adding2 endif elif f==2 take2 = take2 .+ m matrix adding2 = calc[,take2] colnames(adding2,NAMEcolENDOS) if !isnull(bun) bun["sds_@lName"]=adding2 else print "sds" eval adding2 endif endif endloop smpl full if !isnull(Indices) Indices = u endif end function #********************* function 6 ***************************************************** function matrix getIDs(list G) matrix IDs = {} loop foreach i G -q IDs |= varnum(G.$i) endloop return IDs end function # END FUNCTIONS ************************************************************* <hansl> 27.02.2013 23:54, Allin Cottrell:

Am 28.02.2013 19:11, schrieb Allin Cottrell: Good to know! I gonna have a look at how to use these functions instead. Oh 'matrix amat =A' is much shorter then 'getIDs'! Well, yes it's easy, but I like the COMBIs function more, because it generates from a random vector with e.g. integers the binomial combinations of the elements and stores them in the columns of a new matrix. Ah, I always tries this in vain... 'loop foreach i A j=i+1 'loop foreach j A