mlpack::tree::TreeTraits< TreeType > Class Template Reference

The TreeTraits class provides compile-time information on the characteristics of a given tree type. More...

#include <tree_traits.hpp>

Static Public Attributes
static const bool	HasOverlappingChildren = true
	This is true if the subspaces represented by the children of a node can overlap.
static const bool	HasDuplicatedPoints = false
	This is true if a point can be included in more than one node.
static const bool	FirstPointIsCentroid = false
	This is true if the first point of each node is the centroid of its bound.
static const bool	HasSelfChildren = false
	This is true if the points contained in the first child of a node (Child(0)) are also contained in that node.
static const bool	RearrangesDataset = false
	This is true if the tree rearranges points in the dataset when it is built.
static const bool	BinaryTree = false
	This is true if the tree always has only two children.
static const bool	UniqueNumDescendants = true
	This is true if the NumDescendants() method doesn't include duplicated points.

Detailed Description

template<typename TreeType>
class mlpack::tree::TreeTraits< TreeType >

The TreeTraits class provides compile-time information on the characteristics of a given tree type.

These include traits such as whether or not a node knows the distance to its parent node, or whether or not the subspaces represented by children can overlap.

These traits can be used for static compile-time optimization:

// This if statement will be optimized out at compile time!
if (TreeTraits<TreeType>::HasOverlappingChildren == false)
{
  // Do a simpler computation because no children overlap.
}
else
{
  // Do the full, complex calculation.
}

The traits can also be used in conjunction with SFINAE to write specialized versions of functions:

template<typename TreeType>
void Compute(TreeType& node,
             std::enable_if_t<
                 TreeTraits<TreeType>::RearrangesDataset>*)
{
  // Computation where special dataset-rearranging tree constructor is
  // called.
}

template<typename TreeType>
void Compute(TreeType& node,
             std::enable_if_t<
                 !TreeTraits<TreeType>::RearrangesDataset>*)
{
  // Computation where normal tree constructor is called.
}

In those two examples, the std::enable_if_t<> class takes a boolean template parameter which allows that function to be called when the boolean is true.

Each trait must be a static const value and not a function; only const values can be used as template parameters (or constexprs can be used too). By default (the unspecialized implementation of TreeTraits), each parameter is set to make as few assumptions about the tree as possible; so, even if TreeTraits is not specialized for a particular tree type, tree-based algorithms should still work.

When you write your own tree, you must specialize the TreeTraits class to your tree type and set the corresponding values appropriately. See mlpack/core/tree/binary_space_tree/traits.hpp for an example.

---

The documentation for this class was generated from the following file:

• src/mlpack/core/tree/tree_traits.hpp