6:22 a.m.
I bumped into a feature of Hansl that may be produce puzzling results:
using the "pre-multiplication by transpose" notation X'Y with X a 1x1
matrix (that is, defined as a matrix, but with 1 row and 1 column, for
instance because the result of the product of a row vector for a column
vector) produces the "non conformable data type" error, while using the
full syntax X'*Y os ok.
bye,
Stefano
--
_________________________________________________________________________
Stefano Fachin
Professore Ordinario di Statistica Economica
Dip. di Scienze Statistiche
Università di Roma "La Sapienza"
P.le A. Moro 5 - 00185 Roma - Italia
Tel. +39-06-49910834
fax +39-06-49910072
URL http://w3.uniroma1.it/fachin/
6:47 a.m.
Am 07.12.2012 12:22, schrieb Stefano Fachin:
I bumped into a feature of Hansl that may be produce puzzling
results:
using the "pre-multiplication by transpose" notation X'Y with X a 1x1
matrix (that is, defined as a matrix, but with 1 row and 1 column, for
instance because the result of the product of a row vector for a column
vector) produces the "non conformable data type" error, while using the
full syntax X'*Y os ok.
bye,
Stefano
Hi Stefano,
what version are you using? I'm not getting this behavior on a November
build of gretl (on Linux).
thanks,
sven
11:52 a.m.
On Fri, 7 Dec 2012, Sven Schreiber wrote:
Am 07.12.2012 12:22, schrieb Stefano Fachin:
> I bumped into a feature of Hansl that may be produce puzzling results:
> using the "pre-multiplication by transpose" notation X'Y with X a 1x1
> matrix (that is, defined as a matrix, but with 1 row and 1 column, for
> instance because the result of the product of a row vector for a column
> vector) produces the "non conformable data type" error, while using the
> full syntax X'*Y os ok.
what version are you using? I'm not getting this behavior on a November
build of gretl (on Linux).
Hmm, I am seeing that on current CVS:
<hansl>
matrix m1 = 2*ones(1,1)
matrix m2 = 3*I(3)
matrix m3 = m1'*m2 # no error flagged
m3
m3 = m1'm2 # error flagged here
</hansl>
Pretty obviously, the results should be consistent, but which
case are we going to say is "right"?
Allin
12:25 p.m.
Pretty obviously, the results should be consistent, but which case
are we going to say is "right"?
I'd argue that a 1x1 matrix should be treated as a scalar in any computations, so the
former (m1'*m2) is "right."
FWIW, in Gauss/Oxgauss both expressions produce the identical result (6*I(3)). Matlab
doesn't allow the x'y operation -- only x'*y.
PS
-----Original Message-----
From: gretl-users-bounces(a)lists.wfu.edu [mailto:gretl-users-bounces@lists.wfu.edu] On
Behalf Of Allin Cottrell
Sent: Friday, December 07, 2012 11:53 AM
To: Gretl list
Subject: Re: [Gretl-users] pre-multiplication by transpose
On Fri, 7 Dec 2012, Sven Schreiber wrote:
Am 07.12.2012 12:22, schrieb Stefano Fachin:
> I bumped into a feature of Hansl that may be produce puzzling results:
> using the "pre-multiplication by transpose" notation X'Y with X a 1x1
> matrix (that is, defined as a matrix, but with 1 row and 1 column,
> for instance because the result of the product of a row vector for a
> column
> vector) produces the "non conformable data type" error, while using
> the full syntax X'*Y os ok.
what version are you using? I'm not getting this behavior on a
November build of gretl (on Linux).
Hmm, I am seeing that on current CVS:
<hansl>
matrix m1 = 2*ones(1,1)
matrix m2 = 3*I(3)
matrix m3 = m1'*m2 # no error flagged
m3
m3 = m1'm2 # error flagged here
</hansl>
Pretty obviously, the results should be consistent, but which case are we going to say is
"right"?
Allin
_______________________________________________
Gretl-users mailing list
Gretl-users(a)lists.wfu.edu
http://lists.wfu.edu/mailman/listinfo/gretl-users
12:48 p.m.
On 12/7/2012 12:25 PM, Summers, Peter wrote:
I'd argue that a 1x1 matrix should be treated as a scalar in any
computations
So what is "right" is what is clearly wrong?
E.g., (1x2)*((2x1)*(2x2)) -> error (as it should be)
but ((1x2)*(2x1))*(2x2) -> (2x2)
So much for associativity.
Alan Isaac
12:58 p.m.
E.g., (1x2)*((2x1)*(2x2)) -> error (as it should be) but
((1x2)*(2x1))*(2x2) -> (2x2) So much for associativity.
But associativity assumes all products are well-defined. A*(B*C) in your example generates
an error because B*C fails.
PS
-----Original Message-----
From: gretl-users-bounces(a)lists.wfu.edu [mailto:gretl-users-bounces@lists.wfu.edu] On
Behalf Of Alan G Isaac
Sent: Friday, December 07, 2012 12:48 PM
To: Gretl list
Subject: Re: [Gretl-users] pre-multiplication by transpose
On 12/7/2012 12:25 PM, Summers, Peter wrote:
I'd argue that a 1x1 matrix should be treated as a scalar in any
computations
So what is "right" is what is clearly wrong?
E.g., (1x2)*((2x1)*(2x2)) -> error (as it should be) but ((1x2)*(2x1))*(2x2) ->
(2x2) So much for associativity.
Alan Isaac
_______________________________________________
Gretl-users mailing list
Gretl-users(a)lists.wfu.edu
http://lists.wfu.edu/mailman/listinfo/gretl-users
1:52 p.m.
That is the point of the example.
Point taken. But your example holds true whether or not we write x'y or x'*y,
doesn't it?
Said another way, it seems to me that your example illustrates the need for careful
scripting rather than the "right" treatment of x'y vs x'*y. For example,
suppose that I have a script that is designed to compute (1x2)*(2x2)*(2x2), but that an
earlier step produces a 2x1 matrix for the second term. Then as I've written it
(A*B*C) I'd get a possibly misleading result, whereas A*(B*C) would give an error and
cause me to revise my code. Granted, in this example I'd rather have the error.
Going back to Allin's original question (whether gretl's treatment of m1'm2 or
m1'*m2 is "right"), your example illustrates a potential problem when m1 is
'unintentionally' a 1x1 matrix. Are you suggesting that both treatments should
give an error? I'm willing to be persuaded, but that is inconsistent with other
languages.
-----Original Message-----
From: gretl-users-bounces(a)lists.wfu.edu [mailto:gretl-users-bounces@lists.wfu.edu] On
Behalf Of Alan G Isaac
Sent: Friday, December 07, 2012 1:05 PM
To: Gretl list
Subject: Re: [Gretl-users] pre-multiplication by transpose
On 12/7/2012 12:58 PM, Summers, Peter wrote:
But associativity assumes all products are well-defined. A*(B*C) in
your example generates an error because B*C fails.
Indeed.
That is the point of the example.
_______________________________________________
Gretl-users mailing list
Gretl-users(a)lists.wfu.edu
http://lists.wfu.edu/mailman/listinfo/gretl-users
2:31 p.m.
On 12/7/2012 1:52 PM, Summers, Peter wrote:
But your example holds true whether or not we write x'y or
x'*y
Absolutely. I was addressing only the issue of
how to handle a 1 x 1 matrix, not the core question.
I agree that many matrix programming languages special case
the 1x1 matrix. I guess it is convenient enough to introduce
the risk I illustrated, at least in the opinion of some.
Not in mine.
I also have an opinion the topic question (explicit is better than implicit),
but not a strong one. One thing is for sure, x'*y needs to be legal.
The question is whether x'y is a legal "shorthand".
Cheers,
Alan
3:59 p.m.
On 12/07/2012 08:31 PM, Alan G Isaac wrote:
On 12/7/2012 1:52 PM, Summers, Peter wrote:
> But your example holds true whether or not we write x'y or x'*y
Absolutely. I was addressing only the issue of
how to handle a 1 x 1 matrix, not the core question.
I agree that many matrix programming languages special case
the 1x1 matrix. I guess it is convenient enough to introduce
the risk I illustrated, at least in the opinion of some.
Not in mine.
I also have an opinion the topic question (explicit is better than implicit),
but not a strong one. One thing is for sure, x'*y needs to be legal.
The question is whether x'y is a legal "shorthand".
To me it would seem that if somebody writes <m'>, the script author is
treating m as a matrix. Because why would you use a transpose if the
object is always expected to be a scalar? Therefore it would seem
appropriate to always treat <m'y> as a matrix multiplication even in the
special case when m is 1x1.
Apart from that, this type of discussion has been led on the mailing
lists of other open-source projects. Maybe we should all study the
arguments and results of those discussions, before trying to re-invent
the wheel... (But you will notice that I, too, was too lazy and instead
wrote this message straight away :-)
cheers,
sven
5:08 p.m.
On Fri, 7 Dec 2012, Sven Schreiber wrote:
On 12/07/2012 08:31 PM, Alan G Isaac wrote:
> On 12/7/2012 1:52 PM, Summers, Peter wrote:
>> But your example holds true whether or not we write x'y or x'*y
>
>
> Absolutely. I was addressing only the issue of
> how to handle a 1 x 1 matrix, not the core question.
>
> I agree that many matrix programming languages special case
> the 1x1 matrix. I guess it is convenient enough to introduce
> the risk I illustrated, at least in the opinion of some.
> Not in mine.
>
> I also have an opinion the topic question (explicit is better than implicit),
> but not a strong one. One thing is for sure, x'*y needs to be legal.
> The question is whether x'y is a legal "shorthand".
To me it would seem that if somebody writes <m'>, the script author is
treating m as a matrix. Because why would you use a transpose if the
object is always expected to be a scalar? Therefore it would seem
appropriate to always treat <m'y> as a matrix multiplication even in the
special case when m is 1x1.
FWIW, I think that's the explanation of gretl's current
inconsistency. If you write "X'Y" it seems clear that you really
intend a matrix operation, with two matrix operands, in which case a
1x1 matrix would not be given special treatment with regard to
conformability. But if you write "X'*Y", with X 1x1, gretl first
evaluates X', producing an anonymous 1x1 matrix, then finds plain
multiplication, and applies the idea that 1x1 matrices can count as
scalars if need be.
Apart from that, this type of discussion has been led on the mailing
lists of other open-source projects. Maybe we should all study the
arguments and results of those discussions, before trying to re-invent
the wheel...
May be worth searching for that sort of thing, yes. Though the
"short answer" lies in what the other software actually permits.
Allin
6:03 p.m.
On 12/07/2012 11:08 PM, Allin Cottrell wrote:
On Fri, 7 Dec 2012, Sven Schreiber wrote:
> On 12/07/2012 08:31 PM, Alan G Isaac wrote:
>> On 12/7/2012 1:52 PM, Summers, Peter wrote:
>>> But your example holds true whether or not we write x'y or x'*y
>>
>>
>> Absolutely. I was addressing only the issue of
>> how to handle a 1 x 1 matrix, not the core question.
>>
>> I agree that many matrix programming languages special case
>> the 1x1 matrix. I guess it is convenient enough to introduce
>> the risk I illustrated, at least in the opinion of some.
>> Not in mine.
>>
>> I also have an opinion the topic question (explicit is better than implicit),
>> but not a strong one. One thing is for sure, x'*y needs to be legal.
>> The question is whether x'y is a legal "shorthand".
>
> To me it would seem that if somebody writes <m'>, the script author is
> treating m as a matrix. Because why would you use a transpose if the
> object is always expected to be a scalar? Therefore it would seem
> appropriate to always treat <m'y> as a matrix multiplication even in the
> special case when m is 1x1.
FWIW, I think that's the explanation of gretl's current
inconsistency. If you write "X'Y" it seems clear that you really
intend a matrix operation, with two matrix operands, in which case a
1x1 matrix would not be given special treatment with regard to
conformability. But if you write "X'*Y", with X 1x1, gretl first
evaluates X', producing an anonymous 1x1 matrix, then finds plain
multiplication, and applies the idea that 1x1 matrices can count as
scalars if need be.
Yeah, although my argument applies to "X'*Y" as well, right? When does
it make sense to treat this as scalar multiplication when X is 1x1? So
I tend to think gretl should allow this only if Y is a row vector.
What's trickier is plain "X*Y" when X is 1x1 and Y is not a row vector
(so written without any transposition), but that apparently is not the
topic right now.
thanks,
sven
8:16 p.m.
On Sat, 8 Dec 2012, Sven Schreiber wrote:
On 12/07/2012 11:08 PM, Allin Cottrell wrote:
> On Fri, 7 Dec 2012, Sven Schreiber wrote:
>
>> On 12/07/2012 08:31 PM, Alan G Isaac wrote:
>>> On 12/7/2012 1:52 PM, Summers, Peter wrote:
>>>> But your example holds true whether or not we write x'y or x'*y
>>>
>>>
>>> Absolutely. I was addressing only the issue of
>>> how to handle a 1 x 1 matrix, not the core question.
>>>
>>> I agree that many matrix programming languages special case
>>> the 1x1 matrix. I guess it is convenient enough to introduce
>>> the risk I illustrated, at least in the opinion of some.
>>> Not in mine.
>>>
>>> I also have an opinion the topic question (explicit is better than
implicit),
>>> but not a strong one. One thing is for sure, x'*y needs to be legal.
>>> The question is whether x'y is a legal "shorthand".
>>
>> To me it would seem that if somebody writes <m'>, the script author is
>> treating m as a matrix. Because why would you use a transpose if the
>> object is always expected to be a scalar? Therefore it would seem
>> appropriate to always treat <m'y> as a matrix multiplication even in
the
>> special case when m is 1x1.
>
> FWIW, I think that's the explanation of gretl's current
> inconsistency. If you write "X'Y" it seems clear that you really
> intend a matrix operation, with two matrix operands, in which case a
> 1x1 matrix would not be given special treatment with regard to
> conformability. But if you write "X'*Y", with X 1x1, gretl first
> evaluates X', producing an anonymous 1x1 matrix, then finds plain
> multiplication, and applies the idea that 1x1 matrices can count as
> scalars if need be.
Yeah, although my argument applies to "X'*Y" as well, right? When does
it make sense to treat this as scalar multiplication when X is 1x1? So
I tend to think gretl should allow this only if Y is a row vector.
In fact, although we could go either way in terms of resolving the
inconsistency of treatment of X'Y and X'*Y, for X or Y 1x1 and not
strictly conformable with the other operand, it would be easier (I
think) to make the latter operation reduce to the former, hence
(absent any other changes) enforcing the stricter interpretation. If
that's what we want.
What's trickier is plain "X*Y" when X is 1x1 and Y is
not a row vector
(so written without any transposition), but that apparently is not the
topic right now.
No, but rescinding the "1x1 matrix is treated as a scalar" policy
more generally would be seriously backward-incompatible.
Allin Cottrell
P.S. Although I haven't shifted it myself, shouldn't this be on
gretl-devel?
5:08 a.m.
On Fri, 7 Dec 2012, Allin Cottrell wrote:
In fact, although we could go either way in terms of resolving the
inconsistency of treatment of X'Y and X'*Y, for X or Y 1x1 and not
strictly conformable with the other operand, it would be easier (I
think) to make the latter operation reduce to the former, hence
(absent any other changes) enforcing the stricter interpretation. If
that's what we want.
Premise: matrix-oriented languages have a short history, compared to the
tradition in mathematically-formal matrix notation. A few conventions have
been emerging in Gauss, Matlab and Ox, with hansl and mata as the
newcomers in the field. It's perfectly natural that some good ideas become
de facto standards (or almost such, such as the A'B syntax, matlab being
the exception), while at the same time there may be inconsistencies and
oddities. Moreover, hansl has not been "designed": many of its features
have been added incrementally as needed, so quirks may arise just as they
do in natural languages, such as English. Sometimes (like in the case of
left- and right- matrix divisions) changing to conform to what others do
is a good idea, sometimes it isn't. I'd say it depends. IMO, the objective
must be to conform to intuition (and established mathematical conventions)
as closely as possible without infringing consistency and predictability
of behaviour.
This said, I think both expressions should be legal: in the expressions
"a'b" and "a' * b" the 'prime' character actually
performs a different
role (as Allin already said): in the first case, it's shorthand for
"transpose and then multiply"; in the second case, it means "transpose and
see what happens next".
In the interest of common sense, I imagine that everybody agrees that
transposition on a 1x1 matrix should be a no-op which takes precedence on
anything else, so "a' * b" is exactly equivalent to "a*b". For
similar
reasons, "a'b" should be interpreted as "since this is shorthand for
"(a')*b, just do the same".
> What's trickier is plain "X*Y" when X is 1x1 and Y
is not a row vector
> (so written without any transposition), but that apparently is not the
> topic right now.
No, but rescinding the "1x1 matrix is treated as a scalar" policy
more generally would be seriously backward-incompatible.
Not only that, it would be wrong IMO. A scalar is not, strictly speaking,
a 1x1 matrix. In fact, the common mathematical convention on how to
interpret $k \cdot A$, $k \in \Re$ and $A \in \Re^{m \times n}$ (pardon my
TeX) is there exactly to avoid the boring and cumbersome details on how to
do "the right way" something quite trivial.
Allin Cottrell
P.S. Although I haven't shifted it myself, shouldn't this be on
gretl-devel?
It's now on both. Is this a bad idea?
-------------------------------------------------------
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
-------------------------------------------------------
12:26 p.m.
On Sat, 8 Dec 2012, Riccardo (Jack) Lucchetti wrote:
On Fri, 7 Dec 2012, Allin Cottrell wrote:
> In fact, although we could go either way in terms of resolving the
> inconsistency of treatment of X'Y and X'*Y, for X or Y 1x1 and not
> strictly conformable with the other operand, it would be easier (I
> think) to make the latter operation reduce to the former, hence
> (absent any other changes) enforcing the stricter interpretation. If
> that's what we want.
Premise: matrix-oriented languages have a short history, compared to the
tradition in mathematically-formal matrix notation. A few conventions have
been emerging in Gauss, Matlab and Ox, with hansl and mata as the newcomers
in the field. It's perfectly natural that some good ideas become de facto
standards (or almost such, such as the A'B syntax, matlab being the
exception), while at the same time there may be inconsistencies and oddities.
Moreover, hansl has not been "designed": many of its features have been added
incrementally as needed, so quirks may arise just as they do in natural
languages, such as English. Sometimes (like in the case of left- and right-
matrix divisions) changing to conform to what others do is a good idea,
sometimes it isn't. I'd say it depends. IMO, the objective must be to conform
to intuition (and established mathematical conventions) as closely as
possible without infringing consistency and predictability of behaviour.
This said, I think both expressions should be legal: in the expressions
"a'b"
and "a' * b" the 'prime' character actually performs a different
role (as
Allin already said): in the first case, it's shorthand for "transpose and
then multiply"; in the second case, it means "transpose and see what happens
next".
In the interest of common sense, I imagine that everybody agrees that
transposition on a 1x1 matrix should be a no-op which takes precedence on
anything else, so "a' * b" is exactly equivalent to "a*b". For
similar
reasons, "a'b" should be interpreted as "since this is shorthand for
"(a')*b,
just do the same".
I think you're right. That's now the situation in CVS.
Allin Cottrell
4248
days inactive
4249
days old
14 comments
6 participants
participants (6)
-
Alan G Isaac -
Allin Cottrell -
Riccardo (Jack) Lucchetti -
Stefano Fachin -
Summers, Peter -
Sven Schreiber