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) {}


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

    bool equals(const This& c, double tol = 1e-9) const;


  public:

    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