Re: [eigen] proposal for "clean" output arguments

[ Thread Index | Date Index | More Archives ]

On Tue, Aug 18, 2009 at 7:31 AM, Gael Guennebaud <gael.guennebaud@xxxxxxxxx> wrote:
Hi all,

here is a proposal to deal with functions having output (or inout)
arguments. Currently the situation is quite a mess:

1 - some take non const references like
2 - some take pointers like LU::solve(const MatrixBase<T1>& B,
MatrixBase<T2>* X)
3 - some take const references like MatrixBase<T1>::swap(const MatrixBase<T2>&)

The main advantage of the solution 3 is that allows to use temporary
proxies, e.g.:


The main advantage of solution 2 is that it makes it clear what is an output:, &x);

The respective drawbacks of each method are pretty obvious I won't
enumerate them one more time...

So what I propose is to add a trivial Output<T> class mimicking a
reference T& that we'll be passed by value. Ok to make thing crystal
clear here is such a Output class:

template<typename T> class Output
   Output(T& obj) : m_object(obj) { }
   operator T&() { return m_object; }
   T& m_object;

then we add a output() member function to AnyMatrixBase<> :

Output<Derived> output() { return derived(); }

then the function LU::solve(const MatrixBase<T1>& B, MatrixBase<T2>*
X) can be rewritten:

LU::solve(const MatrixBase<T1>& B, Output<T2> _x) {
 T2& x(_x);
 // use x

and the user sill call it like this:, xs.col(2)..output());

For in-out argument we can do the same with a InOut<T> class, and a
AnyMatrixBase::inout() function.

Unless I missed something, I think this solution has all the
advantages that someone can expect:
- it is more C++ than pointers,
- it respects constness (unlike const references)
- it allows to use temporary proxies returned by a function (unlike
references and pointers)
- it make it crystal clear what is an output and an in-out arguments
when someone read a piece of code (unlike all other solutions)

The only limitation I can see is how to extend this concept to scalar
type arguments because we cannot have:

double x;

Note that if we don't make the ctor of Output explicit, then the
following we'll work:

void foo(Output<float> _x);

float x;

If we want to enforce to have "output" next to x, one possibility is
to add a global function output(T&) and make the ctor of Output

float x;

Note that such a global function will only work on declared objects,
and not on temporary proxies, that is why we really have to also have
the output() function as a member of AnyMatrixBase...

Of course, another drawback is more API changes...

What do you think ?

I'm mildly opposed to this because I don't find the .output() or .inout() notation clearer.. Specifically, I suspect that if you put the following to C++ programmers who know math but not eigen:

Vector3d x, b;
Matrix3d A;
b = ....  // fill in b
A = ... // fill in A, x.output());

They would not guess what output() means. Does that mean output to the screen?

I suggest having a .reference() or .ref() method instead of output() or inout(); that makes it clear that you're passing a reference. I think there's little value in specifying the difference between out and inout; it should be clear from the caller's code. 

If Output<T> has an implicit constructor taking a pointer to T, then there is no need to  break the API. This way, & notation is supported for simple matrix types, and there is .ref() to get a mutable reference to a temporary., &x);, x.block<3,10>(0,0).reference());



Mail converted by MHonArc 2.6.19+