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:
        explicit 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:

        explicit RegressionTestResult(const String &fileName)
            : RegressionTestResult(ReleaseObjectGuard(LoadInternal(fileName)))
        {
          if (CVB_CALL_CAPI(PMGetTestResultNumClasses(Handle())) != 0)
          {
            throw std::runtime_error("Loading the RegressionTestResult failed");
          }
        }
        explicit RegressionTestResult(const String &fileName) {…}


        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> FromHandle(ReleaseObjectGuard &&guard) {…}


        static std::unique_ptr<RegressionTestResult> Load(const String &fileName)
        {
          return std::make_unique<RegressionTestResult>(fileName);
        }
        static std::unique_ptr<RegressionTestResult> Load(const String &fileName) {…}


        int RegressionDimension() const
        {
          return static_cast<int>(CVB_CALL_CAPI(PMGetTestResultOutputDimension(Handle())));
        }
        int RegressionDimension() const {…}


        std::vector<std::vector<double>> TargetValues() const
        {
          return targetValues_;
        }
        std::vector<std::vector<double>> TargetValues() const {…}


        std::vector<std::vector<double>> PredictedValues() const
        {
          return predictionResults_;
        }
        std::vector<std::vector<double>> PredictedValues() const {…}
 
      private:
        std::vector<std::vector<double>> targetValues_;
        std::vector<std::vector<double>> predictionResults_;
        const std::string thisObjectName_ = "Polimago Regression Test Result";
      };
      class RegressionTestResult : public TestResultBase {…};

      using RegressionTestResultPtr = std::shared_ptr<RegressionTestResult>;
 
    } /* namespace Testing */
 
    using Testing::RegressionTestResult;
    using Testing::RegressionTestResultPtr;
 
  } /* namespace Polimago */
  CVB_END_INLINE_NS
} /* namespace Cvb */