3:57 p.m.
Dear all,
I am just using the "omit" command. My initial model has many regressors
and the "omit" command with the "--auto=alpha" option reduces the
specification substantially. I want to find out the index/position of
the variable which is selected as insignificant each round.
So lets say I have three regressors. The initial point estimates are:
binit = { 0.5, 2, 3.4 }
after "omit" the first two regressors are found to be insignificant, and
hence the final estimate is, for instance, given by:
bfinal = { 3.55 }
In this case I would like to have something like a selection vector
which takes unity for the omitted variables:
select = { 1, 1, 0 }
I've got a rather complicated solution in mind but I am wondering
whether there is a built-in command which I am not aware of.
Thanks in advance!
Artur
5:37 p.m.
On Tue, 10 Jun 2014, Artur T. wrote:
Dear all,
I am just using the "omit" command. My initial model has many regressors
and the "omit" command with the "--auto=alpha" option reduces the
specification substantially. I want to find out the index/position of
the variable which is selected as insignificant each round.
So lets say I have three regressors. The initial point estimates are:
binit = { 0.5, 2, 3.4 }
after "omit" the first two regressors are found to be insignificant, and
hence the final estimate is, for instance, given by:
bfinal = { 3.55 }
In this case I would like to have something like a selection vector
which takes unity for the omitted variables:
select = { 1, 1, 0 }
I've got a rather complicated solution in mind but I am wondering
whether there is a built-in command which I am not aware of.
A built-in command? Surely not, much too specialized. But it's easy
enough to do with a function. For example:
<hansl>
function matrix deselected (list L1, list L2)
matrix vd = L1
loop i=1..cols(vd) --quiet
vd[i] = !inlist(L2, L1[i])
endloop
return vd
end function
open data4-10
ols 1 0 2 3 4 5 6
L1 = $xlist
omit --auto=.05
L2 = $xlist
matrix Ldiff = deselected(L1, L2)
print Ldiff
</hansl>
Allin Cottrell
5:52 p.m.
On Tue, 10 Jun 2014, Allin Cottrell wrote:
For example:
<hansl>
function matrix deselected (list L1, list L2)
matrix vd = L1
loop i=1..cols(vd) --quiet
vd[i] = !inlist(L2, L1[i])
endloop
return vd
end function
open data4-10
ols 1 0 2 3 4 5 6
L1 = $xlist
omit --auto=.05
L2 = $xlist
matrix Ldiff = deselected(L1, L2)
print Ldiff
</hansl>
Or, alternatively,
<hansl>
function matrix deselected (list L1, list L2)
matrix m1 = L1
matrix m2 = L2
return !sumc(m1 .= m2')
end function
</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
-------------------------------------------------------
6:07 p.m.
This is really nice. I had a much more complicated idea in mind...
Thank you both for your suggestions, Allin and Jack!
Best,
Artur
Am 10.06.2014 23:52, schrieb Riccardo (Jack) Lucchetti:
function matrix deselected (list L1, list L2)
matrix m1 = L1
matrix m2 = L2
return !sumc(m1 .= m2')
end function
6:09 p.m.
On Tue, 10 Jun 2014, Riccardo (Jack) Lucchetti wrote:
Or, alternatively,
<hansl>
function matrix deselected (list L1, list L2)
matrix m1 = L1
matrix m2 = L2
return !sumc(m1 .= m2')
end function
</hansl>
Ah, and don't forget that you can use "+" and "-", with lists, as
in
<hansl>
open data4-10
ols 1 0 2 3 4 5 6
L1 = $xlist
omit --auto=.05
list omitted = L1 - $xlist
printf "'omit' kicked out %s!\n", varname(omitted)
</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
-------------------------------------------------------
7:27 p.m.
On Tue, 10 Jun 2014, Riccardo (Jack) Lucchetti wrote:
On Tue, 10 Jun 2014, Allin Cottrell wrote:
> For example:
>
> <hansl>
> function matrix deselected (list L1, list L2)
> matrix vd = L1
> loop i=1..cols(vd) --quiet
> vd[i] = !inlist(L2, L1[i])
> endloop
> return vd
> end function
>
> open data4-10
> ols 1 0 2 3 4 5 6
> L1 = $xlist
> omit --auto=.05
> L2 = $xlist
> matrix Ldiff = deselected(L1, L2)
> print Ldiff
> </hansl>
Or, alternatively,
<hansl>
function matrix deselected (list L1, list L2)
matrix m1 = L1
matrix m2 = L2
return !sumc(m1 .= m2')
end function
</hansl>
Now that's truly wicked ;-)
Allin
6:09 a.m.
Am 11.06.2014 01:27, schrieb Allin Cottrell:
On Tue, 10 Jun 2014, Riccardo (Jack) Lucchetti wrote:
> On Tue, 10 Jun 2014, Allin Cottrell wrote:
>
>
>> For example:
>>
>> <hansl>
>> function matrix deselected (list L1, list L2)
>> matrix vd = L1
>> loop i=1..cols(vd) --quiet
>> vd[i] = !inlist(L2, L1[i])
>> endloop
>> return vd
>> end function
>>
>> open data4-10
>> ols 1 0 2 3 4 5 6
>> L1 = $xlist
>> omit --auto=.05
>> L2 = $xlist
>> matrix Ldiff = deselected(L1, L2)
>> print Ldiff
>> </hansl>
>
> Or, alternatively,
>
> <hansl>
> function matrix deselected (list L1, list L2)
> matrix m1 = L1
> matrix m2 = L2
> return !sumc(m1 .= m2')
> end function
> </hansl>
Now that's truly wicked ;-)
Allin
Indeed!
Artur
8:29 a.m.
Am 11.06.2014 12:09, schrieb Artur T.:
Am 11.06.2014 01:27, schrieb Allin Cottrell:
> On Tue, 10 Jun 2014, Riccardo (Jack) Lucchetti wrote:
>
>> Or, alternatively,
>>
>> <hansl>
>> function matrix deselected (list L1, list L2)
>> matrix m1 = L1
>> matrix m2 = L2
>> return !sumc(m1 .= m2')
>> end function
>> </hansl>
>
> Now that's truly wicked ;-)
>
> Allin
>
Indeed!
Artur
_______________________________________________
Jack's ideas are always impressive, although I must say I like his
second suggestion with the list difference much better, it's directly
readable.
Apart from that, the expression:
"!sumc(m1 .= m2')"
puzzles me a little. First because of the transpose in "(m1 .= m2')": if
it is equivalent to "((m1 .= m2)')" I would say I find the order of
precedence surprising. If instead it's the same as "(m1 .= (m2'))" then
I guess I don't understand what the code does.
And secondly, using boolean stuff like "!" on vectors/matrices is always
a little ambiguous: one could interpret it as element-wise (as is done
here AFAICS), or in terms of "is there *any* non-zero element in there",
returning a single 1/0 (TRUE/FALSE) instead of a matrix of ones/zeros.
This is a design decision, is it settled and/or documented yet?
Thanks,
sven
9:29 a.m.
On Wed, 11 Jun 2014, Sven Schreiber wrote:
Am 11.06.2014 12:09, schrieb Artur T.:
> Am 11.06.2014 01:27, schrieb Allin Cottrell:
>> On Tue, 10 Jun 2014, Riccardo (Jack) Lucchetti wrote:
>>
>>> Or, alternatively,
>>>
>>> <hansl>
>>> function matrix deselected (list L1, list L2)
>>> matrix m1 = L1
>>> matrix m2 = L2
>>> return !sumc(m1 .= m2')
>>> end function
>>> </hansl>
>>
>> Now that's truly wicked ;-)
>>
>> Allin
>>
>
> Indeed!
> Artur
> _______________________________________________
Jack's ideas are always impressive, although I must say I like his
second suggestion with the list difference much better, it's directly
readable.
Thank you.
Apart from that, the expression:
"!sumc(m1 .= m2')"
puzzles me a little. First because of the transpose in "(m1 .= m2')": if
it is equivalent to "((m1 .= m2)')" I would say I find the order of
precedence surprising. If instead it's the same as "(m1 .= (m2'))"
then
I guess I don't understand what the code does.
Ok, I admit that maybe I could have commented on it a little.
The idea is to use the "dot-equal" operator and compare a _column_ vector
to a _row_ vector so to have a _matrix_ of results. The idea of summing by
column is, then, just a poor man's version of a multiple OR operation.
And secondly, using boolean stuff like "!" on
vectors/matrices is always
a little ambiguous: one could interpret it as element-wise (as is done
here AFAICS), or in terms of "is there *any* non-zero element in there",
returning a single 1/0 (TRUE/FALSE) instead of a matrix of ones/zeros.
This is a design decision, is it settled and/or documented yet?
No, that's element-by-element.
-------------------------------------------------------
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
-------------------------------------------------------
11:47 a.m.
Am 11.06.2014 15:29, schrieb Riccardo (Jack) Lucchetti:
On Wed, 11 Jun 2014, Sven Schreiber wrote:
> Apart from that, the expression:
> "!sumc(m1 .= m2')"
> puzzles me a little. First because of the transpose in "(m1 .= m2')":
if
> it is equivalent to "((m1 .= m2)')" I would say I find the order of
> precedence surprising. If instead it's the same as "(m1 .= (m2'))"
then
> I guess I don't understand what the code does.
Ok, I admit that maybe I could have commented on it a little.
The idea is to use the "dot-equal" operator and compare a _column_
vector to a _row_ vector so to have a _matrix_ of results.
I have to think about whether I love or hate it, given that in
gretl/hansl a vector appears to be nothing than a special matrix and
therefore it is always clear whether it's a row or column (as opposed to
python-numpy for example, where people like to use 1-dim-arrays for
vectors, where the property row/column is undefined). But I guess this
can qualify as broadcasting behavior.
Then I would expect that (m1 .* m2') would also work (will test, have to
run now)...
cheers,
sven
12:16 p.m.
On Wed, 11 Jun 2014, Sven Schreiber wrote:
I have to think about whether I love or hate it, given that in
gretl/hansl a vector appears to be nothing than a special matrix and
therefore it is always clear whether it's a row or column (as opposed to
python-numpy for example, where people like to use 1-dim-arrays for
vectors, where the property row/column is undefined). But I guess this
can qualify as broadcasting behavior.
Constructs of this kind are rather common in matrix-oriented languages
such as gauss and ox.
Then I would expect that (m1 .* m2') would also work (will test,
have to
run now)...
Yes it would, but the it would do nothing special: a (column * row =
matrix) product is just ordinary matrix algebra, so you could omit the dot
and it would do he same thing. The nice thing is that (m1 ./ m2'), despite
being nothing short of heretical in proper matrix algebra, works as one
would expect it to. Where by "one" I mean anyone who ever played with
dollar signs in spreadsheets at least once in their life.
-------------------------------------------------------
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
-------------------------------------------------------
3751
days inactive
3752
days old
10 comments
4 participants
participants (4)
-
Allin Cottrell -
Artur T. -
Riccardo (Jack) Lucchetti -
Sven Schreiber