AlgebraicDecisionTree.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/base/Testable.h>
#include <gtsam/discrete/DecisionTree-inl.h>
 
#include <algorithm>
#include <limits>
#include <map>
#include <string>
#include <iomanip>
#include <vector>
 
namespace gtsam {
 
  template <typename L>
  class AlgebraicDecisionTree : public DecisionTree<L, double> {
    static std::string DefaultFormatter(const L& x) {
      std::stringstream ss;
      ss << x;
      return ss.str();
    }
 
   public:
    using Base = DecisionTree<L, double>;
 
    struct Ring {
      static inline double zero() { return 0.0; }
      static inline double one() { return 1.0; }
      static inline double add(const double& a, const double& b) {
        return a + b;
      }
      static inline double max(const double& a, const double& b) {
        return std::max(a, b);
      }
      static inline double mul(const double& a, const double& b) {
        return a * b;
      }
      static inline double div(const double& a, const double& b) {
        return a / b;
      }
      static inline double id(const double& x) { return x; }
      static inline double negate(const double& x) { return -x; }
    };
 
    AlgebraicDecisionTree(double leaf = 1.0) : Base(leaf) {}
 
    // Explicitly non-explicit constructor
    AlgebraicDecisionTree(const Base& add) : Base(add) {}
 
    AlgebraicDecisionTree(const L& label, double y1, double y2)
        : Base(label, y1, y2) {}
 
    AlgebraicDecisionTree(const typename Base::LabelC& labelC, double y1,
                          double y2)
        : Base(labelC, y1, y2) {}
 
    AlgebraicDecisionTree  //
        (const std::vector<typename Base::LabelC>& labelCs,
         const std::vector<double>& ys) {
      this->root_ =
          Base::create(labelCs.begin(), labelCs.end(), ys.begin(), ys.end());
    }
 
    AlgebraicDecisionTree  //
        (const std::vector<typename Base::LabelC>& labelCs,
        const std::string& table) {
      // Convert string to doubles
      std::vector<double> ys;
      std::istringstream iss(table);
      std::copy(std::istream_iterator<double>(iss),
                std::istream_iterator<double>(), std::back_inserter(ys));
 
      // now call recursive Create
      this->root_ =
          Base::create(labelCs.begin(), labelCs.end(), ys.begin(), ys.end());
    }
 
    template <typename Iterator>
    AlgebraicDecisionTree(Iterator begin, Iterator end, const L& label)
        : Base(nullptr) {
      this->root_ = compose(begin, end, label);
    }
 
    template <typename M>
    AlgebraicDecisionTree(const AlgebraicDecisionTree<M>& other,
                          const std::map<M, L>& map) {
      // Functor for label conversion so we can use `convertFrom`.
      std::function<L(const M&)> L_of_M = [&map](const M& label) -> L {
        return map.at(label);
      };
      std::function<double(const double&)> op = Ring::id;
      this->root_ = DecisionTree<L, double>::convertFrom(other.root_, L_of_M, op);
    }
 
    template <typename X, typename Func>
    AlgebraicDecisionTree(const DecisionTree<L, X>& other, Func f)
        : Base(other, f) {}
 
    AlgebraicDecisionTree operator+(const AlgebraicDecisionTree& g) const {
      return this->apply(g, &Ring::add);
    }
 
    AlgebraicDecisionTree operator-() const {
      return this->apply(&Ring::negate);
    }
 
    AlgebraicDecisionTree operator-(const AlgebraicDecisionTree& g) const {
      return *this + (-g);
    }
 
    AlgebraicDecisionTree operator*(const AlgebraicDecisionTree& g) const {
      return this->apply(g, &Ring::mul);
    }
 
    AlgebraicDecisionTree operator/(const AlgebraicDecisionTree& g) const {
      return this->apply(g, &Ring::div);
    }
 
    double sum() const {
      double sum = 0;
      auto visitor = [&](double y) { sum += y; };
      this->visit(visitor);
      return sum;
    }
 
    AlgebraicDecisionTree normalize() const { return (*this) / this->sum(); }
 
    double min() const {
      double min = std::numeric_limits<double>::max();
      auto visitor = [&](double x) { min = x < min ? x : min; };
      this->visit(visitor);
      return min;
    }
 
    double max() const {
      // Get the most negative value
      double max = -std::numeric_limits<double>::max();
      auto visitor = [&](double x) { max = x > max ? x : max; };
      this->visit(visitor);
      return max;
    }
 
    AlgebraicDecisionTree sum(const L& label, size_t cardinality) const {
      return this->combine(label, cardinality, &Ring::add);
    }
 
    AlgebraicDecisionTree sum(const typename Base::LabelC& labelC) const {
      return this->combine(labelC, &Ring::add);
    }
 
    void print(const std::string& s = "",
               const typename Base::LabelFormatter& labelFormatter =
                   &DefaultFormatter) const {
      auto valueFormatter = [](const double& v) {
        std::stringstream ss;
        ss << std::setw(4) << std::setprecision(8) << v;
        return ss.str();
      };
      Base::print(s, labelFormatter, valueFormatter);
    }
 
    bool equals(const AlgebraicDecisionTree& other, double tol = 1e-9) const {
      // lambda for comparison of two doubles upto some tolerance.
      auto compare = [tol](double a, double b) {
        return std::abs(a - b) < tol;
      };
      return Base::equals(other, compare);
    }
  };
 
template <typename T>
struct traits<AlgebraicDecisionTree<T>>
    : public Testable<AlgebraicDecisionTree<T>> {};
}  // namespace gtsam