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 */