ContinuousInnerDecisionNode.h

#ifndef GRAIL_CONTINUOUS_INNER_DECISION_NODE_H
#define GRAIL_CONTINUOUS_INNER_DECISION_NODE_H
 
#include "DecisionNode.h"
#include <vector>
#include <memory>
#include <iostream>
 
 
namespace grail
{
 namespace simulation
 {
 template <class TDecisionType>
 class ContinuousInnerDecisionNode : public DecisionNode<TDecisionType>
 {
 public:
 ContinuousInnerDecisionNode(int column, float splitValue) : 
 columnIndex { column},
 splitValue{ splitValue }
 {
 
 }
 
 void AddChild(std::unique_ptr<DecisionNode<TDecisionType>> childNode)
 {
 children.emplace_back(std::move(childNode));
 }
 
 void Print(std::unordered_map<int, std::string>& columnNames, const std::string& indent) const override
 {
 if (columnNames.find(columnIndex) == columnNames.end())
 columnNames[columnIndex] = "Column[" + std::to_string(columnIndex) + "]";
 
 std::cout << indent << columnNames.at(columnIndex) << " <= " << splitValue << std::endl;
 children[0]->Print(columnNames, indent + " ");
 std::cout << indent << columnNames.at(columnIndex) << " > " << splitValue << std::endl;
 children[1]->Print(columnNames, indent + " ");
 }
 
 const TDecisionType* Predict(std::vector<float>& data) const final
 {
 return (data[columnIndex] <= splitValue) ? children[0]->Predict(data) : children[1]->Predict(data);
 }
 
 DecisionNodeType GetNodeType() const final
 {
 return DecisionNodeType::CONTINUOUS_INNER;
 }
 private:
 std::vector<std::unique_ptr<DecisionNode<TDecisionType>>> children;
 int columnIndex;
 float splitValue;
 
 template <class T> friend struct IDecisionTreeSerializer;
 };
 }
}
 
#endif //GRAIL_CONTINUOUS_INNER_DECISION_NODE_H