pybdt C++ API Reference

class BDTLearner : public Learner

#include <bdtlearner.hpp>

Public Functions

explicit BDTLearner(const std::vector<std::string> &feature_names, const std::string &weight_name = "")

BDTLearner(const std::vector<std::string> &feature_names, const std::string &sig_weight_name, const std::string &bg_weight_name)

explicit BDTLearner(const boost::python::list &feature_names, const std::string &weight_name = "")

BDTLearner(const boost::python::list &feature_names, const std::string &sig_weight_name, const std::string &bg_weight_name)

virtual ~BDTLearner()

double beta() const

double frac_random_events() const

int num_trees() const

bool use_purity() const

bool quiet() const

boost::python::list after_pruners() const

boost::python::list before_pruners() const

void beta(double beta)

void frac_random_events(double n)

void num_trees(int n)

void use_purity(bool purity)

void quiet(bool val)

void add_after_pruner(boost::shared_ptr<Pruner> pruner)

void add_before_pruner(boost::shared_ptr<Pruner> pruner)

void clear_after_pruners()

void clear_before_pruners()

void set_defaults()

boost::shared_ptr<DTLearner> dtlearner()

virtual boost::shared_ptr<Model> train_given_everything(const std::vector<Event> &sig, const std::vector<Event> &bg, const std::vector<double> &init_sig_weights, const std::vector<double> &init_bg_weights) const

Protected Attributes

boost::shared_ptr<DTLearner> m_dtlearner

double m_beta

double m_frac_random_events

int m_num_trees

bool m_use_purity

bool m_quiet

std::vector<boost::shared_ptr<Pruner>> m_before_pruners

std::vector<boost::shared_ptr<Pruner>> m_after_pruners

Friends

friend class BDTLearner_pickle_suite

class BDTModel : public Model

#include <bdtmodel.hpp>

Public Functions

BDTModel(const std::vector<std::string> &feature_names, const std::vector<boost::shared_ptr<DTModel>> &dtmodels, const std::vector<double> &alphas)

virtual ~BDTModel()

BDTModel(const boost::python::list &feature_names, const boost::python::list &dtmodels, const boost::python::list &alphas)

double get_alpha(int n) const

boost::shared_ptr<DTModel> get_dtmodel(int n) const

int n_dtmodels() const

std::vector<double> event_variable_importance(const Scoreable &s, bool sep_weighted, bool tree_weighted) const

boost::python::dict event_variable_importance_py(const boost::python::list &vals, bool sep_weighted, bool tree_weighted) const

std::vector<double> variable_importance(bool sep_weighted, bool tree_weighted) const

boost::python::dict variable_importance_py(bool sep_weighted, bool tree_weighted) const

boost::shared_ptr<BDTModel> get_subset_bdtmodel(int n_i, int n_f) const

boost::shared_ptr<BDTModel> get_subset_bdtmodel_list(boost::python::list dtmodel_indices) const

boost::shared_ptr<BDTModel> get_trimmed_bdtmodel(double threshold) const

Protected Functions

virtual double base_score(const Scoreable &e, bool use_purity) const

Private Members

std::vector<boost::shared_ptr<DTModel>> m_dtmodels

std::vector<double> m_alphas

int m_n_dtmodels

double m_max_response

Friends

friend struct BDTModel_pickle_suite

struct BDTModel_pickle_suite : public pickle_suite

#include <bdtmodel.hpp>

Public Static Functions

static boost::python::tuple getinitargs(const BDTModel &m)

class CostComplexityPruner : public Pruner

#include <pruner.hpp>

Public Functions

explicit CostComplexityPruner(double strength)

virtual ~CostComplexityPruner()

virtual void prune(boost::shared_ptr<DTModel> tree)

double strength() const

void strength(double s)

Public Static Functions

static double gain(const boost::shared_ptr<DTNode> node)

static double rho(const boost::shared_ptr<DTNode> node)

Private Members

double m_strength

class DataSet

#include <dataset.hpp>

Public Functions

explicit DataSet(const boost::python::dict &data, const std::string subset = "all")

DataSet(const DataSet &other, const std::vector<std::string> &names)

inline const Event &event(int index) const

inline const std::vector<Event> &events() const

std::vector<double> get_column(const std::string &name) const

int get_column_index(const std::string &name) const

std::vector<int> get_column_indices(const std::vector<std::string> &feature_names) const

PyObject *getitem(const std::string &name) const

inline double livetime() const

std::vector<std::string> names() const

boost::python::list names_py() const

inline int n_features() const

inline int n_events() const

boost::python::dict to_dict() const

inline void livetime(const double t)

Protected Attributes

std::vector<std::string> m_names

std::vector<Event> m_events

int m_n_features

int m_n_events

double m_livetime

std::vector<std::vector<double>> m_cols

Friends

friend class Event

class DTLearner : public Learner

#include <dtlearner.hpp>

Public Functions

explicit DTLearner(const std::vector<std::string> &feature_names, const std::string &weight_name = "")

DTLearner(const std::vector<std::string> &feature_names, const std::string &sig_weight_name, const std::string &bg_weight_name)

virtual ~DTLearner()

explicit DTLearner(const boost::python::list &feature_names, const std::string &weight_name = "")

DTLearner(const boost::python::list &feature_names, const std::string &sig_weight_name, const std::string &bg_weight_name)

bool linear_cuts() const

int max_depth() const

int min_split() const

int num_cuts() const

int num_random_variables() const

std::string separation_type() const

void max_depth(int n)

void min_split(int n)

void num_cuts(int n)

void linear_cuts(bool value)

void num_random_variables(int n)

void separation_type(std::string st)

void set_defaults()

virtual boost::shared_ptr<Model> train_given_everything(const std::vector<Event> &sig, const std::vector<Event> &bg, const std::vector<double> &sig_weights, const std::vector<double> &bg_weights) const

Protected Functions

boost::shared_ptr<DTNode> build_tree(const std::vector<Event> &sig, const std::vector<Event> &bg, const std::vector<double> &sig_weights, const std::vector<double> &bg_weights, const int depth = 0) const

Protected Attributes

boost::shared_ptr<SepFunc> m_sep_func

int m_min_split

int m_max_depth

int m_num_cuts

bool m_linear_cuts

int m_num_random_variables

mutable RandomSampler m_random_sampler

Protected Static Functions

static boost::tuple<double, double> m_sum_passing_weight(const double cut_val, const std::vector<double> &feature_col, const std::vector<double> &weights, const std::vector<int> &idx)

Friends

friend class BDTLearner

friend class BDTLearner_pickle_suite

class DTModel : public Model

#include <dtmodel.hpp>

Public Functions

DTModel(const std::vector<std::string> &feature_names, boost::shared_ptr<DTNode> root)

virtual ~DTModel()

DTModel(const boost::python::list &feature_names, boost::shared_ptr<DTNode> root)

std::vector<double> event_variable_importance(const Scoreable &s, bool sep_weighted) const

boost::python::dict event_variable_importance_py(const boost::python::list &vals, bool sep_weighted) const

std::vector<double> variable_importance(bool sep_weighted) const

boost::python::dict variable_importance_py(bool sep_weighted) const

inline boost::shared_ptr<DTNode> root()

Protected Functions

virtual double base_score(const Scoreable &e, bool use_purity) const

Protected Attributes

boost::shared_ptr<DTNode> m_root

Friends

friend struct DTModel_pickle_suite

struct DTModel_pickle_suite : public pickle_suite

#include <dtmodel.hpp>

Public Static Functions

static boost::python::tuple getinitargs(const DTModel &m)

class DTNode : public boost::enable_shared_from_this<DTNode>

#include <dtmodel.hpp>

Public Functions

DTNode(double sep_index, double w_sig, double w_bg, int n_sig, int n_bg)

DTNode(double sep_gain, double sep_index, int feature_id, double feature_val, double w_sig, double w_bg, int n_sig, int n_bg, boost::shared_ptr<DTNode> left, boost::shared_ptr<DTNode> right)

virtual ~DTNode()

void set_dtmodel(boost::shared_ptr<DTModel> model)

void set_dtmodel(DTModel *model)

inline int feature_id() const

std::string feature_name() const

inline double feature_val() const

inline bool is_leaf() const

int max_depth() const

inline double n_bg() const

int n_leaves() const

int n_total() const

inline double n_sig() const

inline double purity() const

inline double sep_index() const

inline double sep_gain() const

int tree_size() const

inline double w_bg() const

inline double w_sig() const

double w_total() const

inline boost::shared_ptr<DTNode> left() const

inline boost::shared_ptr<DTNode> right() const

void prune()

const DTNode &trace(const Scoreable &e)

std::vector<boost::shared_ptr<DTNode>> trace_full(const Scoreable &e)

boost::shared_ptr<DTNode> get_copy() const

Protected Functions

void calc_aux()

Protected Attributes

double m_sep_gain

double m_sep_index

int m_feature_id

double m_feature_val

double m_w_sig

double m_w_bg

int m_n_sig

int m_n_bg

double m_purity

boost::shared_ptr<DTNode> m_left

boost::shared_ptr<DTNode> m_right

DTModel *m_dtmodel

Friends

friend struct DTNode_pickle_suite

struct DTNode_pickle_suite : public pickle_suite

#include <dtmodel.hpp>

Public Static Functions

static boost::python::tuple getinitargs(const DTNode &n)

class ErrorPruner : public Pruner

#include <pruner.hpp>

Public Functions

explicit ErrorPruner(double factor)

virtual ~ErrorPruner()

virtual void prune(boost::shared_ptr<DTModel> tree)

double node_error(const boost::shared_ptr<DTNode> node)

double subtree_error(const boost::shared_ptr<DTNode> node)

double strength() const

void strength(double s)

Private Functions

std::vector<boost::shared_ptr<DTNode>> get_prune_sequence(boost::shared_ptr<DTNode> node)

Private Members

double m_strength

class Event

#include <dataset.hpp>

Public Functions

Event(const DataSet *dataset, const int row)

Event &operator=(const Event &e)

inline double operator[](const size_type index) const

inline bool all_finite() const

inline int get_column_index(const std::string &name) const

inline size_type size() const

inline double value(const size_type index) const

inline std::vector<double> values() const

Private Types

typedef std::vector<double>::size_type size_type

Private Members

const DataSet *m_dataset

int m_row

class Histogram

#include <histogram.hpp>

Subclassed by LinearHistogram, NonlinearHistogram

Public Functions

virtual ~Histogram()

virtual double count(int i) const = 0

virtual std::vector<double>::const_iterator begin() const = 0

virtual std::vector<double>::const_iterator end() const = 0

virtual double min_val() const = 0

virtual double max_val() const = 0

virtual int n_bins() const = 0

void fill(const std::vector<double> &values)

virtual void fill(const std::vector<double> &values, const std::vector<double> &weights) = 0

virtual int index_for_value(double value) const = 0

virtual double value_for_index(int i) const = 0

class Learner

#include <learner.hpp>

Subclassed by BDTLearner, DTLearner, VineLearner

Public Functions

explicit Learner(const std::vector<std::string> &feature_names, const std::string &weight_name = "")

Learner(const std::vector<std::string> &feature_names, const std::string &sig_weight_name, const std::string &bg_weight_name)

virtual ~Learner()

explicit Learner(const boost::python::list &feature_names, const std::string &weight_name = "")

Learner(const boost::python::list &feature_names, const std::string &sig_weight_name, const std::string &bg_weight_name)

std::vector<std::string> feature_names() const

std::string sig_weight_name() const

std::string bg_weight_name() const

boost::shared_ptr<Model> train(const DataSet &sig, const DataSet &bg) const

boost::shared_ptr<Model> train_given_weights(const DataSet &sig, const DataSet &bg, const std::vector<double> &sig_weights, const std::vector<double> &bg_weights) const

virtual boost::shared_ptr<Model> train_given_everything(const std::vector<Event> &sig, const std::vector<Event> &bg, const std::vector<double> &init_sig_weights, const std::vector<double> &init_bg_weights) const = 0

Protected Attributes

std::vector<std::string> m_feature_names

std::string m_sig_weight_name

std::string m_bg_weight_name

Private Functions

void init()

class LinearHistogram : public Histogram

#include <linear_histogram.hpp>

Public Functions

LinearHistogram(double min_val, double max_val, int n_bins)

~LinearHistogram()

virtual double count(int i) const

virtual std::vector<double>::const_iterator begin() const

virtual std::vector<double>::const_iterator end() const

virtual double min_val() const

virtual double max_val() const

virtual int n_bins() const

void fill(double value, double weight = 1.0)

void fill(const std::vector<double> &values)

virtual void fill(const std::vector<double> &values, const std::vector<double> &weights)

virtual int index_for_value(double value) const

virtual double value_for_index(int i) const

Private Members

double m_min_val

double m_max_val

int m_n_bins

double m_bin_width

double m_underflow

double m_overflow

std::vector<double> m_bin_values

class Model

#include <model.hpp>

Subclassed by BDTModel, DTModel, VineModel

Public Functions

Model(std::vector<std::string> feature_names)

Model(boost::python::list feature_names)

virtual ~Model()

std::vector<std::string> feature_names() const

boost::python::list feature_names_py() const

double score(const Scoreable &s, bool use_purity = false)

std::vector<double> score(const DataSet &ds, bool use_purity = false, bool quiet = false)

std::vector<double> score(const std::vector<Event> &events, bool use_purity = false, bool quiet = false)

double score_one(const boost::python::list &vals, bool use_purity)

PyObject *score_DataSet(const DataSet &ds, bool use_purity, bool quiet)

Public Static Functions

static double get_epsilon()

static void set_epsilon(double epsilon)

Protected Functions

virtual double base_score(const Scoreable &s, bool use_purity) const = 0

Protected Attributes

std::vector<std::string> m_feature_names

int m_n_features

Protected Static Attributes

static double m_EPS = numeric_limits<double>::epsilon()

Friends

friend struct DTModel_pickle_suite

friend struct BDTModel_pickle_suite

class NonlinearHistogram : public Histogram

#include <nonlinear_histogram.hpp>

Public Functions

explicit NonlinearHistogram(const std::vector<double> &bin_edges)

NonlinearHistogram(const int n, const std::vector<double> values, bool presorted = false)

NonlinearHistogram(const int n, const std::vector<double> values, const std::vector<double> weights, bool presorted = false)

~NonlinearHistogram()

virtual double count(int i) const

virtual std::vector<double>::const_iterator begin() const

virtual std::vector<double>::const_iterator end() const

virtual double min_val() const

virtual double max_val() const

virtual int n_bins() const

virtual void fill(const std::vector<double> &values, const std::vector<double> &weights)

void fill_presorted(const std::vector<double> &sorted_values, const std::vector<double> &sorted_weights)

virtual int index_for_value(double value) const

virtual double value_for_index(int i) const

void write(std::ostream &os) const

Public Static Functions

static std::vector<std::pair<double, double>> get_sorted_values_weights(const std::vector<double> values, const std::vector<double> weights)

static std::pair<std::vector<double>, std::vector<double>> get_pair_sorted_values_weights(const std::vector<double> values, const std::vector<double> weights)

static std::vector<double> get_ntile_boundaries(const int n, const std::vector<double> values, const std::vector<double> weights)

Private Types

typedef std::vector<double> dlist

typedef dlist::iterator dlist_iter

typedef dlist::const_iterator dlist_citer

typedef std::vector<std::pair<double, double>> pairlist

typedef pairlist::const_iterator pairlist_citer

Private Members

std::vector<double> m_bin_edges

double m_underflow

double m_overflow

std::vector<double> m_bin_values

Private Static Functions

static std::vector<double> get_ntile_boundaries_presorted(const int n, const std::vector<double> sorted_values, const std::vector<double> sorted_weights)

template<typename T>
class Notifier

#include <notifier.hpp>

Public Functions

inline Notifier(const std::string &msg, T max, std::ostream &stream = std::cerr, bool overwrite = true)

inline void update(const T &amount)

inline void finish()

Protected Attributes

char m_first

std::string m_msg

T m_max

std::ostream &m_stream

int m_amount_width

std::string m_last

class Pruner

#include <pruner.hpp>

Subclassed by CostComplexityPruner, ErrorPruner, SameLeafPruner

Public Functions

virtual ~Pruner()

virtual void prune(boost::shared_ptr<DTModel> tree) = 0

class RandomSampler

#include <random_sampler.hpp>

Public Functions

RandomSampler(int seed = 0)

template<typename T>
inline std::vector<T> sample(const unsigned n, const std::vector<T> &vec, const bool replace = false)

template<typename T, typename T2>
inline std::vector<T> sample_range(const unsigned n, const T2 &i1, const T2 &i2 = 0, const bool replace = false)

Private Members

gsl_rng *m_rng

template<typename EventType>
class RealScoreable : public Scoreable

#include <model.hpp>

Public Functions

inline RealScoreable(const EventType &event)

inline virtual ~RealScoreable()

inline virtual double operator[](size_type i) const

inline virtual size_type size() const

Private Members

const EventType &m_event

class SameLeafPruner : public Pruner

#include <pruner.hpp>

Public Functions

SameLeafPruner()

virtual ~SameLeafPruner()

virtual void prune(boost::shared_ptr<DTModel> tree)

Private Functions

void prune_node(boost::shared_ptr<DTNode> node)

class Scoreable

#include <model.hpp>

Subclassed by RealScoreable< EventType >

Public Functions

virtual ~Scoreable()

inline bool all_finite() const

virtual double operator[](size_type i) const = 0

virtual size_type size() const = 0

Protected Types

typedef std::vector<double>::size_type size_type

struct SepCrossEntropy : public SepFunc

#include <dtlearner.hpp>

Public Functions

inline virtual double operator()(double p) const

inline virtual std::string separation_type() const

struct SepFunc

#include <dtlearner.hpp>

Subclassed by SepCrossEntropy, SepGini, SepMisclassError

Public Functions

virtual double operator()(double p) const = 0

virtual std::string separation_type() const = 0

inline virtual ~SepFunc()

struct SepGini : public SepFunc

#include <dtlearner.hpp>

Public Functions

inline virtual double operator()(double p) const

inline virtual std::string separation_type() const

struct SepMisclassError : public SepFunc

#include <dtlearner.hpp>

Public Functions

inline virtual double operator()(double p) const

inline virtual std::string separation_type() const

class VineLearner : public Learner

#include <vinelearner.hpp>

Public Functions

VineLearner(const std::string &vine_feature, const double vine_feature_min, const double vine_feature_max, const double vine_feature_width, const double vine_feature_step, boost::shared_ptr<Learner> learner)

virtual ~VineLearner()

bool quiet() const

std::string vine_feature() const

double vine_feature_min() const

double vine_feature_max() const

double vine_feature_width() const

double vine_feature_step() const

void quiet(bool val)

void vine_feature(const std::string &vine_feature)

void vine_feature_min(const double vine_feature_min)

void vine_feature_max(const double vine_feature_max)

void vine_feature_width(const double vine_feature_width)

void vine_feature_step(const double vine_feature_step)

boost::shared_ptr<Learner> learner()

virtual boost::shared_ptr<Model> train_given_everything(const std::vector<Event> &sig, const std::vector<Event> &bg, const std::vector<double> &init_sig_weights, const std::vector<double> &init_bg_weights) const

Protected Attributes

std::string m_vine_feature

double m_vine_feature_min

double m_vine_feature_max

double m_vine_feature_width

double m_vine_feature_step

size_t m_vine_feature_i

bool m_quiet

boost::shared_ptr<Learner> m_learner

Friends

friend class VineLearner_pickle_suite

class VineModel : public Model

#include <vinemodel.hpp>

Public Functions

VineModel(const std::vector<std::string> &feature_names, const std::string &vine_feature, const std::vector<double> bin_mins, const std::vector<double> bin_maxs, const std::vector<boost::shared_ptr<Model>> models)

virtual ~VineModel()

VineModel(const boost::python::list &feature_names, const std::string &vine_feature, const boost::python::list &bin_mins, const boost::python::list &bin_maxs, const boost::python::list &models)

std::vector<double> variable_importance(bool sep_weighted) const

boost::python::dict variable_importance_py(bool sep_weighted) const

Protected Functions

virtual double base_score(const Scoreable &e, bool use_purity) const

Protected Attributes

std::string m_vine_feature

size_t m_vine_feature_i

std::vector<double> m_bin_mins

std::vector<double> m_bin_maxs

std::vector<boost::shared_ptr<Model>> m_models

Friends

friend struct VineModel_pickle_suite

struct VineModel_pickle_suite : public pickle_suite

#include <vinemodel.hpp>

Public Static Functions

static boost::python::tuple getinitargs(const VineModel &m)

namespace np

Functions

template<typename T>
vector<T> array_to_vector(PyObject *a)

template<typename T>
std::vector<T> list_to_vector(const boost::python::list &l)

template<typename T>
boost::python::list vector_to_list(const vector<T> &v)

template<typename T>
PyObject *vector_to_array(const vector<T> &v)

template<typename T, typename T2>
vector<T> range(T2 lower, T2 upper = 0)

template<typename T>
vector<T> ones(int n)

template<typename T>
vector<T> zeros(int n)

template<typename T>
T sum(const vector<T> &v)

template<typename T>
T max(const vector<T> &v)

template<typename T>
T max(const vector<T> &v, const vector<int> &idx)

template<typename T>
T min(const vector<T> &v)

template<typename T>
T min(const vector<T> &v, const vector<int> &idx)

template<typename T>
int index(const vector<T> &v, const T &t)

template<typename T, typename T2>
vector<bool> lt(const vector<T> &v, const T2 &t)

template<typename T, typename T2>
vector<bool> gt(const vector<T> &v, const T2 &t)

template<typename T, typename T2>
vector<bool> lte(const vector<T> &v, const T2 &t)

template<typename T, typename T2>
vector<bool> gte(const vector<T> &v, const T2 &t)

template<typename T1, typename T2>
bool dims_match(const vector<T1> &a, const vector<T2> &b)

template<typename func, typename T>
vector<typename func::result_type> operate(const vector<T> &a, const vector<T> &b)

template<typename func, typename T, typename T2>
vector<typename func::result_type> operate(const vector<T> &a, const T2 &b)

template<typename T, typename T2>
vector<T> add(const vector<T> &a, const T2 &b)

template<typename T, typename T2>
vector<T> sub(const vector<T> &a, const T2 &b)

template<typename T, typename T2>
vector<T> mul(const vector<T> &a, const T2 &b)

template<typename T, typename T2>
vector<T> div(const vector<T> &a, const T2 &b)

template<typename T, typename T2>
vector<bool> eq(const vector<T> &a, const T2 &b)

template<typename T>
T prod(const vector<T> &v)

template<typename T>
vector<T> exp(const vector<T> &v)

template<typename T>
vector<bool> isfinite(const vector<T> &v)

template<typename Tout, typename T>
vector<Tout> conv(const vector<T> &v)

template<typename T1, typename T2>
vector<T1> subscript(const vector<T1> v, const vector<T2> indices)

template<typename T>
vector<T> subscript(const vector<T> v, const vector<bool> keep)

template<typename T>
std::string stringify(const vector<T> v)

namespace std

STL namespace.

file bdtlearner.cpp

#include <Python.h>

#include “bdtlearner.hpp”

#include “np.hpp”

#include “notifier.hpp”

#include <iostream>

#include <limits>

#include <boost/make_shared.hpp>

#include <boost/pointer_cast.hpp>

Functions

void export_bdtlearner()

file bdtlearner.hpp

#include <string>

#include <vector>

#include <boost/shared_ptr.hpp>

#include <boost/tuple/tuple.hpp>

#include “boost_python.hpp”

#include “bdtmodel.hpp”

#include “dataset.hpp”

#include “dtlearner.hpp”

#include “learner.hpp”

#include “pruner.hpp”

Functions

void export_bdtlearner()

file bdtmodel.cpp

#include <Python.h>

#include “bdtmodel.hpp”

#include “np.hpp”

#include <cmath>

#include <boost/make_shared.hpp>

Functions

void export_bdtmodel()

file bdtmodel.hpp

#include <string>

#include <vector>

#include <boost/shared_ptr.hpp>

#include <boost/tuple/tuple.hpp>

#include “boost_python.hpp”

#include “dtmodel.hpp”

#include “model.hpp”

Functions

void export_bdtmodel()

file boost_python.hpp

#include <boost/python.hpp>

file dataset.cpp

#include “dataset.hpp”

#include “np.hpp”

#include <cmath>

#include <boost/make_shared.hpp>

#include <numpy/ndarrayobject.h>

Defines

PY_ARRAY_UNIQUE_SYMBOL

NO_IMPORT_ARRY

Functions

void export_dataset()

file dataset.hpp

#include <cmath>

#include <iostream>

#include <vector>

#include <string>

#include “boost_python.hpp”

Functions

void export_dataset()

file dtlearner.cpp

#include <Python.h>

#include <boost/shared_ptr.hpp>

#include <boost/make_shared.hpp>

#include “dtlearner.hpp”

#include “linear_histogram.hpp”

#include “nonlinear_histogram.hpp”

#include “np.hpp”

#include <limits>

#include <map>

Functions

void export_dtlearner()

file dtlearner.hpp

#include <string>

#include <vector>

#include <boost/make_shared.hpp>

#include <boost/shared_ptr.hpp>

#include <boost/tuple/tuple.hpp>

#include “boost_python.hpp”

#include “dataset.hpp”

#include “dtmodel.hpp”

#include “learner.hpp”

#include “random_sampler.hpp”

Functions

void export_dtlearner()

file dtmodel.cpp

#include <Python.h>

#include “dtmodel.hpp”

#include “np.hpp”

#include <algorithm>

#include <iostream>

#include <limits>

#include <numeric>

#include <queue>

#include <boost/make_shared.hpp>

#include <boost/math/special_functions/fpclassify.hpp>

Functions

void export_dtmodel()

file dtmodel.hpp

#include <string>

#include <vector>

#include “boost_python.hpp”

#include <boost/enable_shared_from_this.hpp>

#include <boost/shared_ptr.hpp>

#include “model.hpp”

Functions

void export_dtmodel()

file histogram.cpp

#include “linear_histogram.hpp”

#include <vector>

#include “np.hpp”

file histogram.hpp

#include <cmath>

#include <vector>

file learner.cpp

#include <Python.h>

#include “learner.hpp”

#include “np.hpp”

#include <algorithm>

Functions

void export_learner()

file learner.hpp

#include <vector>

#include <string>

#include “boost_python.hpp”

#include “dataset.hpp”

#include “model.hpp”

Functions

void export_learner()

file linear_histogram.cpp

#include “linear_histogram.hpp”

#include “np.hpp”

file linear_histogram.hpp

#include <cmath>

#include <vector>

#include “histogram.hpp”

file model.cpp

#include <Python.h>

#include “model.hpp”

#include <cmath>

#include <limits>

#include <boost/shared_ptr.hpp>

#include <boost/make_shared.hpp>

#include “np.hpp”

#include “notifier.hpp”

Functions

void export_model()

file model.hpp

#include <cstdlib>

#include <string>

#include <vector>

#include <boost/shared_ptr.hpp>

#include “boost_python.hpp”

#include “dataset.hpp”

Functions

void export_model()

template<typename EventType>
RealScoreable<EventType> make_scoreable(const EventType &event)

file nonlinear_histogram.cpp

#include “nonlinear_histogram.hpp”

#include <iostream>

#include “np.hpp”

Functions

template<typename T>
vector<T> sorted(const vector<T> &v)

file nonlinear_histogram.hpp

#include <algorithm>

#include <cassert>

#include <cmath>

#include <ostream>

#include <vector>

#include <utility>

#include “histogram.hpp”

file notifier.hpp

#include <iomanip>

#include <iostream>

#include <sstream>

file np.hpp

#include <cstdlib>

#include <algorithm>

#include <fstream>

#include <iomanip>

#include <iostream>

#include <numeric>

#include <queue>

#include <sstream>

#include <string>

#include <vector>

#include “boost_python.hpp”

#include <numpy/ndarrayobject.h>

Defines

NPY_NO_DEPRECATED_API

PY_ARRAY_UNIQUE_SYMBOL

NO_IMPORT_ARRAY

file pruner.cpp

#include <Python.h>

#include “pruner.hpp”

#include <map>

#include <numeric>

#include <queue>

Functions

void export_pruners()

file pruner.hpp

#include <boost/shared_ptr.hpp>

#include “dtmodel.hpp”

Functions

void export_pruners()

file pybdt.cpp

#include <cstdlib>

#include <algorithm>

#include <fstream>

#include <iomanip>

#include <iostream>

#include <numeric>

#include <queue>

#include <sstream>

#include <string>

#include <vector>

#include <boost/assign/list_of.hpp>

#include <boost/assign/std/vector.hpp>

#include <boost/shared_ptr.hpp>

#include <boost/make_shared.hpp>

#include <boost/tuple/tuple.hpp>

#include “boost_python.hpp”

#include <numpy/ndarrayobject.h>

#include “np.hpp”

#include “dataset.hpp”

#include “model.hpp”

#include “learner.hpp”

#include “dtmodel.hpp”

#include “dtlearner.hpp”

#include “bdtmodel.hpp”

#include “bdtlearner.hpp”

#include “vinemodel.hpp”

#include “vinelearner.hpp”

Defines

NPY_NO_DEPRECATED_API

PY_ARRAY_UNIQUE_SYMBOL

Functions

static PyObject *hack_import_array()

file random_sampler.cpp

#include “random_sampler.hpp”

file random_sampler.hpp

#include <set>

#include <vector>

#include <gsl/gsl_randist.h>

#include <gsl/gsl_rng.h>

#include “np.hpp”

file vinelearner.cpp

#include <Python.h>

#include <stdexcept>

#include “vinelearner.hpp”

#include “np.hpp”

#include “notifier.hpp”

#include <boost/shared_ptr.hpp>

#include <boost/make_shared.hpp>

#include <boost/pointer_cast.hpp>

#include “vinemodel.hpp”

Functions

void export_vinelearner()

file vinelearner.hpp

#include <string>

#include <vector>

#include <boost/shared_ptr.hpp>

#include <boost/tuple/tuple.hpp>

#include “boost_python.hpp”

#include “dataset.hpp”

#include “learner.hpp”

Functions

void export_vinelearner()

file vinemodel.cpp

#include <Python.h>

#include “vinemodel.hpp”

#include “np.hpp”

#include <iostream>

#include <limits>

#include <boost/math/special_functions/fpclassify.hpp>

Functions

void export_vinemodel()

file vinemodel.hpp

#include <string>

#include <vector>

#include <utility>

#include “boost_python.hpp”

#include <boost/enable_shared_from_this.hpp>

#include <boost/shared_ptr.hpp>

#include “model.hpp”

Functions

void export_vinemodel()

dir icetray

dir private

dir pybdt

dir pybdt