OptionalJacobian.h

Go to the documentation of this file.

/* ----------------------------------------------------------------------------
 
 * GTSAM Copyright 2010, Georgia Tech Research Corporation,
 * Atlanta, Georgia 30332-0415
 * All Rights Reserved
 * Authors: Frank Dellaert, et al. (see THANKS for the full author list)
 
 * See LICENSE for the license information
 
 * -------------------------------------------------------------------------- */

 
#pragma once
#include <gtsam/config.h>  // Configuration from CMake
 
#include <Eigen/Core>
#include <Eigen/LU>
#include <cstddef>
#include <functional>
#include <optional>
#include <stdexcept>
#include <string>
 
namespace gtsam {

template<int Rows, int Cols>
class OptionalJacobian {
 
public:

  typedef Eigen::Matrix<double, Rows, Cols> Jacobian;
  typedef Eigen::Stride<Eigen::Dynamic, 1> Stride;
  typedef Eigen::Map<Jacobian, 0, Stride> Map;
 
private:
 
  Map map_; 
 
  // Trick from http://eigen.tuxfamily.org/dox/group__TutorialMapClass.html
  // uses "placement new" to make map_ usurp the memory of the fixed size matrix
  void usurp(double* data, Eigen::Index outerStride) {
    new (&map_) Map(data, Stride(outerStride, 1));
  }
 
  // Private and very dangerous constructor straight from memory
  OptionalJacobian(double* data, Eigen::Index outerStride)
      : map_(nullptr, Stride(1, 1)) {
    if (data) usurp(data, outerStride);
  }
 
  template<int M, int N>
  friend class OptionalJacobian;
 
public:

  OptionalJacobian() : map_(nullptr, Stride(1, 1)) {
  }

  OptionalJacobian(std::nullptr_t /*unused*/) :
      map_(nullptr, Stride(1, 1)) {
  }

  OptionalJacobian(Jacobian& fixed) :
      map_(nullptr, Stride(1, 1)) {
    usurp(fixed.data(), fixed.rows());
  }

  OptionalJacobian(Jacobian* fixedPtr) :
      map_(nullptr, Stride(1, 1)) {
    if (fixedPtr)
      usurp(fixedPtr->data(), fixedPtr->rows());
  }

  OptionalJacobian(Eigen::MatrixXd& dynamic) :
      map_(nullptr, Stride(1, 1)) {
    dynamic.resize(Rows, Cols); // no malloc if correct size
    usurp(dynamic.data(), dynamic.rows());
  }

  OptionalJacobian(Eigen::MatrixXd* dynamic) :
      map_(nullptr, Stride(1, 1)) {
    if (dynamic) {
      dynamic->resize(Rows, Cols);  // no malloc if correct size
      usurp(dynamic->data(), dynamic->rows());
    }
  }

  template<class MATRIX>
  OptionalJacobian(Eigen::Ref<MATRIX> dynamic_ref) :
      map_(nullptr, Stride(1, 1)) {
    if (dynamic_ref.rows() == Rows && dynamic_ref.cols() == Cols &&
        !dynamic_ref.IsRowMajor && dynamic_ref.innerStride() == 1) {
      usurp(dynamic_ref.data(), dynamic_ref.outerStride());
    } else {
      throw std::invalid_argument(
          std::string("OptionalJacobian called with wrong dimensions or "
                      "storage order.\n"
                      "Expected: ") +
          "(" + std::to_string(Rows) + ", " + std::to_string(Cols) + ")");
    }
  } 

  OptionalJacobian(std::nullopt_t /*none*/) :
      map_(nullptr, Stride(1, 1)) {
  }

  OptionalJacobian(const std::optional<std::reference_wrapper<Eigen::MatrixXd>> optional) :
      map_(nullptr, Stride(1, 1)) {
    if (optional) {
      optional->get().resize(Rows, Cols);
      usurp(optional->get().data(), optional->get().rows());
    }
  }

  //  template <typename Derived, bool InnerPanel>
  //  OptionalJacobian(Eigen::Block<Derived,Rows,Cols,InnerPanel> block) : map_(nullptr) { ?? }

  operator bool() const {
    return map_.data() != nullptr;
  }

  Map& operator*() {
    return map_;
  }

  Map* operator->() {
    return &map_;
  }

  //  template <int M, int N>
  //  OptionalJacobian<M, N> block(int startRow, int startCol) {
  //    if (*this)
  //      OptionalJacobian<M, N>(map_.block<M, N>(startRow, startCol));
  //    else
  //      return OptionalJacobian<M, N>();
  //  }

  template <int N>
  OptionalJacobian<Rows, N> cols(int startCol) {
    if (*this)
      return OptionalJacobian<Rows, N>(&map_(0, startCol), map_.outerStride());
    else
      return OptionalJacobian<Rows, N>();
  }

};
 
// The pure dynamic specialization of this is needed to support
// variable-sized types. Note that this is designed to work like the
// boost optional scheme from GTSAM 3.
template<>
class OptionalJacobian<Eigen::Dynamic, Eigen::Dynamic> {
 
public:

  typedef Eigen::MatrixXd Jacobian;
 
private:
 
  Jacobian* pointer_; 
 
public:

  OptionalJacobian() :
    pointer_(nullptr) {
  }

  OptionalJacobian(Jacobian* pointer) : pointer_(pointer) {}

  OptionalJacobian(Jacobian& dynamic) : pointer_(&dynamic) {}

  OptionalJacobian(std::nullopt_t /*none*/) :
    pointer_(nullptr) {
  }

  OptionalJacobian(const std::optional<std::reference_wrapper<Eigen::MatrixXd>> optional) :
      pointer_(nullptr) {
    if (optional) pointer_ = &((*optional).get());
  }

  operator bool() const {
    return pointer_!=nullptr;
  }

  Jacobian& operator*() {
    return *pointer_;
  }

  Jacobian* operator->(){ return pointer_; }
};
 
// forward declare
template <typename T> struct traits;

template <class T, class A>
struct MakeJacobian {
  typedef Eigen::Matrix<double, traits<T>::dimension, traits<A>::dimension> type;
};

template<class T, class A>
struct MakeOptionalJacobian {
  typedef OptionalJacobian<traits<T>::dimension,
      traits<A>::dimension> type;
};
 
} // namespace gtsam