Conditional.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 <boost/range.hpp>
 
#include <gtsam/inference/Key.h>
 
namespace gtsam {
 
  template<class FACTOR, class DERIVEDCONDITIONAL>
  class Conditional
  {
  protected:
    size_t nrFrontals_;
 
  private:
    typedef Conditional<FACTOR,DERIVEDCONDITIONAL> This;
 
  public:
    typedef boost::iterator_range<typename FACTOR::const_iterator> Frontals;
 
    typedef boost::iterator_range<typename FACTOR::const_iterator> Parents;
 
  protected:
 
    Conditional() : nrFrontals_(0) {}
 
    Conditional(size_t nrFrontals) : nrFrontals_(nrFrontals) {}
 
 
  public:
 
    void print(const std::string& s = "Conditional", const KeyFormatter& formatter = DefaultKeyFormatter) const;
 
    bool equals(const This& c, double tol = 1e-9) const;
 
 
 
    size_t nrFrontals() const { return nrFrontals_; }
 
    size_t nrParents() const { return asFactor().size() - nrFrontals_; }
 
    Key firstFrontalKey() const {
      if(nrFrontals_ > 0)
        return asFactor().front();
      else
        throw std::invalid_argument("Requested Conditional::firstFrontalKey from a conditional with zero frontal keys");
    }
 
    Frontals frontals() const { return boost::make_iterator_range(beginFrontals(), endFrontals()); }
 
    Parents parents() const { return boost::make_iterator_range(beginParents(), endParents()); }
 
    typename FACTOR::const_iterator beginFrontals() const { return asFactor().begin(); }
 
    typename FACTOR::const_iterator endFrontals() const { return asFactor().begin() + nrFrontals_; }
 
    typename FACTOR::const_iterator beginParents() const { return endFrontals(); }
 
    typename FACTOR::const_iterator endParents() const { return asFactor().end(); }
 
 
    size_t& nrFrontals() { return nrFrontals_; }
 
    typename FACTOR::iterator beginFrontals() { return asFactor().begin(); }
 
    typename FACTOR::iterator endFrontals() { return asFactor().begin() + nrFrontals_; }
 
    typename FACTOR::iterator beginParents() { return asFactor().begin() + nrFrontals_; }
 
    typename FACTOR::iterator endParents() { return asFactor().end(); }
 
  private:
    // Cast to factor type (non-const) (casts down to derived conditional type, then up to factor type)
    FACTOR& asFactor() { return static_cast<FACTOR&>(static_cast<DERIVEDCONDITIONAL&>(*this)); }
 
    // Cast to derived type (const) (casts down to derived conditional type, then up to factor type)
    const FACTOR& asFactor() const { return static_cast<const FACTOR&>(static_cast<const DERIVEDCONDITIONAL&>(*this)); }
 
    friend class boost::serialization::access;
    template<class ARCHIVE>
    void serialize(ARCHIVE & ar, const unsigned int /*version*/) {
      ar & BOOST_SERIALIZATION_NVP(nrFrontals_);
    }
 
 
  };
 
} // gtsam