Re: operator overloading
Tom Anderson wrote:
On Tue, 20 May 2008, Mark Space wrote:
I also think that perhaps some sort of matrix semantics could be
provide for some sort of abstract number class, again using []. This
wasn't brought up much, but thinking on it I believe it might be useful.
It wouldn't be. Do you declare the operator in the interfaces - List,
Map, Set - or not? If no, only in AbstractList etc, then users have to
declare their variables as AbstractList, rather than List. That sucks.
If yes, then users can't define their own implementations of List,
because they can't write an implementation of the [] method. That also
sucks.
No, as a subclass of AbstractNumber; eg. AbstractMatrix or something
like that.
I'd like to see it support ',' in the [], ie.
MyMatrix m = new MyMatrix(3,3); // 2 dimensions
m[0,0] = 0.5;
Something like that. Internally, you'd implement this however you want.
Even just a regular fixed size array would be useful for many matrix
style operations.
The proposed [] overloading (proposed here on this thread) were
associative array style operations. Totally different from what I'm
thinking of (which is why it's attached to a different base class).
To implement this, you'd have to pay attention to eliminating
unnecessary object creation. The only general way to implement
arbitrary sized dimensions is through some sort of variable arguments scheme
public abstract class AbstractMatrix<class T> {
T get( int ... i );
void put( T t, int ... i );
}
But this would require the compiler to generate an anonymous array for
each invocation, which could kill performance. However, I think most
practical applications of matrices require only one or two dimensions.
So if the compiler had the option to chose a faster operation for those
types of matrices, then it might be practical.
public abstract class AbstractMatrix<class T> {
T get( int i );
T get( int i, int j );
T get( int ... i );
void put( T t, int i );
void put( T t, int i, int j);
void put( T t, int ... i );
}
Now we have some practical options for small matrices, and a CYA
implementation for arbitrarily large matrices.