regression_test_result.hpp

#pragma once
 
#include "../_cexports/c_polimago.h"
 
#include "../global.hpp"
#include "../string.hpp"
#include "test_result_base.hpp"
 
#include <vector>
#include <memory>
 
namespace Cvb
{
CVB_BEGIN_INLINE_NS
 
namespace Polimago
{
namespace Testing
{
 
 
class RegressionTestResult : public TestResultBase
{
private:
  RegressionTestResult (ReleaseObjectGuard&& guard)
    : TestResultBase (std::move (guard))
  {
    auto numExamples = NumExamples ();
    auto dimension = RegressionDimension ();
    for (decltype(numExamples) i = 0; i < numExamples; ++i)
    {
      std::vector<double> targetValuesPerExample;
      for (decltype(dimension) j = 0; j < dimension; ++j)
      {
        auto targetValue = CVB_CALL_CAPI(PMGetTestResultTargetValue(Handle(), i, j));
        targetValuesPerExample.push_back (targetValue);
      }
      targetValues_.push_back (targetValuesPerExample);
    }
 
    for (decltype(numExamples) i = 0; i < numExamples; ++i)
    {
      std::vector<double> predictionResultsPerExample;
      for (decltype(dimension) j = 0; j < dimension; ++j)
      {
        auto predictionResult = CVB_CALL_CAPI(PMGetTestResultNumericalPrediction(Handle(), i, j));
        predictionResultsPerExample.push_back (predictionResult);
      }
      predictionResults_.push_back (predictionResultsPerExample);
    }
  }
 
  std::string ObjectName () const override
  {
    return thisObjectName_;
  }
 
public:
 
  RegressionTestResult (const String & fileName)
    : RegressionTestResult (ReleaseObjectGuard(LoadInternal (fileName)))
  {
    if (CVB_CALL_CAPI (PMGetTestResultNumClasses(Handle())) != 0)
    {
      throw std::runtime_error ("Loading the RegressionTestResult failed");
    }
  }
 
  RegressionTestResult (RegressionTestResult&&) noexcept = default;
 
  RegressionTestResult& operator=(RegressionTestResult&&) noexcept = default;
 
  virtual ~RegressionTestResult () {};
 
 
  static std::unique_ptr<RegressionTestResult> FromHandle (ReleaseObjectGuard&& guard)
  {
    if (!guard.Handle ())
    {
      throw std::invalid_argument ("invalid regression test result native handle");
    }
    return std::unique_ptr<RegressionTestResult>(new RegressionTestResult(std::move(guard)));
  }
 
 
  static std::unique_ptr<RegressionTestResult> Load (const String & fileName)
  {
    return std::unique_ptr<RegressionTestResult>(new RegressionTestResult(fileName));
  }
 
 
  int RegressionDimension() const
  {
    return static_cast<int>(CVB_CALL_CAPI (PMGetTestResultOutputDimension(Handle())));
  }
 
 
  std::vector<std::vector<double>> TargetValues() const
  {
    return targetValues_;
  }
 
 
  std::vector<std::vector<double>> PredictedValues() const
  {
    return predictionResults_;
  }
 
private:
  std::vector<std::vector<double>> targetValues_;
  std::vector<std::vector<double>> predictionResults_;
  const std::string thisObjectName_ = "Polimago Regression Test Result";
};
 
using RegressionTestResultPtr = std::shared_ptr<RegressionTestResult>;
 
 
} /* namespace Testing */
 
using Testing::RegressionTestResult;
using Testing::RegressionTestResultPtr;
 
} /* namespace Polimago */
CVB_END_INLINE_NS
} /* namespace Cvb */