*** operator that image an Rsf to a single point or two *** 
I currenly use Variance operator to fill the output cube with the 
same variance. I think that is okay as long as I offer a {\tt createRange()} 
method that creates a RealVector (single element). However, in image 
processing I often want the input "to be filled" with the result, especially
in nonstationary applications where the various data patches. 
I feel best is to compute the minimal set and then to use a wrapper class 
to fill the data set with that minimal value. A bit overhead but nice 
design. 

*** elementwise operations *** 

A bunch of standard elementwise operations. Some of these operations are 
part of the Rsf design. The ones that are not I wrote operators that 
apply the corresponding Java operation (usually from java.lang.Math) to 
all elements of the Rsf. I gave all operators three user interfaces: 
a standard Jag operator interface, 
a main method that allows a researcher to invoke the operator as a standalone 
routine (SEP-like), and finally 
a static method that implements the actual operation. 
I wonder if we always can and want to implement these three interfaces.  

Elw still missing: log, exp, sqrt. 

Div by 3 and Mul by 3 are inverse to each other. However, they are not 
linear operations (Div is not). Should the two operators be linked, and 
if, how? 

Are these tools linear or nonlinear: e.g. ElwDiv or ElwExp? Some of them 
have inverses in the sense that B[A x] = I x. 

Later I want statOp, seisOp, mathOp etc ... I need a tool that finds all 
occurences of a class and then allows me to change it conveniently and 
safely. 

Many of these operators could be static since they basically do not depend 
on anything but their current input. Mul(fac1, fac2) for example. But this 
does not fit our operator concept, where the operator carries additional 
information such as what is your Range and Domain etc. 

I compromise in some cases (Inv, Mul) by having an operator implementation 
with two backdoors: a static apply and a SEP-like main routine. Should be 
fun to see how this develops. 

Inv(data) could do the transformation in place. No extra allocation. 
All functions can do that. Insure that Op.image(d,d) works (since 
operations are elementwise that operation should be fine). 

 * Maybe this should be integrated into a larger routine such as SEP's Add.
 * I kind of like it modular, Unix-like. I sometimes wonder if that should 
 * all be part of Rsf. Probably not. 

