Dataset.hh

#ifndef GRAIL_DATASET_H
#define GRAIL_DATASET_H
 
#include "../DT/DTConsiderationType.hh"
#include "../DT/DecisionNode.h"
#include "DatasetSample.hh"
#include <vector>
#include <memory>
#include <iostream>
#include <initializer_list>
#include <functional>
 
namespace grail
{
    namespace simulation
    {
        class ISimulatedGameAction;
 
        class Dataset
        {
        public:
            size_t DecisionVariablesCount() const;
 
            const std::vector<DTConsiderationType>& GetConsiderationTypes() const;
 
            const DTConsiderationType GetConsiderationType(int columnIndex) const;
 
            Dataset(std::initializer_list<DTConsiderationType> considerationTypes);
            
            Dataset(std::vector<DTConsiderationType> considerationTypes);
 
            void AddSample(std::unique_ptr<ISimulatedGameAction> decision, std::initializer_list<float> data);
 
            void AddSample(std::unique_ptr<ISimulatedGameAction> decision, std::vector<float> data);
 
            void AddSample(std::unique_ptr<DatasetSample> sample);
            
            double ValidateBinary(DecisionNode<ISimulatedGameAction>& decisionTreeNodeRoot);
 
            std::vector<std::unique_ptr<DatasetSample>> Samples;
 
            bool MoveFromOther(Dataset& sourceDataset);
 
            bool CopyFromOther(Dataset& sourceDataset);
 
        private:
            bool CheckDataCompatibility(const Dataset& other) const;
 
            double CalculateDecisionEntropy() const;
 
            std::unique_ptr<Dataset> SplitByFilter(std::function<bool(std::vector<float>&)> filter) const;
            std::vector<std::unique_ptr<Dataset>> SplitContinuous(size_t column, float splitValue) const;
            std::vector<std::pair<std::unique_ptr<Dataset>, float>> SplitNominal(int column) const;
            
            std::vector<DTConsiderationType> considerationTypes;
 
            friend class C45Algorithm;
        };
    }
}
#endif //GRAIL_DATASET_H