RE: [eigen] Using Matrix<AutoDiff> in conjunction with Matrix<double>?

[<Daniel.Vollmer@xxxxxx>]

Hi,

thanks for the pointer.

the following extensions to AutoDiff seem to at least help somewhat:

// so we can print matrices of AutoDiffScalar

template<typename DerType>

struct significant_decimals_impl<AutoDiffScalar<DerType> > : significant_decimals_impl<typename DerType::Scalar> { };

// allows Matrix<AutoDiff<T>, 3, 1>.dot(Matrix<T, 3, 1>)

template<typename DerType>

struct conj_helper<Eigen::AutoDiffScalar<DerType>, typename DerType::Scalar, false, false>

{

  EIGEN_STRONG_INLINE Eigen::AutoDiffScalar<DerType> pmul(const Eigen::AutoDiffScalar<DerType> &x,

    const typename DerType::Scalar &y) const

  { return x*y; }

};

// allows Matrix<T, 3, 1>.dot(Matrix<AutoDiff<T>, 3, 1>)

template<typename DerType>

struct conj_helper<typename DerType::Scalar, Eigen::AutoDiffScalar<DerType>, false, false>

{

  EIGEN_STRONG_INLINE Eigen::AutoDiffScalar<DerType> pmul(const typename DerType::Scalar &x,

    const Eigen::AutoDiffScalar<DerType> &y) const

  { return x*y; }

};

The required promotion for using mixed types (e.g. AutoDiff<T> * Matrix<T> or Matrix<T> + Matrix<AutoDiff<T>>) is still missing.

Best regards

Daniel Vollmer

--------------------------
Deutsches Zentrum für Luft- und Raumfahrt e.V. (DLR)
German Aerospace Center
Institute of Aerodynamics and Flow Technology | Lilienthalplatz 7 | 38108 Braunschweig | Germany

Daniel Vollmer | AS C²A²S²E
www.DLR.de

---

Von: Gael Guennebaud [gael.guennebaud@xxxxxxxxx]
Gesendet: Montag, 4. April 2016 11:42
An: eigen
Betreff: Re: [eigen] Using Matrix<AutoDiff> in conjunction with Matrix<double>?

Yes, adding such flexibility is desirable, and this issue has been identified a long time ago:

http://eigen.tuxfamily.org/bz/show_bug.cgi?id=279

feel free to extend AutoDiffScalar and to propose a patch.

gael

On Thu, Mar 31, 2016 at 5:21 PM, <Daniel.Vollmer@xxxxxx> wrote:

Hi,

I'm working with the (unsupported) AutoDiff module and I was wondering whether it might be worthwhile to support mixing expressions containing Matrix<AutoDiff<T> > with Matrix<T>, e.g.

  typedef Eigen::Matrix<double, 3, 1> Vec;
  typedef Eigen::AutoDiffScalar<Eigen::Vector3d> AD;
  typedef Eigen::Matrix<AD, 3, 1> VecAD;

  VecAD foo(VecAD::Zero());
  Vec bar(Vec::Ones());
  foo += bar; // fail: need to use cast, `bar.cast<AD>()` works
  foo = bar * AD(0.5); // fail: error: invalid operands to binary _expression_ ('Vec' (aka 'Matrix<double, 3, 1>') and'AD' (aka 'AutoDiffScalar<Matrix<double, 3, 1> >'))
  AD v = foo.dot(bar); // fail: error: implicit instantiation of undefined template Eigen::internal::conj_helper<Eigen::AutoDiffScalar<Eigen::Matrix<double, 3, 1, 0, 3, 1> >, double, false, false>'

I can work around this by using `cast<AD>()`, but that is sub-optimal because the derivatives are then known to be zero (and could thus be implemented more efficiently).

Can I just extend the supported expressions to do this without too much trouble? How would I go about this?


As an additional note, in order to stream Matrices containing AD, I had to do the following:

namespace Eigen {
namespace internal {

// so we can print matrices of AutoDiffScalar
template<typename DerType>
struct significant_decimals_impl<AutoDiffScalar<DerType> > : significant_decimals_impl<typename DerType::Scalar> { };

} // end namespace internal
} // end namespace Eigen


Best regards

Daniel Vollmer

--------------------------
Deutsches Zentrum für Luft- und Raumfahrt e.V. (DLR)
German Aerospace Center
Institute of Aerodynamics and Flow Technology | Lilienthalplatz 7 | 38108 Braunschweig | Germany

Daniel Vollmer | AS C²A²S²E
www..DLR.de