3:46 p.m.
Hi
I want to thank again all Gretl developpers for this wonderful software.
I try to port some of my R code into Gretl and I miss few things.
For example, what is the easiest way to perform some aggregate operation in
Gretl like :
- aggregate(x, by = y, FUN) in R
or
- egen z = FUN(x), by(y); in Stata
or
- SELECT FUN(x) GROUP BY y in SQL
It looks like I miss something in the documentation.
Thanks again
--
Ahmadou H. DICKO
Data scientist and applied economist
PhD student in Climate change economics
Faculty of economics and managment - Cheikh Anta Diop University
West African Science Service Center on Climate Change and Adaptated Land
Use (WASCAL)
Center for Development Research (ZEF) - University of Bonn
twitter : @dickoah
skype : dicko.ahmadou.h
tel : 33 827 55 16
6:40 p.m.
On Tue, 19 Feb 2013, ahmadou dicko wrote:
I want to thank again all Gretl developpers for this wonderful
software.
Glad you like it!
I try to port some of my R code into Gretl and I miss few things.
For example, what is the easiest way to perform some aggregate operation in
Gretl like :
- aggregate(x, by = y, FUN) in R
This functionality is not built-in (except in relation to the
"summary" command, using the --by option). However it's
possible to write a function to do this sort of thing. The
following is not very general but should give you the idea:
<hansl>
function matrix aggregate (series x, series y, string funname)
matrix m = values(y) ~ 0
loop i=1..rows(m) --quiet
smpl y == m[i,1] --restrict --replace
m[i,2] = @funname(x)
printf "@funname(x) for y=%g: %g\n", m[i,1], m[i,2]
endloop
colnames(m, "y f(x)")
return m
end function
open credscore.gdt
m = aggregate(Income, Acc, "mean")
print m
m = aggregate(Income, Acc, "sd")
print m
</hansl>
Allin Cottrell
6:50 p.m.
Thank you very much this is exactly what I was looking for.
I'll try to understand better hansl to improve this function and
generalized it.
I think that having a general "by" operator for common aggregator
functions (max, mean, etc.) can be useful for other Gretl users.
Thanks again for this example showing hansl capabilities.
On Tue, Feb 19, 2013 at 6:40 PM, Allin Cottrell <cottrell(a)wfu.edu> wrote:
On Tue, 19 Feb 2013, ahmadou dicko wrote:
> I want to thank again all Gretl developpers for this wonderful software.
Glad you like it!
> I try to port some of my R code into Gretl and I miss few things.
>
> For example, what is the easiest way to perform some aggregate operation
in
> Gretl like :
>
> - aggregate(x, by = y, FUN) in R
This functionality is not built-in (except in relation to the
"summary" command, using the --by option). However it's
possible to write a function to do this sort of thing. The
following is not very general but should give you the idea:
<hansl>
function matrix aggregate (series x, series y, string funname)
matrix m = values(y) ~ 0
loop i=1..rows(m) --quiet
smpl y == m[i,1] --restrict --replace
m[i,2] = @funname(x)
printf "@funname(x) for y=%g: %g\n", m[i,1], m[i,2]
endloop
colnames(m, "y f(x)")
return m
end function
open credscore.gdt
m = aggregate(Income, Acc, "mean")
print m
m = aggregate(Income, Acc, "sd")
print m
</hansl>
Allin Cottrell
_______________________________________________
Gretl-users mailing list
Gretl-users(a)lists.wfu.edu
http://lists.wfu.edu/mailman/listinfo/gretl-users
--
Ahmadou H. DICKO
Data scientist and applied economist
PhD student in Climate change economics
Faculty of economics and managment - Cheikh Anta Diop University
West African Science Service Center on Climate Change and Adaptated Land
Use (WASCAL)
Center for Development Research (ZEF) - University of Bonn
twitter : @dickoah
skype : dicko.ahmadou.h
tel : 33 827 55 16
8:30 p.m.
On Tue, 19 Feb 2013, ahmadou dicko wrote:
> This functionality is not built-in (except in relation to the
> "summary" command, using the --by option). However it's
> possible to write a function to do this sort of thing. The
> following is not very general but should give you the idea:
>
> <hansl>
> function matrix aggregate (series x, series y, string funname)
> matrix m = values(y) ~ 0
> loop i=1..rows(m) --quiet
> smpl y == m[i,1] --restrict --replace
> m[i,2] = @funname(x)
> printf "@funname(x) for y=%g: %g\n", m[i,1], m[i,2]
> endloop
> colnames(m, "y f(x)")
> return m
> end function
>
> open credscore.gdt
> m = aggregate(Income, Acc, "mean")
> print m
> m = aggregate(Income, Acc, "sd")
> print m
> </hansl>
Mmmm. I like it. This as a native function would be very nice to have.
Plus, this is one of those cases in which C would be much much faster than
hansl.
-------------------------------------------------------
Riccardo (Jack) Lucchetti
Dipartimento di Scienze Economiche e Sociali (DiSES)
Università Politecnica delle Marche
(formerly known as Università di Ancona)
r.lucchetti(a)univpm.it
http://www2.econ.univpm.it/servizi/hpp/lucchetti
-------------------------------------------------------
4:19 a.m.
On Tue, 19 Feb 2013, Riccardo (Jack) Lucchetti wrote:
On Tue, 19 Feb 2013, ahmadou dicko wrote:
>> This functionality is not built-in (except in relation to the
>> "summary" command, using the --by option). However it's
>> possible to write a function to do this sort of thing. The
>> following is not very general but should give you the idea:
>>
>> <hansl>
>> function matrix aggregate (series x, series y, string funname)
>> matrix m = values(y) ~ 0
>> loop i=1..rows(m) --quiet
>> smpl y == m[i,1] --restrict --replace
>> m[i,2] = @funname(x)
>> printf "@funname(x) for y=%g: %g\n", m[i,1], m[i,2]
>> endloop
>> colnames(m, "y f(x)")
>> return m
>> end function
>>
>> open credscore.gdt
>> m = aggregate(Income, Acc, "mean")
>> print m
>> m = aggregate(Income, Acc, "sd")
>> print m
>> </hansl>
Mmmm. I like it. This as a native function would be very nice to have. Plus,
this is one of those cases in which C would be much much faster than hansl.
Agreed. In tonight's CVS we have a native function, aggregate(), on
the pattern shown above, which supports the methods sum, mean, sd,
var, sst, skewness, kurtosis, min, max, median and gini. It'll be in
the snapshots tomorrow.
Allin Cottrell
7:13 a.m.
On Tue, 19 Feb 2013, Allin Cottrell wrote:
> Mmmm. I like it. This as a native function would be very nice to
have.
> Plus, this is one of those cases in which C would be much much faster than
> hansl.
Agreed. In tonight's CVS we have a native function, aggregate(), on the
pattern shown above, which supports the methods sum, mean, sd, var, sst,
skewness, kurtosis, min, max, median and gini. It'll be in the snapshots
tomorrow.
Very nice. The next step, logically, would be to support user-written
functions too. However, this would mean to complicate the code by a factor
(I reckon) of 1 to 5 or so. Arguably though, this would only be useful in
a few cases, since if you take the trouble to write a complex user-level
funciton to accomplish something very specific, then the overhead of
aggregating "by hand", as in Allin's hansl script he sent yesterday
becomes negligible.
-------------------------------------------------------
Riccardo (Jack) Lucchetti
Dipartimento di Scienze Economiche e Sociali (DiSES)
Università Politecnica delle Marche
(formerly known as Università di Ancona)
r.lucchetti(a)univpm.it
http://www2.econ.univpm.it/servizi/hpp/lucchetti
-------------------------------------------------------
2:57 p.m.
On Wed, 20 Feb 2013, Riccardo (Jack) Lucchetti wrote:
On Tue, 19 Feb 2013, Allin Cottrell wrote:
>> Mmmm. I like it. This as a native function would be very nice to have.
>> Plus, this is one of those cases in which C would be much much faster than
>> hansl.
>
> Agreed. In tonight's CVS we have a native function, aggregate(), on the
> pattern shown above, which supports the methods sum, mean, sd, var, sst,
> skewness, kurtosis, min, max, median and gini. It'll be in the snapshots
> tomorrow.
Very nice. The next step, logically, would be to support user-written
functions too. However, this would mean to complicate the code by a factor (I
reckon) of 1 to 5 or so.
I was afraid the factor might be at the top end of that range,
but I experimented and it's more like 0.25. So user-functions
are now supported. The function must take a single series
argument and return a scalar. Example:
<hansl>
function scalar my_aggregator (series x)
return sum(x^3)
end function
open credscore.gdt
matrix m = aggregate(Income, Acc, my_aggregator)
print m
</hansl>
Allin
4:45 p.m.
On Wed, 20 Feb 2013, Allin Cottrell wrote:
On Wed, 20 Feb 2013, Riccardo (Jack) Lucchetti wrote:
> Very nice. The next step, logically, would be to support user-written
> functions too. However, this would mean to complicate the code by a factor
> (I reckon) of 1 to 5 or so.
I was afraid the factor might be at the top end of that range, but I
experimented and it's more like 0.25. So user-functions are now supported.
The function must take a single series argument and return a scalar. Example:
<hansl>
function scalar my_aggregator (series x)
return sum(x^3)
end function
open credscore.gdt
matrix m = aggregate(Income, Acc, my_aggregator)
print m
</hansl>
Now, I don't want to be guilty of personality cult, but at the risk of
sounding like an old Stalinist apparatchik I have to say I am left in awe
by the skills of our beloved leader.
Studying the cvs diff has been for several years my primary method for
learning C, but this case stands out as a true gem.
Thank you.
-------------------------------------------------------
Riccardo (Jack) Lucchetti
Dipartimento di Scienze Economiche e Sociali (DiSES)
Università Politecnica delle Marche
(formerly known as Università di Ancona)
r.lucchetti(a)univpm.it
http://www2.econ.univpm.it/servizi/hpp/lucchetti
-------------------------------------------------------
10:48 a.m.
Hi,
I'd like to point out, that a 'good' 'aggregate by' function would do
such a job as described below.
Unfortunately I'm stuck with more then bivariate interaction but I'm
sure GRETL can do this,
this question is how!
It's even more complex since the R function is not that good either, cos
e.g. for MAVOVA one needs the variance-covariance-structure of
the 'interaction series'. That's why in GRETL lists should be processed
which makes the stuff not easier.
I worked around with the new '^' operator and have some promising
results, but a build-in function would be the best.
Cheers
Leon
<hansl>
open pizza4.gdt
series ages = age<=20 ? 0 : (age>20 && age <=40) ? 1 : 2
set echo off
foreign language=R --send-data --quiet
library(plyr)
ddply(gretldata[,c(1,2,4,6,8)], ~ female + college + ages,
numcolwise(mean))
end foreign
<hansl>
While the bivariate case in rather easy as in
<hansl>
open pizza4.gdt
set echo off
series ages = age<=20 ? 0 : (age>20 && age <=40) ? 1 : 2
list G1 = 2 4
list G2 = 2 8
list G3 = 4 8
list G = G1 || G2
scalar times = 2 # should also be
possible to be set to nelem(G)
#set up of all combination list
loop for i=2..times -q
string listName = "inter$i"
list @listName = null
endloop
list part1 = null
list part2 = G
# bivariate interaction
loop foreach i G-q
part1 = G.$i
part2 -= G.$i
inter2 += part2^part1
part2 += G.$i
endloop
<hansl>
Am 20.02.2013 17:45, schrieb Riccardo (Jack) Lucchetti:
On Wed, 20 Feb 2013, Allin Cottrell wrote:
> On Wed, 20 Feb 2013, Riccardo (Jack) Lucchetti wrote:
>
>> Very nice. The next step, logically, would be to support
>> user-written functions too. However, this would mean to complicate
>> the code by a factor (I reckon) of 1 to 5 or so.
>
> I was afraid the factor might be at the top end of that range, but I
> experimented and it's more like 0.25. So user-functions are now
> supported. The function must take a single series argument and return
> a scalar. Example:
>
> <hansl>
> function scalar my_aggregator (series x)
> return sum(x^3)
> end function
>
> open credscore.gdt
> matrix m = aggregate(Income, Acc, my_aggregator)
> print m
> </hansl>
Now, I don't want to be guilty of personality cult, but at the risk of
sounding like an old Stalinist apparatchik I have to say I am left in
awe by the skills of our beloved leader.
Studying the cvs diff has been for several years my primary method for
learning C, but this case stands out as a true gem.
Thank you.
-------------------------------------------------------
Riccardo (Jack) Lucchetti
Dipartimento di Scienze Economiche e Sociali (DiSES)
Università Politecnica delle Marche
(formerly known as Università di Ancona)
r.lucchetti(a)univpm.it
http://www2.econ.univpm.it/servizi/hpp/lucchetti
-------------------------------------------------------
_______________________________________________
Gretl-users mailing list
Gretl-users(a)lists.wfu.edu
http://lists.wfu.edu/mailman/listinfo/gretl-users
12:20 a.m.
On Sun, 24 Feb 2013, Pindar wrote:
Hi,
I'd like to point out, that a 'good' 'aggregate by' function would do
such a
job as described below.
Unfortunately I'm stuck with more then bivariate interaction but I'm sure
GRETL can do this,
this question is how!
The script below should do what I think you need; the trick is creating a
series which contains, in coded form, all the possible combinations of
values of the variables contained in a list. This is what the function
"pack" does; note that "pack" also creates a matrix which is used in
the
"unpack" function later.
See if this helps:
<hansl>
set echo off
set messages off
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
pwrof2 = {}
n = 1
k = 1
loop foreach i X --quiet
ret += k*X.$i
n = 2^ceil(log2(1+max(X.$i)))
k *= n
pwrof2 |= n
end loop
return ret
end function
function matrix unpack(scalar x, matrix pwr)
k = rows(pwr)
matrix ret = zeros(k,1)
loop i=1..k --quiet
h = pwr[i]
a = x % h
ret[i] = a
x = (x-a)/h
end loop
return ret
end function
# --- END FUNCTIONS -----------------------------------------
open pizza4.gdt
series ages = age<=20 ? 0 : (age>20 && age <=40) ? 1 : 2
list A = female hs ages
matrix codes = {}
u = pack(A, &codes)
n_u = values(u)
loop i = 1..rows(n_u) --quiet
k = n_u[i]
smpl u==k --restrict --replace
c = unpack(k, codes)
l = 1
loop foreach j A --quiet
printf "%10s = %d", "$j", c[l]
l++
end loop
printf "\ncases = %d, mean(pizza) = %g, mean(income) = %g\n\n", \
$nobs, mean(pizza), mean(income)
end loop
smpl full
</hansl>
It's even more complex since the R function is not that good either, cos e.g.
for MAVOVA one needs the variance-covariance-structure of
the 'interaction series'. That's why in GRETL lists should be processed which
makes the stuff not easier.
I worked around with the new '^' operator and have some promising results,
but a build-in function would be the best.
Cheers
Leon
<hansl>
open pizza4.gdt
series ages = age<=20 ? 0 : (age>20 && age <=40) ? 1 : 2
set echo off
foreign language=R --send-data --quiet
library(plyr)
ddply(gretldata[,c(1,2,4,6,8)], ~ female + college + ages,
numcolwise(mean))
end foreign
<hansl>
While the bivariate case in rather easy as in
<hansl>
open pizza4.gdt
set echo off
series ages = age<=20 ? 0 : (age>20 && age <=40) ? 1 : 2
list G1 = 2 4
list G2 = 2 8
list G3 = 4 8
list G = G1 || G2
scalar times = 2 # should also be possible
to be set to nelem(G)
#set up of all combination list
loop for i=2..times -q
string listName = "inter$i"
list @listName = null
endloop
list part1 = null
list part2 = G
# bivariate interaction
loop foreach i G-q
part1 = G.$i
part2 -= G.$i
inter2 += part2^part1
part2 += G.$i
endloop
<hansl>
Am 20.02.2013 17:45, schrieb Riccardo (Jack) Lucchetti:
> On Wed, 20 Feb 2013, Allin Cottrell wrote:
>
>> On Wed, 20 Feb 2013, Riccardo (Jack) Lucchetti wrote:
>>
>>> Very nice. The next step, logically, would be to support user-written
>>> functions too. However, this would mean to complicate the code by a
>>> factor (I reckon) of 1 to 5 or so.
>>
>> I was afraid the factor might be at the top end of that range, but I
>> experimented and it's more like 0.25. So user-functions are now supported.
>> The function must take a single series argument and return a scalar.
>> Example:
>>
>> <hansl>
>> function scalar my_aggregator (series x)
>> return sum(x^3)
>> end function
>>
>> open credscore.gdt
>> matrix m = aggregate(Income, Acc, my_aggregator)
>> print m
>> </hansl>
>
> Now, I don't want to be guilty of personality cult, but at the risk of
> sounding like an old Stalinist apparatchik I have to say I am left in awe
> by the skills of our beloved leader.
>
> Studying the cvs diff has been for several years my primary method for
> learning C, but this case stands out as a true gem.
>
> Thank you.
>
>
> -------------------------------------------------------
> Riccardo (Jack) Lucchetti
> Dipartimento di Scienze Economiche e Sociali (DiSES)
>
> Università Politecnica delle Marche
> (formerly known as Università di Ancona)
>
> r.lucchetti(a)univpm.it
> http://www2.econ.univpm.it/servizi/hpp/lucchetti
> -------------------------------------------------------
>
>
> _______________________________________________
> Gretl-users mailing list
> Gretl-users(a)lists.wfu.edu
> http://lists.wfu.edu/mailman/listinfo/gretl-users
-------------------------------------------------------
Riccardo (Jack) Lucchetti
Dipartimento di Scienze Economiche e Sociali (DiSES)
Università Politecnica delle Marche
(formerly known as Università di Ancona)
r.lucchetti(a)univpm.it
http://www2.econ.univpm.it/servizi/hpp/lucchetti
-------------------------------------------------------
4:24 p.m.
Thank u Jack for this nice solution!
Leon
Am 25.02.2013 um 01:20 schrieb "Riccardo (Jack) Lucchetti"
<r.lucchetti(a)univpm.it>:
On Sun, 24 Feb 2013, Pindar wrote:
> Hi,
>
> I'd like to point out, that a 'good' 'aggregate by' function
would do such a job as described below.
> Unfortunately I'm stuck with more then bivariate interaction but I'm sure
GRETL can do this,
> this question is how!
The script below should do what I think you need; the trick is creating a series which
contains, in coded form, all the possible combinations of values of the variables
contained in a list. This is what the function "pack" does; note that
"pack" also creates a matrix which is used in the "unpack" function
later.
See if this helps:
<hansl>
set echo off
set messages off
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
pwrof2 = {}
n = 1
k = 1
loop foreach i X --quiet
ret += k*X.$i
n = 2^ceil(log2(1+max(X.$i)))
k *= n
pwrof2 |= n
end loop
return ret
end function
function matrix unpack(scalar x, matrix pwr)
k = rows(pwr)
matrix ret = zeros(k,1)
loop i=1..k --quiet
h = pwr[i]
a = x % h
ret[i] = a
x = (x-a)/h
end loop
return ret
end function
# --- END FUNCTIONS -----------------------------------------
open pizza4.gdt
series ages = age<=20 ? 0 : (age>20 && age <=40) ? 1 : 2
list A = female hs ages
matrix codes = {}
u = pack(A, &codes)
n_u = values(u)
loop i = 1..rows(n_u) --quiet
k = n_u[i]
smpl u==k --restrict --replace
c = unpack(k, codes)
l = 1
loop foreach j A --quiet
printf "%10s = %d", "$j", c[l]
l++
end loop
printf "\ncases = %d, mean(pizza) = %g, mean(income) = %g\n\n", \
$nobs, mean(pizza), mean(income)
end loop
smpl full
</hansl>
>
> It's even more complex since the R function is not that good either, cos e.g. for
MAVOVA one needs the variance-covariance-structure of
> the 'interaction series'. That's why in GRETL lists should be processed
which makes the stuff not easier.
>
> I worked around with the new '^' operator and have some promising results,
but a build-in function would be the best.
>
> Cheers
> Leon
>
> <hansl>
> open pizza4.gdt
> series ages = age<=20 ? 0 : (age>20 && age <=40) ? 1 : 2
> set echo off
> foreign language=R --send-data --quiet
> library(plyr)
> ddply(gretldata[,c(1,2,4,6,8)], ~ female + college + ages, numcolwise(mean))
> end foreign
> <hansl>
>
> While the bivariate case in rather easy as in
>
> <hansl>
> open pizza4.gdt
> set echo off
> series ages = age<=20 ? 0 : (age>20 && age <=40) ? 1 : 2
>
> list G1 = 2 4
> list G2 = 2 8
> list G3 = 4 8
> list G = G1 || G2
>
> scalar times = 2 # should also be possible to be
set to nelem(G)
>
> #set up of all combination list
> loop for i=2..times -q
> string listName = "inter$i"
> list @listName = null
> endloop
>
> list part1 = null
> list part2 = G
>
> # bivariate interaction
> loop foreach i G-q
> part1 = G.$i
> part2 -= G.$i
> inter2 += part2^part1
> part2 += G.$i
> endloop
> <hansl>
>
>
>
> Am 20.02.2013 17:45, schrieb Riccardo (Jack) Lucchetti:
>> On Wed, 20 Feb 2013, Allin Cottrell wrote:
>>> On Wed, 20 Feb 2013, Riccardo (Jack) Lucchetti wrote:
>>>> Very nice. The next step, logically, would be to support user-written
functions too. However, this would mean to complicate the code by a factor (I reckon) of 1
to 5 or so.
>>> I was afraid the factor might be at the top end of that range, but I
experimented and it's more like 0.25. So user-functions are now supported. The
function must take a single series argument and return a scalar. Example:
>>> <hansl>
>>> function scalar my_aggregator (series x)
>>> return sum(x^3)
>>> end function
>>> open credscore.gdt
>>> matrix m = aggregate(Income, Acc, my_aggregator)
>>> print m
>>> </hansl>
>> Now, I don't want to be guilty of personality cult, but at the risk of
sounding like an old Stalinist apparatchik I have to say I am left in awe by the skills of
our beloved leader.
>> Studying the cvs diff has been for several years my primary method for learning
C, but this case stands out as a true gem.
>> Thank you.
>> -------------------------------------------------------
>> Riccardo (Jack) Lucchetti
>> Dipartimento di Scienze Economiche e Sociali (DiSES)
>>
>> Università Politecnica delle Marche
>> (formerly known as Università di Ancona)
>>
>> r.lucchetti(a)univpm.it
>> http://www2.econ.univpm.it/servizi/hpp/lucchetti
>> -------------------------------------------------------
>> _______________________________________________
>> Gretl-users mailing list
>> Gretl-users(a)lists.wfu.edu
>> http://lists.wfu.edu/mailman/listinfo/gretl-users
-------------------------------------------------------
Riccardo (Jack) Lucchetti
Dipartimento di Scienze Economiche e Sociali (DiSES)
Università Politecnica delle Marche
(formerly known as Università di Ancona)
r.lucchetti(a)univpm.it
http://www2.econ.univpm.it/servizi/hpp/lucchetti
-------------------------------------------------------
8:52 p.m.
I'm working since weeks now on a comprehensive 'SummaryBy' function. It's
not that easy as it seems, especially if u want something like a combination of discrete
variables (and to use it for tests like Box-M...). With a bunch of new hansl
functionalities the target has come closer! Thanks Allin for implementing the new
stuff!!!
At the moment my function makes all necessary calculations but the user has to be
informed correctly what summaries he receives (The bivariate interaction is not a problem
anymore).
In terms of multivariate statistic I also programmed:
-Mardia Test for multivariate norm dist
-MANOVA
-Linear Discriminant Analysis
-Scale function for standardization
-renumber function for discrete series
Whenever it comes to calculating variances a MLE switch is included in order to compare
the results to e.g. R.
I hope to get the package work for productive use soon, so that I can upload it :-)
Leon
Am 19.02.2013 um 19:50 schrieb ahmadou dicko <dicko.ahmadou(a)gmail.com>:
Thank you very much this is exactly what I was looking for.
I'll try to understand better hansl to improve this function and generalized it.
I think that having a general "by" operator for common aggregator functions
(max, mean, etc.) can be useful for other Gretl users.
Thanks again for this example showing hansl capabilities.
On Tue, Feb 19, 2013 at 6:40 PM, Allin Cottrell <cottrell(a)wfu.edu> wrote:
> On Tue, 19 Feb 2013, ahmadou dicko wrote:
>
> > I want to thank again all Gretl developpers for this wonderful software.
>
> Glad you like it!
>
> > I try to port some of my R code into Gretl and I miss few things.
> >
> > For example, what is the easiest way to perform some aggregate operation in
> > Gretl like :
> >
> > - aggregate(x, by = y, FUN) in R
>
> This functionality is not built-in (except in relation to the
> "summary" command, using the --by option). However it's
> possible to write a function to do this sort of thing. The
> following is not very general but should give you the idea:
>
> <hansl>
> function matrix aggregate (series x, series y, string funname)
> matrix m = values(y) ~ 0
> loop i=1..rows(m) --quiet
> smpl y == m[i,1] --restrict --replace
> m[i,2] = @funname(x)
> printf "@funname(x) for y=%g: %g\n", m[i,1], m[i,2]
> endloop
> colnames(m, "y f(x)")
> return m
> end function
>
> open credscore.gdt
> m = aggregate(Income, Acc, "mean")
> print m
> m = aggregate(Income, Acc, "sd")
> print m
> </hansl>
>
> Allin Cottrell
> _______________________________________________
> Gretl-users mailing list
> Gretl-users(a)lists.wfu.edu
> http://lists.wfu.edu/mailman/listinfo/gretl-users
--
Ahmadou H. DICKO
Data scientist and applied economist
PhD student in Climate change economics
Faculty of economics and managment - Cheikh Anta Diop University
West African Science Service Center on Climate Change and Adaptated Land Use (WASCAL)
Center for Development Research (ZEF) - University of Bonn
twitter : @dickoah
skype : dicko.ahmadou.h
tel : 33 827 55 16
_______________________________________________
Gretl-users mailing list
Gretl-users(a)lists.wfu.edu
http://lists.wfu.edu/mailman/listinfo/gretl-users
4328
days inactive
4334
days old
11 comments
4 participants
participants (4)
-
ahmadou dicko -
Allin Cottrell -
Pindar -
Riccardo (Jack) Lucchetti