GaussianFactor.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
 
 * -------------------------------------------------------------------------- */

 
// \callgraph
 
#pragma once
 
#include <gtsam/inference/Factor.h>
#include <gtsam/base/Matrix.h>
#include <gtsam/base/Testable.h>
 
namespace gtsam {
 
  // Forward declarations
  class VectorValues;
  class Scatter;
  class SymmetricBlockMatrix;

  class GTSAM_EXPORT GaussianFactor : public Factor
  {
  public:
    typedef GaussianFactor This; 
    typedef std::shared_ptr<This> shared_ptr; 
    typedef Factor Base; 


    GaussianFactor() {}

    template<typename CONTAINER>
    GaussianFactor(const CONTAINER& keys) : Base(keys) {}


    void print(
        const std::string& s = "",
        const KeyFormatter& formatter = DefaultKeyFormatter) const override = 0;

    virtual bool equals(const GaussianFactor& lf, double tol = 1e-9) const = 0;


    virtual double error(const VectorValues& c) const;

    virtual double deltaError(const VectorValues& c, double* oldError = nullptr,
                              double* newError = nullptr) const;

    double error(const HybridValues& c) const override;

    virtual DenseIndex getDim(const_iterator variable) const = 0;

    virtual Matrix augmentedJacobian() const = 0;

    virtual std::pair<Matrix,Vector> jacobian() const = 0;

    virtual Matrix augmentedInformation() const = 0;

    virtual Matrix information() const = 0;

    VectorValues hessianDiagonal() const;

    virtual void hessianDiagonalAdd(VectorValues& d) const = 0;

    virtual void hessianDiagonal(double* d) const = 0;

    virtual std::map<Key,Matrix> hessianBlockDiagonal() const = 0;

    virtual GaussianFactor::shared_ptr clone() const = 0;

    virtual GaussianFactor::shared_ptr negate() const = 0;

    virtual void updateHessian(const KeyVector& keys,
                           SymmetricBlockMatrix* info) const = 0;

    virtual void updateHessian(const KeyVector& keys,
                           SymmetricBlockMatrix* info,
                           DenseIndex beginCol, DenseIndex endCol) const = 0;


    virtual void multiplyHessianAdd(double alpha, const VectorValues& x, VectorValues& y) const = 0;

    virtual VectorValues gradientAtZero() const = 0;

    virtual void gradientAtZero(double* d) const = 0;

    virtual Vector gradient(Key key, const VectorValues& x) const = 0;


    virtual bool isJacobian() const { return false; }
 
    // Determine position of a given key
    template <typename CONTAINER>
    static DenseIndex Slot(const CONTAINER& keys, Key key) {
      return std::find(keys.begin(), keys.end(), key) - keys.begin();
    }

    
  private:
#if GTSAM_ENABLE_BOOST_SERIALIZATION
    friend class boost::serialization::access;
    template<class ARCHIVE>
    void serialize(ARCHIVE & ar, const unsigned int /*version*/) {
      ar & BOOST_SERIALIZATION_BASE_OBJECT_NVP(Base);
    }
#endif
  }; // GaussianFactor

template<>
struct traits<GaussianFactor> : public Testable<GaussianFactor> {
};
 
} // \ namespace gtsam