Program Listing for File functions.h

↰ Return to documentation for file (include/parpecommon/functions.h)

#ifndef PARPE_OPTIMIZATION_FUNCTIONS_H
#define PARPE_OPTIMIZATION_FUNCTIONS_H

#include <parpecommon/logging.h>

#include <memory>
#include <vector>

#include <gsl/gsl-lite.hpp>

namespace parpe {

enum FunctionEvaluationStatus
{
    functionEvaluationSuccess,
    functionEvaluationFailure,
};

class GradientFunction
{
public:
    virtual FunctionEvaluationStatus evaluate(
            gsl::span<double const> parameters,
            double& fval,
            gsl::span<double> gradient) const;

    virtual FunctionEvaluationStatus evaluate(
            gsl::span<double const> parameters,
            double& fval,
            gsl::span<double> gradient,
            Logger* logger,
            double* cpuTime) const = 0;

    virtual int numParameters() const = 0;

    virtual std::vector<std::string> getParameterIds() const = 0;

    virtual ~GradientFunction() = default;
};


template<typename T>
class SummedGradientFunction
{
public:
    virtual FunctionEvaluationStatus evaluate(
            gsl::span<const double> parameters,
            T dataset,
            double& fval,
            gsl::span<double> gradient,
            Logger* logger,
            double* cpuTime) const = 0;

    virtual FunctionEvaluationStatus evaluate(
            gsl::span<const double> parameters,
            std::vector<T> datasets,
            double& fval,
            gsl::span<double> gradient,
            Logger* logger,
            double* cpuTime) const = 0;

    virtual int numParameters() const = 0;

    virtual std::vector<std::string> getParameterIds() const = 0;

    virtual ~SummedGradientFunction() = default;
};


template<typename T>
class SummedGradientFunctionGradientFunctionAdapter
        : public GradientFunction
        , public SummedGradientFunction<T>
{
public:
    SummedGradientFunctionGradientFunctionAdapter(
            std::unique_ptr<SummedGradientFunction<T>> gradFun,
            std::vector<T> datasets)
        : grad_fun_(std::move(gradFun))
        , datasets_(datasets)
    {}

    FunctionEvaluationStatus evaluate(gsl::span<const double> parameters,
                                      double& fval,
                                      gsl::span<double> gradient,
                                      Logger* logger = nullptr,
                                      double* cpuTime = nullptr) const override
    {
        return grad_fun_->evaluate(
                    parameters, datasets_, fval, gradient, logger, cpuTime);
    }

    FunctionEvaluationStatus evaluate(gsl::span<const double> parameters,
                                      T dataset,
                                      double& fval,
                                      gsl::span<double> gradient,
                                      Logger* logger,
                                      double* cpuTime) const override
    {
        return grad_fun_->evaluate(
                    parameters, dataset, fval, gradient, logger, cpuTime);
    }

    FunctionEvaluationStatus evaluate(gsl::span<const double> parameters,
                                      std::vector<T> datasets,
                                      double& fval,
                                      gsl::span<double> gradient,
                                      Logger* logger,
                                      double* cpuTime) const override
    {
        return grad_fun_->evaluate(
                    parameters, datasets, fval, gradient, logger, cpuTime);
    }

    int numParameters() const override { return grad_fun_->numParameters(); }

    std::vector<std::string> getParameterIds() const override
    {
        return grad_fun_->getParameterIds();
    }

    SummedGradientFunction<T>* getWrappedFunction() const
    {
        return grad_fun_.get();
    }

private:
    std::unique_ptr<SummedGradientFunction<T>> grad_fun_;

    std::vector<T> datasets_;
};

}
#endif