12    using FeatTypes = tuple<ArrayXf,ArrayXi,ArrayXb>;
 
   13    constexpr auto size = std::tuple_size<FeatTypes>::value;
 
   15    return std::make_tuple(feature, threshold);
 
 
   21    vector<float> thresholds;
 
   22    for (
const auto& val : 
unique(x))
 
   23        thresholds.push_back(val);
 
   27    vector<float> thresholds;
 
   28    for (
const auto& val : 
unique(x))
 
   29        thresholds.push_back(val.a);
 
   34    vector<float> thresholds;
 
   36    for (
unsigned i =0; i<s.size()-1; ++i)
 
   39        thresholds.push_back(s.at(i+1));
 
   44    vector<float> thresholds;
 
   46    for (
unsigned i =0; i<s.size()-1; ++i)
 
   49        thresholds.push_back(s.at(i+1).a);
 
   58        [&](
const auto& arg) -> 
ArrayXb { 
 
   59            using T = std::decay_t<
decltype(arg)>;
 
   60            if constexpr (T::NumDimensions == 1)
 
   63                return ArrayXb::Constant(arg.size(), 
true);
 
 
   68float gain(
const ArrayXf& lsplit, 
 
   69            const ArrayXf& rsplit, 
 
   70            bool classification, vector<float> unique_classes)
 
   72        float lscore, rscore, score;
 
   79            score = (lscore*float(lsplit.size()) + 
 
   80                    rscore*float(rsplit.size()))
 
   81                        /(
float(lsplit.size()) + 
float(rsplit.size()));
 
   85            lscore = 
variance(lsplit)/float(lsplit.size());
 
   86            rscore = 
variance(rsplit)/float(rsplit.size());
 
   89            score = lscore + rscore; 
 
 
   96                          const vector<float>& unique_classes)
 
   98    vector<float> class_weights;
 
   99    for (
auto c : unique_classes){
 
  100        class_weights.push_back(
 
  101            float( (classes.cast<
int>() == 
int(c)).count())/classes.size()
 
  105    auto cw = VectorXf::Map(class_weights.data(), class_weights.size());
 
  106    float gini = 1 - cw.dot(cw);
 
 
holds variable type data.
class tree_node_< Node > TreeNode
std::variant< ArrayXb, ArrayXi, ArrayXf, ArrayXXb, ArrayXXi, ArrayXXf, TimeSeriesb, TimeSeriesi, TimeSeriesf, ArrayXbJet, ArrayXiJet, ArrayXfJet, ArrayXXbJet, ArrayXXiJet, ArrayXXfJet, TimeSeriesbJet, TimeSeriesiJet, TimeSeriesfJet > State
defines the possible types of data flowing thru nodes.
vector< float > get_thresholds< ArrayXb >(const ArrayXb &x)
tuple< string, float > get_best_variable_and_threshold(const Dataset &d, TreeNode &tn)
vector< float > get_thresholds< ArrayXfJet >(const ArrayXfJet &x)
ArrayXb threshold_mask< State >(const State &x, const float &threshold)
float gain(const ArrayXf &lsplit, const ArrayXf &rsplit, bool classification, vector< float > unique_classes)
float gini_impurity_index(const ArrayXf &classes, const vector< float > &uc)
vector< float > get_thresholds< ArrayXi >(const ArrayXi &x)
vector< float > get_thresholds< ArrayXf >(const ArrayXf &x)
vector< float > get_thresholds< ArrayXiJet >(const ArrayXiJet &x)
auto get_best_thresholds(const Dataset &d, std::index_sequence< Is... >)
ArrayXb threshold_mask(const T &x, const float &threshold)
Applies a learned threshold to a feature, returning a mask.
vector< float > get_thresholds< ArrayXbJet >(const ArrayXbJet &x)
vector< T > unique(vector< T > w)
returns unique elements in vector
float variance(const ArrayXf &v)
calculate variance
Eigen::Array< bool, Eigen::Dynamic, 1 > ArrayXb
Eigen::Array< fJet, Eigen::Dynamic, 1 > ArrayXfJet
Eigen::Array< int, Eigen::Dynamic, 1 > ArrayXi
Eigen::Array< bJet, Eigen::Dynamic, 1 > ArrayXbJet
Eigen::Array< iJet, Eigen::Dynamic, 1 > ArrayXiJet