x_tree_auxiliary_information.hpp

Go to the documentation of this file.

#ifndef MLPACK_CORE_TREE_RECTANGLE_TREE_X_TREE_AUXILIARY_INFORMATION_HPP
#define MLPACK_CORE_TREE_RECTANGLE_TREE_X_TREE_AUXILIARY_INFORMATION_HPP

namespace mlpack {
namespace tree {

template<typename TreeType>
class XTreeAuxiliaryInformation
{
 public:
  XTreeAuxiliaryInformation() :
    normalNodeMaxNumChildren(0),
    splitHistory(0)
  { };

  XTreeAuxiliaryInformation(const TreeType* node) :
      normalNodeMaxNumChildren(node->Parent() ?
          node->Parent()->AuxiliaryInfo().NormalNodeMaxNumChildren() :
          node->MaxNumChildren()),
      splitHistory(node->Bound().Dim())
  { };

  XTreeAuxiliaryInformation(const XTreeAuxiliaryInformation& other,
                            TreeType* /* tree */ = NULL,
                            bool /* deepCopy */ = true) :
      normalNodeMaxNumChildren(other.NormalNodeMaxNumChildren()),
      splitHistory(other.SplitHistory())
  { };

  XTreeAuxiliaryInformation& operator=(const XTreeAuxiliaryInformation& other)
  {
    normalNodeMaxNumChildren = other.NormalNodeMaxNumChildren();
    splitHistory = other.SplitHistory();

    return *this;
  }

  XTreeAuxiliaryInformation(XTreeAuxiliaryInformation&& other) :
      normalNodeMaxNumChildren(other.NormalNodeMaxNumChildren()),
      splitHistory(std::move(other.splitHistory))
  {
    other.normalNodeMaxNumChildren = 0;
  };

  bool HandlePointInsertion(TreeType* /* node */, const size_t /* point */)
  {
    return false;
  }

  bool HandleNodeInsertion(TreeType* /* node */,
                           TreeType* /* nodeToInsert */,
                           bool /* insertionLevel */)
  {
    return false;
  }

  bool HandlePointDeletion(TreeType* , const size_t)
  {
    return false;
  }

  bool HandleNodeRemoval(TreeType* , const size_t)
  {
    return false;
  }

  bool UpdateAuxiliaryInfo(TreeType* )
  {
    return false;
  }

  void NullifyData()
  { }

  typedef struct SplitHistoryStruct
  {
    int lastDimension;
    std::vector<bool> history;

    SplitHistoryStruct(int dim) : lastDimension(0), history(dim)
    {
      for (int i = 0; i < dim; i++)
        history[i] = false;
    }

    SplitHistoryStruct(const SplitHistoryStruct& other) :
        lastDimension(other.lastDimension),
        history(other.history)
    { }

    SplitHistoryStruct& operator=(const SplitHistoryStruct& other)
    {
      lastDimension = other.lastDimension;
      history = other.history;
      return *this;
    }

    SplitHistoryStruct(SplitHistoryStruct&& other) :
        lastDimension(other.lastDimension),
        history(std::move(other.history))
    {
      other.lastDimension = 0;
    }

    template<typename Archive>
    void Serialize(Archive& ar, const unsigned int /* version */)
    {
      ar & data::CreateNVP(lastDimension, "lastDimension");
      ar & data::CreateNVP(history, "history");
    }
  } SplitHistoryStruct;

 private:
  size_t normalNodeMaxNumChildren;
  SplitHistoryStruct splitHistory;

 public:
  size_t NormalNodeMaxNumChildren() const { return normalNodeMaxNumChildren; }
  size_t& NormalNodeMaxNumChildren() { return normalNodeMaxNumChildren; }
  const SplitHistoryStruct& SplitHistory() const { return splitHistory; }
  SplitHistoryStruct& SplitHistory() { return splitHistory; }

  template<typename Archive>
  void Serialize(Archive& ar, const unsigned int /* version */)
  {
    using data::CreateNVP;

    ar & CreateNVP(normalNodeMaxNumChildren, "normalNodeMaxNumChildren");
    ar & CreateNVP(splitHistory, "splitHistory");
  }

};

} // namespace tree
} // namespace mlpack

#endif  //  MLPACK_CORE_TREE_RECTANGLE_TREE_X_TREE_AUXILIARY_INFORMATION_HPP