How do I write a function that has optional Eigen::Ref output args?

Question

I'm writing a function that has 1 input and 3 outputs like the following:

void ComputeABC(const Eigen::Vector2d& x,
                Eigen::Matrix2d& a,
                Eigen::Matrix2d& b,
                Eigen::Matrix2d& c)

However, I need my output types to be compatible with both Eigen::Matrix2d and Eigen::Map<Eigen::Matrix2d>. Luckily, Eigen provides a Ref type:

void ComputeABC(const Eigen::Vector2d& x,
                Eigen::Ref<Eigen::Matrix2d> a,
                Eigen::Ref<Eigen::Matrix2d> b,
                Eigen::Ref<Eigen::Matrix2d> c)

Now comes the tricky part. a, b, and c are all expensive to compute, but some intermediate values can be shared in the computation, thus saving some compute. Given that these are expensive, I want to optionally compute each of these. I can do this by making each output type of pointer, and pass in NULL to signal that I don't want to compute that specific value.

void ComputeABC(const Eigen::Vector2d& x,
                Eigen::Ref<Eigen::Matrix2d>* optional_a,
                Eigen::Ref<Eigen::Matrix2d>* optional_b,
                Eigen::Ref<Eigen::Matrix2d>* optional_c)

Unfortunately, this is quite ugly, since the user now has to construct a Ref and then pass it in. Trying to pass in an Eigen::Matrix2d* or Eigen::Map<Eigen::Matrix2d>* will result in a compile error.

Does anyone have any suggestions for how to make this function easier to use, given the following criteria?

• Adding an additional 3 bools to optionally compute values is quite clunky, and the user will still have to construct a dummy Eigen::Ref<Eigen::Matrix2d> for each unwanted output.
• The calling code has either a Eigen::Matrix2d or Eigen::Map<Eigen::Matrix2d> for each arg that needs to be populated, preferably with zero copies.
• Avoid using bare double* arrays as, these don't provide any bounds checking on the memory being used.
• Any subset of a, b, & c can be requested. ( [a], [a, b], [a, b, c], [b], [b, c], [c] ). Thus, overloads don't scale well.

Answer 1

You could pass Ref<Matrix<double,2,Dynamic> > for the optional arguments and check if cols()==0.

using namespace Eigen;
typedef Matrix<double,2,Dynamic> Matrix2xd;
void ComputeABC(const Vector2d& x,
            Ref<Matrix2xd> a, Ref<Matrix2xd> b, Ref<Matrix2xd> c)
{
   if(a.cols()>0) { /* compute a */ }
   if(b.cols()>0) { /* compute b */ }
   if(c.cols()>0) { /* compute c */ }
}

To call the function with only computing a and c:

Matrix2d a, c;
Vector2d x(1.0, 2.0);
ComputeABC(x, a, Matrix2xd(), c); // Matrix2xd() constructs a temporary 2x0 matrix

If (inside ComputeABC) the expression you assign to a is known to have 2 columns, you should not even experience a difference vs Matrix2d, except for an assertion check that a indeed has two columns.

Answer 2

I'm not sure of how you can make a clean interface with so many combinations of output arguments in a single function. I'd instead probably lean towards turning it into a class.

class ABCComputer {
public:
  setInput(const Eigen::Vector2d& x);

  getOptionalA(Eigen::Ref<Eigen::Matrix2d>);
  getOptionalB(Eigen::Ref<Eigen::Matrix2d>);
  getOptionalC(Eigen::Ref<Eigen::Matrix2d>);
};

Because you say the computations of A, B, and C share intermediate values, you can compute the requested values all at once by specifying which outputs are desired with flags:

enum ABCOptions {
  ComputeA = 0x01,
  ComputeB = 0x02,
  ComputeC = 0x04
};


class ABCComputer {
public:
  compute(const Eigen::Vector2d& x, unsigned int options);

  getOptionalA(Eigen::Ref<Eigen::Matrix2d>);
  getOptionalB(Eigen::Ref<Eigen::Matrix2d>);
  getOptionalC(Eigen::Ref<Eigen::Matrix2d>);
};

and call it with something like

ABCComputer abc;
abc.compute(x, ComputeA | ComputeC);
abc.getOptionalA(my_A);
abc.getOptionalC(my_C);

Answer 3

You can wrap the Eigen::Ref in a c++17 std::optional. There is a backport to c++11.

Another option uses the fact that EigenRef is default constructible to do something like this:

template<class Obj>
class Opt
{
    const bool has;
    Obj obj;
public:
    Opt(std::nullptr_t n=nullptr) : has(false) {}
    template<class T>
    Opt(T && o) : has(true), obj(std::forward<T>(o)) {}
    Obj const& operator*() { return obj; }
    operator bool() { return has; }
};

using namespace Eigen;

void print(Opt<Ref<VectorXf>> a, Opt<std::string> b)
{
    if(a) { std::cout << "a=" << *a << std::endl; }
    if(b) { std::cout << "b=" << *b << std::endl; }
}

int main()
{
    VectorXf aaa;
    print(aaa, nullptr);
    std::cout << "Hello World!\n";
}