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 double NegativeDensityDefault ()  noexcept
  {
    return 1.0;
  }
 
 
  static int ContrastTriggerDefault ()  noexcept
  {
    return 8;
  }
 
 
  static int EnsembleSizeDefault ()  noexcept
  {
    return 15;
  }
 
 
  static int PolydromyDefault ()  noexcept
  {
    return 2;
  }
 
 
  static int MinFeatureCountDefault ()  noexcept
  {
    return 50;
  }
 
 
  int MinFeatureCount() const noexcept
  {
    return minFeatureCount_;
  }
 
 
  void SetMinFeatureCount(int minFeatureCount)
  {
    if (minFeatureCount < 1)
    {
      throw std::invalid_argument ("minimum feature count value must be >0");
    }
    minFeatureCount_ = minFeatureCount;
  }
 
 
  int Polydromy() const noexcept
  {
    return polydromy_;
  }
 
 
  void SetPolydromy(int polydromy)
  {
    if (polydromy < 1)
    {
      throw std::invalid_argument ("polydromy value must be >0");
    }
    polydromy_ = polydromy;
  }
 
 
  int EnsembleSize() const noexcept
  {
    return ensembleSize_;
  }
 
 
  void SetEnsembleSize(int ensembleSize)
  {
    if (ensembleSize < 1)
    {
      throw std::invalid_argument ("ensemble size value must be >0");
    }
    ensembleSize_ = ensembleSize;
  }
 
 
  int ContrastTrigger() const noexcept
  {
    return contrastTrigger_;
  }
 
 
  void SetContrastTrigger(int contrastTrigger)
  {
    if (contrastTrigger < 1)
    {
      throw std::invalid_argument ("contrast trigger value must be >0");
    }
    contrastTrigger_ = contrastTrigger;
  }
 
 
  int IndifferenceRadius() const noexcept
  {
    return indifferenceRadius_;
  }
 
 
  void SetIndifferenceRadius(int indifferenceRadius)
  {
    if (indifferenceRadius < 1)
    {
      throw std::invalid_argument ("indifference radius value must be >0");
    }
    indifferenceRadius_ = indifferenceRadius;
  }
 
 
  double NegativeDensity() const noexcept
  {
    return negativeDensity_;
  }
 
 
  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;
  }
 
private:
  int minFeatureCount_;
  int polydromy_;
  int ensembleSize_;
  int contrastTrigger_;
  int indifferenceRadius_;
  double negativeDensity_;
};
 
} /* namespace Minos */
CVB_END_INLINE_NS
} /* namespace Cvb */