comlexity-cost, off-by-one bug fix, question length, refactor

Author: kjgm

README.md

@@ -86,6 +86,7 @@ Run the program without any parameters to see a full list of the available param
 ## Parameters
 ConTree can be configured by the following parameters:
 * `max_depth` : The maximum depth of the tree. Note that a tree of depth zero has a single leaf node. A tree of depth one has one branching node and two leaf nodes.
+* `complexity_cost` : The cost of adding of adding a branching node (between 0 and 1).
 * `max_gap` : The maximum permissible gap to the optimal solution.
 * `max_gap_decay` : Use this parameter, if you want to find solutions iteratively, with each iteration decreasing the `max_gap` by multiplying it with `max_gap_decay`.
 * `time_limit` : The run time limit in seconds. If the time limit is exceeded a possibly non-optimal tree is returned.
@@ -107,3 +108,4 @@ Other related work:
 * Lin, Jimmy, et al. "Generalized and scalable optimal sparse decision trees." In _International Conference on Machine Learning_ (2020). [pdf](https://proceedings.mlr.press/v119/lin20g/lin20g.pdf) / [source](https://github.com/Jimmy-Lin/GeneralizedOptimalSparseDecisionTrees)
 * Aglin, Gaël, Siegfried Nijssen, and Pierre Schaus. "Learning optimal decision trees using caching branch-and-bound search." In _Proceedings of the AAAI conference on artificial intelligence_ (2020). [pdf](https://ojs.aaai.org/index.php/AAAI/article/download/5711/5567) / [source](https://github.com/aia-uclouvain/pydl8.5)
 * Mazumder, Rahul, Xiang Meng, and Haoyue Wang. "Quant-BnB: A scalable branch-and-bound method for optimal decision trees with continuous features." In _International Conference on Machine Learning_ (2022). [pdf](https://proceedings.mlr.press/v162/mazumder22a/mazumder22a.pdf) / [source](https://github.com/mengxianglgal/Quant-BnB)
+* Kiossou, Harold, Pierre Schaus, and Siegfried Nijssen. "Anytime Optimal Decision Tree Learning with Continuous Features." _arXiv preprint arXiv:2601.14765_ (2026). [pdf](https://arxiv.org/pdf/2601.14765) / [source](https://anonymous.4open.science/r/contree-rs-C7B8)

code/DataStructures/include/intervals_pruner.h

@@ -5,6 +5,7 @@
 #include <unordered_map>
 #include <utility>
 #include <vector>
+#include <cmath>
 
 class IntervalsPruner {
 public:
@@ -16,14 +17,18 @@ class IntervalsPruner {
      * 
      * @param possible_split_indexes_ref Reference to a vector containing possible split indices.
      * @param max_gap The maximum allowable gap for the solution to be considered valid (off by at most max_gap).
+     * @param complexity_cost The cost of adding a branching node
      */
-    IntervalsPruner(const std::vector<int>& possible_split_indexes_ref, int max_gap);
+    IntervalsPruner(const std::vector<int>& possible_split_indexes_ref, int max_gap, float complexity_cost);
 
+    /**
+    * We store the intervals using four values
+    */
     struct Bound {
-        int left_bound;                
-        int right_bound;               
-        int last_split_left_index;     
-        int last_split_right_index;    
+        int left_bound;             // the left split-index bound (inclusive) of the interval
+        int right_bound;            // the right split-index bound (inclusive) of the interval
+        int last_split_left_index;  // the last split index tested to the left of the left_bound (-1 if not set)
+        int last_split_right_index; // the last split index tested to the right of the right_bound (-1 if not set)
     };
 
     /**
@@ -39,7 +44,7 @@ class IntervalsPruner {
      * @param split_index The index at which the split is evaluated.
      * @return A pair of integers representing the new pruned interval bounds.
      */
-    std::pair<int, int> neighbourhood_pruning(int score_difference, int left, int right, int split_index);
+    std::pair<int, int> neighbourhood_pruning(float score_difference, int left, int right, int split_index);
 
     /**
      * Applies subinterval pruning to determine if a given interval can be entirely pruned.
@@ -51,7 +56,7 @@ class IntervalsPruner {
      * @param current_best_score The best score obtained so far, used as a reference for pruning.
      * @return True if the subinterval can be pruned, otherwise false.
      */
-    bool subinterval_pruning(const Bound& current_bounds, int current_best_score);
+    bool subinterval_pruning(const Bound& current_bounds, float current_best_score);
 
     /**
      * Performs interval shrinking by narrowing the bounds of the interval based on the current best score.
@@ -63,7 +68,7 @@ class IntervalsPruner {
      * @param current_bounds The current bounds of the interval to be updated by shrinking
      * @param current_best_score The best score to compare against during the shrinking process.
      */
-    void interval_shrinking(Bound& current_bounds, int current_best_score);
+    void interval_shrinking(Bound& current_bounds, float current_best_score);
 
     /**
      * Records the result of a split, storing the index and associated scores.
@@ -75,15 +80,16 @@ class IntervalsPruner {
      * @param left_score The score associated with the left subinterval.
      * @param right_score The score associated with the right subinterval.
      */
-    void add_result(int index, int left_score, int right_score);
+    void add_result(int index, float left_score, float right_score);
 
 private:
     const std::vector<int>& possible_split_indexes; 
     int possible_split_size;                    
     int rightmost_zero_index;                      
     int leftmost_zero_index;                       
-    int max_gap;                                   
-    std::unordered_map<int, std::pair<int, int>> evaluated_indices_record; 
+    int max_gap;
+    float complexity_cost;
+    std::unordered_map<int, std::pair<float, float>> evaluated_indices_record; 
 };
 
 #endif // INTERVALS_PRUNER_H

code/DataStructures/include/tree.h

@@ -9,14 +9,14 @@
 
 struct Tree {
     Tree();
-    Tree(int label, int misclassifications);
-    Tree(int split_feature, float split_threshold, const std::shared_ptr<Tree>& left, const std::shared_ptr<Tree>& right);
+    Tree(int label, float objective);
+    Tree(int split_feature, float split_threshold, const std::shared_ptr<Tree>& left, const std::shared_ptr<Tree>& right, float complexity_cost);
 
     std::shared_ptr<Tree> left{ nullptr }, right{ nullptr };
     int split_feature = -1, label = -1;
     float split_threshold = 0.0;
 
-    int misclassification_score = INT_MAX;
+    float objective = INT_MAX;
 
     bool is_leaf() const;
     bool is_internal() const;
@@ -33,7 +33,7 @@ struct Tree {
     inline std::shared_ptr<Tree> get_right_tree() const { return right; }
 
     void make_leaf(int label, int misclassifications);
-    void update_split(int split_feature, float split_threshold, const std::shared_ptr<Tree>& left, const std::shared_ptr<Tree>& right);
+    void update_split(int split_feature, float split_threshold, const std::shared_ptr<Tree>& left, const std::shared_ptr<Tree>& right, float complexity_cost);
 
     std::string to_string(int indent = 0) const;
 };

code/DataStructures/src/dataview.cpp

@@ -32,6 +32,10 @@ Dataview::Dataview(Dataset* sorted_dataset, Dataset* unsorted_dataset, int class
         for (int i = 0; i < first_feature.size() - 1; i++) {
             right_label_frequency[first_feature[i].label]--;
             left_label_frequency[first_feature[i].label]++;
+            
+            // we cannot compute a gini value if there is no split here
+            if (first_feature[i].unique_value_index == first_feature[i + 1].unique_value_index) continue;
+
 
             float left_gini = 1.0f; float right_gini = 1.0f;
             int left_count = i + 1; int right_count = int(first_feature.size()) - left_count;
@@ -78,10 +82,13 @@ Dataview::Dataview(Dataset* sorted_dataset, Dataset* unsorted_dataset, int class
                 right_label_frequency[current_feature[feature_element_idx].label]--;
                 left_label_frequency[current_feature[feature_element_idx].label]++;
 
+                // we cannot compute a gini value if there is no split here
+                if (feature_element_idx < current_feature.size() - 1
+                    && current_feature[feature_element_idx].unique_value_index == current_feature[feature_element_idx + 1].unique_value_index) continue;
+
                 float left_gini = 1.0f; float right_gini = 1.0f;
                 int left_count = feature_element_idx + 1; int right_count = int(current_feature.size()) - left_count;
 
-
                 for (int label = 0; label < class_number; label++) {
                     if (left_count > 0) {
                         float left_probability = static_cast<float>(left_label_frequency[label]) / static_cast<float>(left_count);
@@ -142,7 +149,8 @@ const std::vector<int>& Dataview::get_possible_split_indices(int feature_index)
     return possible_split_indices[feature_index];
 }
 
-void Dataview::split_data_points(const Dataview& current_dataview, int feature_index, int split_point, int split_unique_value_index, Dataview& left_dataview, Dataview& right_dataview, int current_max_depth) {
+void Dataview::split_data_points(const Dataview& current_dataview, int feature_index, int split_point, int split_unique_value_index,
+    Dataview& left_dataview, Dataview& right_dataview, int current_max_depth) {
     left_dataview.feature_data.resize(current_dataview.get_feature_number());
     right_dataview.feature_data.resize(current_dataview.get_feature_number());