From: Peter Vanbroekhoven <calamitates@...>
Date: 2005-10-19T01:08:14+09:00
Subject: Re: Integer#** weirdness

On Tue, 18 Oct 2005, Mathieu Bouchard wrote:

> What should happen after coercion? if i do 2**aMatrix, is it required that
> the left side gets promoted to a matrix (that is, the same type as the
> right-handed argument) ? Then is there any definition of matrix**matrix ?
> (i haven't ever used one). It would have to extend the semantics of
> scalar**matrix. Maybe I'm just lost too...
>
> But then, x**y = exp(log(x)*y), and since both exp and log are defined on
> matrices (through use of singular value decomposition), this gives us a
> natural definition for aMatrix**anotherMatrix.

I suppose it's only defined for square matrices. And indeed, through power 
series, about any analytic function can be defined on square matrices (for 
which the power series converges, of course).

But that's besides the point (of my problem), point is that Ruby as it is 
now precludes these kinds of things by doing the comparison before the 
coercion in some cases. This means that if I wanted to add matrix 
exponentials to Ruby, I'd need to redefine Integer#** instead of hooking 
into Ruby's coercion framework.

OTOH, coercion is indeed not always an option. Say I just wanted to define 
someInteger**someMatrix, then I've got only one option in Ruby's coercion 
framework, namely to coerce the integer to a matrix. And although it is 
possible to define someMatrix**someOtherMatrix, I may not want to go 
through all that trouble, even when someMatrix is just a 1x1 matrix in 
this case because it is overhead to build the matrix for nothing.

> The complex fields (like Q(sqrt(-1)) and C) are not in any way totally
> orderable. If you quotient the field in some way then you may obtain
> something totally orderable or not, but the best you can get with an
> ordinary complex field is a partial order. However Ruby doesn't have a
> Semicomparable interface (the name i wanted to give to partial ordering in
> Ruby), despite the Module class already supporting most of it in an
> implicit way: think about the meaning of "A<B" as "A is subclass of B" aka
> "A objects are a subset of B objects".
> 
> What do you think of this?

C can be totally ordered, for instance lexical order (with i = sqrt(-1)):

   a + b * i <= c + d * i   iff   a < c  or  a = c and b <= d

Is that a useable order? Well, that depends on what you need that order 
for. There are other orders possible though, but Ruby has only support for 
a single order. I wonder how hard it would be to have Ruby support 
multiple orders for the same kind of object. Given that we can use 
different < symbols, it would probably look like this:

   Complex.with_ordering(Complex::LexicalOrder) do
     Complex(1, 1) < Complex(1, 2) #=> true
   end

IMO though, we don't need a separate Semicomparable interface. #<=> 
already returns nil when two objects are not comparable. For instance
1 <=> true gives nil. Currently the comparison methods in Comparable raise 
an error when #<=> returns nil, but this could be changed to have these 
methods return false instead. Or nil, as Module#< does when two classes 
are not comparable, which would make things more consistent.

Peter