predictor_factory_base.hpp

#pragma once
 
#include "../_cexports/c_polimago.h"
 
#include "../global.hpp"
#include "../string.hpp"
#include "../value_range.hpp"
#include "predictor_base.hpp"
#include "test_result_base.hpp"
 
#include <algorithm>
#include <iterator>
#include <cctype>
 
namespace Cvb
{
  CVB_BEGIN_INLINE_NS

  namespace Polimago
  {
    namespace Training
    {


      class PredictorFactoryBase
      {
      public:
        PredictorFactoryBase(const PredictorFactoryBase &other)            = delete;
        PredictorFactoryBase &operator=(const PredictorFactoryBase &other) = delete;
        PredictorFactoryBase(PredictorFactoryBase &&other)                 = delete;
        PredictorFactoryBase &operator=(PredictorFactoryBase &&other)      = delete;
        virtual ~PredictorFactoryBase()                                    = default;
 
      protected:
        PredictorFactoryBase()
            : preproCode_()
            , lambda_(LambdaDefault)
        {
        }
 
      public:
        static constexpr double LambdaDefault = 0.1;

        static ValueRange<double> LambdaRange()
        {
          return ValueRange<double>(0.0, 10.0);
        }
        static ValueRange<double> LambdaRange() {…}

        static constexpr int FeatureResolutionDefault = 1;

        static ValueRange<int> FeatureResolutionRange()
        {
          return ValueRange<int>(0, 10);
        }
        static ValueRange<int> FeatureResolutionRange() {…}

        static constexpr int PreprocessingMaxLength = 15;

        static constexpr std::array<char, 4> PreprocessingValidCharacters()
        {
          return {'p', 'a', 's', '+'};
        }
        static constexpr std::array<char, 4> PreprocessingValidCharacters() {…}


        double Lambda() const noexcept
        {
          return lambda_;
        }
        double Lambda() const noexcept {…}


        void SetLambda(double lambda)
        {
          if ((lambda < LambdaRange().Min()) || (lambda > LambdaRange().Max()))
          {
            throw std::out_of_range("lambda value out of range");
          }
 
          lambda_ = lambda;
        }
        void SetLambda(double lambda) {…}


        String Preprocessing() const
        {
          return preproCode_;
        }
        String Preprocessing() const {…}


        void SetPreprocessing(const String &code)
        {
          if (code.length() > PreprocessingMaxLength)
          {
            throw std::invalid_argument("Preprocessing codes must not be longer than 15 characters");
          }
          std::string asciiCode(Internal::CastToAscii(code));
          std::transform(asciiCode.begin(), asciiCode.end(), asciiCode.begin(),
                         [](char ch) { return static_cast<char>(std::tolower(ch)); });
          if (asciiCode.find_first_not_of(PreprocessingValidCharacters().data()) != std::string::npos)
          {
            throw std::invalid_argument("Preprocessing code contains invalid characters");
          }
 
          preproCode_.assign(asciiCode.begin(), asciiCode.end());
        }
        void SetPreprocessing(const String &code) {…}


        static String FormatPreprocessingCode(const String &input)
        {
          std::string asciiCode;
          std::transform(input.begin(), input.end(), std::back_inserter(asciiCode), [](const String::value_type ch) {
            return static_cast<char>(std::tolower(static_cast<char>(ch)));
          });
 
          String retval;
          for (auto c : asciiCode)
          {
            auto preprocessingValidCharacters = PreprocessingValidCharacters();
            if (std::find(preprocessingValidCharacters.begin(), preprocessingValidCharacters.end(), c)
                    != preprocessingValidCharacters.end()
                && retval.length() < PreprocessingMaxLength)
            {
              retval.push_back(c);
            }
          }
          return retval;
        }
        static String FormatPreprocessingCode(const String &input) {…}
 
      protected:
        void UseSettingsFromPredictor(const PredictorBase &clf)
        {
          preproCode_ = clf.Preprocessing();
          lambda_     = clf.Lambda();
        }
 
        double Lamda() const noexcept
        {
          return lambda_;
        }
 
        void SetLamda(double lambda) noexcept
        {
          lambda_ = lambda;
        }
 
        String PreproCode() const
        {
          return preproCode_;
        }
 
        void SetPreproCode(const String &prepreCode)
        {
          preproCode_ = prepreCode;
        }
 
      private:
        String preproCode_;
        double lambda_;
      };
      class PredictorFactoryBase {…};

      using PredictorFactoryBasePtr = std::shared_ptr<PredictorFactoryBase>;


      class PredictorFactoryBaseEx : public PredictorFactoryBase
      {
      protected:
        PredictorFactoryBaseEx()
            : PredictorFactoryBase()
            , featureResolution_(FeatureResolutionDefault)
            , interpolation_(InterpolationDefault)
        {
        }
 
      public:
        static constexpr InterpolationType InterpolationDefault = InterpolationType::Linear;


        InterpolationType Interpolation() const noexcept
        {
          return interpolation_;
        }
        InterpolationType Interpolation() const noexcept {…}


        void SetInterpolation(InterpolationType interpolation) noexcept
        {
          interpolation_ = interpolation;
        }
        void SetInterpolation(InterpolationType interpolation) noexcept {…}


        int FeatureResolution() const noexcept
        {
          return featureResolution_;
        }
        int FeatureResolution() const noexcept {…}


        void SetFeatureResolution(int featureResolution)
        {
          if ((featureResolution < FeatureResolutionRange().Min())
              || (featureResolution > FeatureResolutionRange().Max()))
          {
            throw std::out_of_range("feature resolution value out of range");
          }
 
          featureResolution_ = featureResolution;
        }
        void SetFeatureResolution(int featureResolution) {…}
 
      protected:
        void UseSettingsFromPredictor(const PredictorBaseEx &clf)
        {
          PredictorFactoryBase::UseSettingsFromPredictor(clf);
          featureResolution_ = clf.FeatureResolution();
          interpolation_     = clf.Interpolation();
        }
 
        void UseSettingsFromTestResult(const Testing::TestResultBase &res)
        {
          interpolation_ = res.Interpolation();
          SetPreproCode(res.Preprocessing());
          SetLambda(res.Lambda());
          featureResolution_ = res.FeatureResolution();
        }
 
      private:
        int featureResolution_;
        InterpolationType interpolation_;
      };
      class PredictorFactoryBaseEx : public PredictorFactoryBase {…};

      using PredictorFactoryBaseExPtr = std::shared_ptr<PredictorFactoryBaseEx>;
 
    } /* namespace Training */
 
    using Training::PredictorFactoryBase;
    using Training::PredictorFactoryBaseEx;
    using Training::PredictorFactoryBaseExPtr;
    using Training::PredictorFactoryBasePtr;
 
  } /* namespace Polimago */
  CVB_END_INLINE_NS
} /* namespace Cvb */