DiscreteBoundaryFactor.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/discrete/DecisionTreeFactor.h>
#include <gtsam/hybrid/HybridNonlinearFactor.h>
 
namespace gtsam {
 
/* ************************************************************************ */
GTSAM_EXPORT DecisionTreeFactor DiscreteFactorFromErrors(
    const DiscreteKeys& discreteKeys, const AlgebraicDecisionTree<Key>& errors);

class GTSAM_EXPORT DiscreteBoundaryFactor : public DecisionTreeFactor {
 protected:
  static DecisionTreeFactor ComputeDiscreteBoundary(
      const DiscreteKeys& dkeys,
      const HybridNonlinearFactor::FactorValuePairs& factors,
      const gtsam::Values& values);
 
 public:
  // typedefs needed to play nice with gtsam
  typedef DiscreteBoundaryFactor This;
  typedef DecisionTreeFactor Base;  
  typedef std::shared_ptr<DiscreteBoundaryFactor> shared_ptr;


  DiscreteBoundaryFactor() {}

  DiscreteBoundaryFactor(const DiscreteKeys& keys, const ADT& potentials)
      : DecisionTreeFactor(keys, potentials) {}

  DiscreteBoundaryFactor(const DiscreteKeys& dkeys,
                         const HybridNonlinearFactor::FactorValuePairs& factors,
                         const gtsam::Values& continuousVals)
      : DecisionTreeFactor(
            ComputeDiscreteBoundary(dkeys, factors, continuousVals)) {}


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

 
  using DecisionTreeFactor::operator*;

  DiscreteFactor::shared_ptr operator*(double s) const override;

  DiscreteBoundaryFactor operator*(const DiscreteBoundaryFactor& f) const;
 
  using DecisionTreeFactor::operator/;

  DiscreteBoundaryFactor operator/(const DiscreteBoundaryFactor& f) const;


  DiscreteBoundaryFactor apply(Unary op) const;

  DiscreteBoundaryFactor apply(UnaryAssignment op) const;

  DiscreteBoundaryFactor apply(const DiscreteBoundaryFactor& f,
                               Binary op) const;

 
 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
};
 
// traits
template <>
struct traits<DiscreteBoundaryFactor>
    : public Testable<DiscreteBoundaryFactor> {};
}  // namespace gtsam