[eigen] On lazy evaluation and temporary matrices

[Jose Luis Blanco <joseluisblancoc@xxxxxxxxx>]

Hi guys,

I need the help of someone knowing the inner workings of Eigen. I've
spent a few days stuck debugging an error in some silly computations
with Eigen matrices, and want to rule out potential errors...
Consider  this code:

======================
void func( Matrix<...> &m_out )
{
  Matrix<...> I = ....
  const double numbers[] = { 1.0, x(), -y()*x() , whatever, .... };
  m_out =  I * Matrix<...>(numbers);
}

int main()
{
  Matrix<...> M;
  func(M);
  cout << M << endl;
}
======================

Is it a problem for the temporary object "Matrix<...>(numbers)" to be
created with a pointer to memory on the stack, while the evaluation of
the object for the matrix product is actually evaluated *out* of that
function (where obviously that pointer is invalid)??

I ask because I'm having a very erratic behavior in code like above
(on GCC doesn't work, it does on MSVC; adding a "cout << ..." for an
unrelated matrix changes the result, etc...).
Is it necessary to use instead:

( I * Matrix<...>(numbers) ).eval();

or not even with this .eval() is my code correct?
I'm still having random wrong matrix elements with and without eval(),
so I wanted to be sure on this part before keep on debugging...

Thanks for your time!
JL