learn_parameters.hpp

#pragma once
 
#include "../_cexports/c_minos.h"
 
#include "../global.hpp"
 
namespace Cvb
{
  CVB_BEGIN_INLINE_NS

  namespace Minos
  {


    class LearnParameters
    {
    public:
      LearnParameters(int minFeatureCount, int polydromy, int ensembleSize, int contrastTrigger, int indifferenceRadius,
                      double negativeDensity) noexcept
          : minFeatureCount_(minFeatureCount)
          , polydromy_(polydromy)
          , ensembleSize_(ensembleSize)
          , contrastTrigger_(contrastTrigger)
          , indifferenceRadius_(indifferenceRadius)
          , negativeDensity_(negativeDensity)
      {
      }
 
      LearnParameters() noexcept
          : minFeatureCount_(MinFeatureCountDefault())
          , polydromy_(PolydromyDefault())
          , ensembleSize_(EnsembleSizeDefault())
          , contrastTrigger_(ContrastTriggerDefault())
          , indifferenceRadius_(IndifferenceRadiusDefault())
          , negativeDensity_(NegativeDensityDefault())
      {
      }
 
    public:

      static int IndifferenceRadiusDefault() noexcept
      {
        return 6;
      }
      static int IndifferenceRadiusDefault() noexcept {…}


      static double NegativeDensityDefault() noexcept
      {
        return 1.0;
      }
      static double NegativeDensityDefault() noexcept {…}


      static int ContrastTriggerDefault() noexcept
      {
        return 8;
      }
      static int ContrastTriggerDefault() noexcept {…}


      static int EnsembleSizeDefault() noexcept
      {
        return 15;
      }
      static int EnsembleSizeDefault() noexcept {…}


      static int PolydromyDefault() noexcept
      {
        return 2;
      }
      static int PolydromyDefault() noexcept {…}


      static int MinFeatureCountDefault() noexcept
      {
        return 50;
      }
      static int MinFeatureCountDefault() noexcept {…}


      int MinFeatureCount() const noexcept
      {
        return minFeatureCount_;
      }
      int MinFeatureCount() const noexcept {…}


      void SetMinFeatureCount(int minFeatureCount)
      {
        if (minFeatureCount < 1)
        {
          throw std::invalid_argument("minimum feature count value must be >0");
        }
        minFeatureCount_ = minFeatureCount;
      }
      void SetMinFeatureCount(int minFeatureCount) {…}


      int Polydromy() const noexcept
      {
        return polydromy_;
      }
      int Polydromy() const noexcept {…}


      void SetPolydromy(int polydromy)
      {
        if (polydromy < 1)
        {
          throw std::invalid_argument("polydromy value must be >0");
        }
        polydromy_ = polydromy;
      }
      void SetPolydromy(int polydromy) {…}


      int EnsembleSize() const noexcept
      {
        return ensembleSize_;
      }
      int EnsembleSize() const noexcept {…}


      void SetEnsembleSize(int ensembleSize)
      {
        if (ensembleSize < 1)
        {
          throw std::invalid_argument("ensemble size value must be >0");
        }
        ensembleSize_ = ensembleSize;
      }
      void SetEnsembleSize(int ensembleSize) {…}


      int ContrastTrigger() const noexcept
      {
        return contrastTrigger_;
      }
      int ContrastTrigger() const noexcept {…}


      void SetContrastTrigger(int contrastTrigger)
      {
        if (contrastTrigger < 1)
        {
          throw std::invalid_argument("contrast trigger value must be >0");
        }
        contrastTrigger_ = contrastTrigger;
      }
      void SetContrastTrigger(int contrastTrigger) {…}


      int IndifferenceRadius() const noexcept
      {
        return indifferenceRadius_;
      }
      int IndifferenceRadius() const noexcept {…}


      void SetIndifferenceRadius(int indifferenceRadius)
      {
        if (indifferenceRadius < 1)
        {
          throw std::invalid_argument("indifference radius value must be >0");
        }
        indifferenceRadius_ = indifferenceRadius;
      }
      void SetIndifferenceRadius(int indifferenceRadius) {…}


      double NegativeDensity() const noexcept
      {
        return negativeDensity_;
      }
      double NegativeDensity() const noexcept {…}


      void SetNegativeDensity(double negativeDensity)
      {
        if (negativeDensity < 0.0 || negativeDensity > 1.0)
        {
          throw std::invalid_argument("negative density value must be in [0.0, 1.0]");
        }
        negativeDensity_ = negativeDensity;
      }
      void SetNegativeDensity(double negativeDensity) {…}
 
    private:
      int minFeatureCount_;
      int polydromy_;
      int ensembleSize_;
      int contrastTrigger_;
      int indifferenceRadius_;
      double negativeDensity_;
    };
    class LearnParameters {…};
 
  } /* namespace Minos */
  CVB_END_INLINE_NS
} /* namespace Cvb */