2 p.m.
Dear Gretl Team,
Is it possible to preserve row and col names of a matrix after
"mreverse" and "trimr" functions? Please take a look at the following
code:
<hansl>
matrix M = {1, 2; 2, 1; 4, 1}
strings Row = defarray("Row1", "Row2", "Row3")
strings Col = defarray("Col1", "Col2")
rownames(M, Row)
colnames(M, Col)
matrix Msortby = msortby(M, 1)
matrix Mreverse = mreverse(M)
matrix Mtrimr = trimr(M, 1, 1)
print M Msortby Mreverse Mtrimr
</hansl>
In my humble opinion, "reverse" and "trimr" could have the same
behavior of "msortby", i.e., keep col and row names as in "msortby".
Best,
Henrique Andrade
1:23 p.m.
Hi,
it doesn't look as if there ever was an answer (holiday season...).
But I think Henrique is right -- and myself have stumbled across a
similar problem, namely when selecting/slicing out a submatrix. Example:
<hansl>
matrix m = {1, 2, 3}
colnames(m, "one two three")
print m
matrix m2 = m[, 1:2]
print m2 # no header anymore
</hansl>
cheers,
sven
Am 31.08.2016 um 16:00 schrieb Henrique Andrade:
Dear Gretl Team,
Is it possible to preserve row and col names of a matrix after
"mreverse" and "trimr" functions? Please take a look at the
following
code:
<hansl>
matrix M = {1, 2; 2, 1; 4, 1}
strings Row = defarray("Row1", "Row2", "Row3")
strings Col = defarray("Col1", "Col2")
rownames(M, Row)
colnames(M, Col)
matrix Msortby = msortby(M, 1)
matrix Mreverse = mreverse(M)
matrix Mtrimr = trimr(M, 1, 1)
print M Msortby Mreverse Mtrimr
</hansl>
In my humble opinion, "reverse" and "trimr" could have the same
behavior of "msortby", i.e., keep col and row names as in "msortby".
Best,
Henrique Andrade
_______________________________________________
Gretl-devel mailing list
Gretl-devel(a)lists.wfu.edu
http://lists.wfu.edu/mailman/listinfo/gretl-devel
1:47 p.m.
On Wed, 2 Nov 2016, Sven Schreiber wrote:
Hi,
it doesn't look as if there ever was an answer (holiday season...).
But I think Henrique is right -- and myself have stumbled across a similar
problem, namely when selecting/slicing out a submatrix. Example:
<hansl>
matrix m = {1, 2, 3}
colnames(m, "one two three")
print m
matrix m2 = m[, 1:2]
print m2 # no header anymore
</hansl>
cheers,
sven
While we're on the subject: I don't remember exactly when, but someone
brouht up the fact that it's not immediate, in Hansl, to delete certain
row/columns from a matrix. Suppose for example that I wanted to modify a
matrix X by killing column 4. The best way to do this would be
<hansl>
X = X[,1:3] ~ X[,5:]
</hansl>
which, however, gets a little awkward if the column you want to drop is
the first or the last one. Ok, you may go
<hansl>
scalar k = 4
if k==1
X = X[,2:]
elif k==cols(X)
X = X[,1:k-1]
else
X = X[,1:k-1] ~ X[,k+1:]
endif
</hansl>
or
<hansl>
X = selifc(X, !(seq(1,cols(X)).=k))
</hansl>
but neither is elegant and transparent at the same time. Worse still,
imagine I wanted to drop column 2, 3 and 5. Ok, you have the übergeekish
<hansl>
e = {2,3,5}
X = selifc(X, !(maxc(seq(1,cols(X)).=e')))
</hansl>
but I wouldn't be averse to introducing a function pair like killcol(X, e)
and killrow(X, e). Opinions?
-------------------------------------------------------
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:10 p.m.
Am 02.11.2016 um 14:47 schrieb Riccardo (Jack) Lucchetti:
While we're on the subject:
You recently have a tendency to use this "speaking of which" phrase to
actually do a Monty-Python-esque "and now for something completely
different" ...
brouht up the fact that it's not immediate, in Hansl, to delete
certain
row/columns from a matrix.
Yeah, by coincidence I just answered this (old) question yesterday on
Stackexchange
(http://stackoverflow.com/questions/37242922/deleting-a-column-in-hansl).
but I wouldn't be averse to introducing a function pair like
killcol(X,
e) and killrow(X, e). Opinions?
First, it would be an improvement. Second, if at all possible, I would
favor some clever extension of the matrix indexing apparatus. For
example (just an example, no claim of optimality), X[-3, -2] might
return the matrix X without the 3rd row and the 2nd column.
cheers,
sven
2:24 p.m.
On Wed, 2 Nov 2016, Sven Schreiber wrote:
Am 02.11.2016 um 14:47 schrieb Riccardo (Jack) Lucchetti:
> While we're on the subject:
You recently have a tendency to use this "speaking of which" phrase to
actually do a Monty-Python-esque "and now for something completely different"
...
"It's..."
-------------------------------------------------------
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:09 p.m.
You recently have a tendency to use this "speaking of which" phrase to actually
do a Monty-Python-esque "and now for something completely different" ...
> brouht up the fact that it's not immediate, in Hansl, to delete certain
> row/columns from a matrix.
Yeah, by coincidence I just answered this (old) question yesterday on Stackexchange
(http://stackoverflow.com/questions/37242922/deleting-a-column-in-hansl).
> but I wouldn't be averse to introducing a function pair like killcol(X,
> e) and killrow(X, e). Opinions?
First, it would be an improvement. Second, if at all possible, I would favor some clever
extension of the matrix indexing apparatus. For example (just an example, no claim of
optimality), X[-3, -2] might return the matrix X without the 3rd row and the 2nd column.
I like Sven's suggestion. I also like that I've had the Liberty Bell March running
through my head since Jack's last comment ;-)
PS
11:49 p.m.
On Wed, 2 Nov 2016, Sven Schreiber wrote:
Am 02.11.2016 um 14:47 schrieb Riccardo (Jack) Lucchetti:
> While we're on the subject:
You recently have a tendency to use this "speaking of which"
phrase to actually do a Monty-Python-esque "and now for something
completely different" ...
> brouht up the fact that it's not immediate, in Hansl, to delete
> certain row/columns from a matrix.
Yeah, by coincidence I just answered this (old) question yesterday on
Stackexchange
(http://stackoverflow.com/questions/37242922/deleting-a-column-in-hansl).
> but I wouldn't be averse to introducing a function pair like
> killcol(X, e) and killrow(X, e). Opinions?
First, it would be an improvement. Second, if at all possible, I
would favor some clever extension of the matrix indexing
apparatus. For example (just an example, no claim of optimality),
X[-3, -2] might return the matrix X without the 3rd row and the
2nd column.
I appreciate that you said "no claim of optimality", but I don't
think we should use negative indices for the purpose you indicate.
Seems to me the de facto standard regarding negative indices in
matrix-oriented languages is that they mean, "count from the end,
not the beginning", not "drop these rows or columns".
Allin
7:32 a.m.
Am 03.11.2016 um 00:49 schrieb Allin Cottrell:
On Wed, 2 Nov 2016, Sven Schreiber wrote:
>
> First, it would be an improvement. Second, if at all possible, I would
> favor some clever extension of the matrix indexing apparatus. For
> example (just an example, no claim of optimality), X[-3, -2] might
> return the matrix X without the 3rd row and the 2nd column.
I appreciate that you said "no claim of optimality", but I don't think
we should use negative indices for the purpose you indicate. Seems to me
the de facto standard regarding negative indices in matrix-oriented
languages is that they mean, "count from the end, not the beginning",
not "drop these rows or columns".
That's true. See how I didn't let my Python/numpy bias show while making
this suggestion?
So any other symbol that is not an arithmetic operator might also do
perhaps. Given that "!" is already negation in the context of "!=",
maybe X[!3, !2] ? Or §?
BTW, "while we're on the subject", a short form for defining a
range/sequence matrix would also be nice. Something like:
{1:5} == seq(1,5)
Then you could do X[!{1:5}, ] which would mean drop the first five rows
from X.
thanks,
sven
7:52 a.m.
On 3 Nov 2016, at 00:49, Allin Cottrell <cottrell(a)wfu.edu>
wrote:
On Wed, 2 Nov 2016, Sven Schreiber wrote:
> Am 02.11.2016 um 14:47 schrieb Riccardo (Jack) Lucchetti:
>
>> While we're on the subject:
>
> You recently have a tendency to use this "speaking of which" phrase to
actually do a Monty-Python-esque "and now for something completely different"
...
>
>> brouht up the fact that it's not immediate, in Hansl, to delete certain
row/columns from a matrix.
>
> Yeah, by coincidence I just answered this (old) question yesterday on Stackexchange
(http://stackoverflow.com/questions/37242922/deleting-a-column-in-hansl).
>
>> but I wouldn't be averse to introducing a function pair like killcol(X, e)
and killrow(X, e). Opinions?
>
> First, it would be an improvement. Second, if at all possible, I would favor some
clever extension of the matrix indexing apparatus. For example (just an example, no claim
of optimality), X[-3, -2] might return the matrix X without the 3rd row and the 2nd
column.
I appreciate that you said "no claim of optimality", but I don't think we
should use negative indices for the purpose you indicate. Seems to me the de facto
standard regarding negative indices in matrix-oriented languages is that they mean,
"count from the end, not the beginning", not "drop these rows or
columns".
Try this in R:
A <- matrix(1:12,nrow=3)
A
A[-1,-2]
displays A without first row and second column.
As I expected and hoped.
Berend
8:28 a.m.
On Thu, 3 Nov 2016, Berend Hasselman wrote:
>> First, it would be an improvement. Second, if at all
possible, I would
>> favor some clever extension of the matrix indexing apparatus. For
>> example (just an example, no claim of optimality), X[-3, -2] might
>> return the matrix X without the 3rd row and the 2nd column.
>
> I appreciate that you said "no claim of optimality", but I don't think
> we should use negative indices for the purpose you indicate. Seems to
> me the de facto standard regarding negative indices in matrix-oriented
> languages is that they mean, "count from the end, not the beginning",
> not "drop these rows or columns".
Try this in R:
A <- matrix(1:12,nrow=3)
A
A[-1,-2]
displays A without first row and second column.
As I expected and hoped.
I normally don't like R very much, but I must admit I find this quite
cool. I guess we could adopt the following convention with respect to
matrix slicing: positive indices mean "keep" and negative indices mean
"drop". My earlier example would just become X[,{-2,-3,-5}], or even
X[,-{2,3,5}].
As for the "from the end" convention, I guess that this is (at least in my
own experience) a rather unusual case, that can be easily handled via
mreverse() or by tricks like
<hansl>
# slice columns 1,3 and 4 from the end
matrix e = (cols(A) + 1) - {1,3,4}
eval A[,e]
</hansl>
The "minus is for dropping" convention would have the advantage of being
(a) intuitive (b) backwards compatible, though we should decide what to do
in the mixed case, eg,
A[,{1,-2}]
Flag an error, perhaps?
-------------------------------------------------------
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:41 p.m.
A[,{1,-2}]
Flag an error, perhaps? Yes,
A <- matrix(1:12,nrow=3)
A[,c(1,-2)] # c(1,2) is R for {1,2}
Error in A[, c(1, -2)] : only 0's may
be mixed with negative subscripts
a = 1:12
a[c(1,-2)]
Error in a[c(1, -2)] : only 0's may be mixed with negative
subscripts
a[c(0,1)]
[1] 1
one can use x[0]->numeric(0)
inside [.....] one can insert or pluses (+zero) or
minuses (+zero) only
Oleh
3 листопада 2016, 10:28:29, від "Riccardo (Jack) Lucchetti"
<r.lucchetti(a)univpm.it>:
On Thu, 3 Nov 2016, Berend Hasselman wrote:
>>> First, it would be an improvement. Second, if at all possible, I would
>>> favor some clever extension of the matrix indexing apparatus. For
>>> example (just an example, no claim of optimality), X[-3, -2] might
>>> return the matrix X without the 3rd row and the 2nd column.
>>
>> I appreciate that you said "no claim of optimality", but I don't
think
>> we should use negative indices for the purpose you indicate. Seems to
>> me the de facto standard regarding negative indices in matrix-oriented
>> languages is that they mean, "count from the end, not the beginning",
>> not "drop these rows or columns".
>
> Try this in R:
>
> A <- matrix(1:12,nrow=3)
> A
> A[-1,-2]
>
> displays A without first row and second column.
> As I expected and hoped.
I normally don't like R very much, but I must admit I find this quite
cool. I guess we could adopt the following convention with respect to
matrix slicing: positive indices mean "keep" and negative indices mean
"drop". My earlier example would just become X[,{-2,-3,-5}], or even
X[,-{2,3,5}].
As for the "from the end" convention, I guess that this is (at least in my
own experience) a rather unusual case, that can be easily handled via
mreverse() or by tricks like
# slice columns 1,3 and 4 from the end
matrix e = (cols(A) + 1) - {1,3,4}
eval A[,e]
The "minus is for dropping" convention would have the advantage of being
(a) intuitive (b) backwards compatible, though we should decide what to do
in the mixed case, eg,
A[,{1,-2}]
Flag an error, perhaps?
-------------------------------------------------------
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-devel mailing list
Gretl-devel(a)lists.wfu.edu
http://lists.wfu.edu/mailman/listinfo/gretl-devel
7:02 p.m.
On Thu, 3 Nov 2016, Berend Hasselman wrote:
Try this in R:
A <- matrix(1:12,nrow=3)
A
A[-1,-2]
displays A without first row and second column.
As I expected and hoped.
OK, if there's a precedent out there, and if people feel that these
semantics are more useful than negative indices meaning "count from
the end", I withdraw my objection.
I've made start on implementation. Supported so far: a single negative
index per dimension, as in Berend's example, and also an all-negative
index-vector per dimension. An exclusion in one dimension can be
combined with an arbitrary "positive" specification in the other.
<hansl>
matrix A = mshape(seq(1,12), 3, 4)
A
eval A[-1,-2]
eval A[1:2,-2]
eval A[{1,3},-2]
eval A[,{-1,-3}]
eval A[2:3,{-1,-3}]
eval A[2:3,seq(-1,-3)]
</hansl>
(As in Jack's follow-up posting, you can't mix positive and negative
values in a single index-vector.)
Not sure about exclusionary "from:to" ranges. The R syntax is
"-(from:to)". Supporting that would require additional changes to the
parser. Maybe just tell people to use seq() for this?
Allin
10:03 p.m.
On Thu, 3 Nov 2016, Allin Cottrell wrote:
Not sure about exclusionary "from:to" ranges. The R syntax
is "-(from:to)".
Supporting that would require additional changes to the parser. Maybe just
tell people to use seq() for this?
If you ask me, seq() is just fine.
-------------------------------------------------------
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:26 p.m.
On Thu, 3 Nov 2016, Riccardo (Jack) Lucchetti wrote:
On Thu, 3 Nov 2016, Allin Cottrell wrote:
> Not sure about exclusionary "from:to" ranges. The R syntax is
"-(from:to)".
> Supporting that would require additional changes to the parser. Maybe just
> tell people to use seq() for this?
If you ask me, seq() is just fine.
I do ask you, and am glad to have your concurring opinion ;-)
Suporting "-(from:to)" would require a rather bothersome extension
of our current syntax.
Allin
3:58 p.m.
Am 03.11.2016 um 20:02 schrieb Allin Cottrell:
I've made start on implementation. Supported so far: a single
negative
index per dimension, as in Berend's example, and also an all-negative
index-vector per dimension. An exclusion in one dimension can be
combined with an arbitrary "positive" specification in the other.
That's very nice!
<hansl>
matrix A = mshape(seq(1,12), 3, 4)
A
eval A[-1,-2]
eval A[1:2,-2]
eval A[{1,3},-2]
eval A[,{-1,-3}]
eval A[2:3,{-1,-3}]
eval A[2:3,seq(-1,-3)]
</hansl>
I just tested that the form "-{2,3}" to represent an all-negative index
vector also works.
(As in Jack's follow-up posting, you can't mix positive and
negative
values in a single index-vector.)
Right -- but could there be a more specific error message maybe? I'm
getting "index out of bounds", which is understandable but still a
little off track I'd say, because each individual entry (-1 and 2) is OK
under this new syntax feature.
Not sure about exclusionary "from:to" ranges. The R syntax
is
"-(from:to)". Supporting that would require additional changes to the
parser. Maybe just tell people to use seq() for this?
An expression "(from:to)" with round parentheses looks a little
un-hanslish indeed.
However, what would be the problem with curly braces in "{from:to}" (my
previous suggestion)? Intuitively I'd say that after an opening brace
"{" it's 100% obvious that we're in a matrix expression where the colon
":" hasn't been allowed so far. So it looks as if it would be relatively
straightforward to teach the parser to recognize the colon as indicating
an integer sequence and translate it to "seq(from,to)".
This is of course unrelated to the original column/row dropping feature,
it would be a general alias for seq() (or more precisely, for the
two-argument variant of seq). I think it would increase hansl's coolness
factor ;-)
thanks,
sven
5:32 p.m.
Am 11.11.2016 um 16:58 schrieb Sven Schreiber:
However, what would be the problem with curly braces in
"{from:to}" (my
previous suggestion)? Intuitively I'd say that after an opening brace
"{" it's 100% obvious that we're in a matrix expression where the
colon
":" hasn't been allowed so far. So it looks as if it would be relatively
straightforward to teach the parser to recognize the colon as indicating
an integer sequence and translate it to "seq(from,to)".
OK, I take that back -- a colon could appear inside curly braces, for
example as part of a ternary expression:
matrix M = { (1==2 ? 3 : 4) }
Hm,
Sven
2716
days inactive
2788
days old
15 comments
7 participants
participants (7)
-
Allin Cottrell -
Berend Hasselman -
Henrique Andrade -
oleg_komashko＠ukr.net -
Riccardo (Jack) Lucchetti -
Summers, Peter -
Sven Schreiber