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 <cstddef>
#include <functional>
#include <gtsam/config.h>      // Configuration from CMake
#include <Eigen/Dense>
#include <optional>
#include <stdexcept>
#include <string>
 
namespace gtsam {
 
template<int Rows, int Cols>
class OptionalJacobian {
 
public:
 
  typedef Eigen::Matrix<double, Rows, Cols> Jacobian;
 
private:
 
  Eigen::Map<Jacobian> 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) {
    new (&map_) Eigen::Map<Jacobian>(data);
  }
 
  // Private and very dangerous constructor straight from memory
  OptionalJacobian(double* data) : map_(nullptr) {
    if (data) usurp(data);
  }
 
  template<int M, int N>
  friend class OptionalJacobian;
 
public:
 
  OptionalJacobian() :
      map_(nullptr) {
  }
 
  OptionalJacobian(std::nullptr_t /*unused*/) :
      map_(nullptr) {
  }
 
  OptionalJacobian(Jacobian& fixed) :
      map_(nullptr) {
    usurp(fixed.data());
  }
 
  OptionalJacobian(Jacobian* fixedPtr) :
      map_(nullptr) {
    if (fixedPtr)
      usurp(fixedPtr->data());
  }
 
  OptionalJacobian(Eigen::MatrixXd& dynamic) :
      map_(nullptr) {
    dynamic.resize(Rows, Cols); // no malloc if correct size
    usurp(dynamic.data());
  }
 
  OptionalJacobian(Eigen::MatrixXd* dynamic) :
      map_(nullptr) {
    if (dynamic) {
      dynamic->resize(Rows, Cols);  // no malloc if correct size
      usurp(dynamic->data());
    }
  }
 
  template<class MATRIX>
  OptionalJacobian(Eigen::Ref<MATRIX> dynamic_ref) :
      map_(nullptr) {
    if (dynamic_ref.rows() == Rows && dynamic_ref.cols() == Cols && !dynamic_ref.IsRowMajor) {
      usurp(dynamic_ref.data());
    } 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) {
  }
 
  OptionalJacobian(const std::optional<std::reference_wrapper<Eigen::MatrixXd>> optional) :
      map_(nullptr) {
    if (optional) {
      optional->get().resize(Rows, Cols);
      usurp(optional->get().data());
    }
  }
  //  template <typename Derived, bool InnerPanel>
  //  OptionalJacobian(Eigen::Block<Derived,Rows,Cols,InnerPanel> block) : map_(nullptr) { ?? }
 
  operator bool() const {
    return map_.data() != nullptr;
  }
 
  Eigen::Map<Jacobian>& operator*() {
    return map_;
  }
 
  Eigen::Map<Jacobian>* 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));
    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