objective.hpp

Go to the documentation of this file.

#pragma once
 
#include <initializer_list>
#include <utility>
#include <vector>
 
#include "copp/core.hpp"
 
namespace copp
{

    enum class ObjectiveKind
    {
        Time = 0,
        Linear = 1,
        ThermalEnergy = 2,
        TotalVariationTorque = 3,
    };

    class Objective
    {
    public:
        static Objective Time(double weight = 1.0)
        {
            return Objective(ObjectiveKind::Time, weight, {}, {}, {});
        }

        static Objective Linear(
            double weight,
            Span<const double> alpha,
            Span<const double> beta)
        {
            return Objective(
                ObjectiveKind::Linear,
                weight,
                copy_span(alpha),
                copy_span(beta),
                {});
        }
 
        static Objective Linear(
            double weight,
            std::initializer_list<double> alpha,
            std::initializer_list<double> beta)
        {
            return Linear(weight, Span<const double>(alpha.begin(), alpha.size()),
                          Span<const double>(beta.begin(), beta.size()));
        }

        static Objective ThermalEnergy(double weight, Span<const double> normalize)
        {
            return Objective(
                ObjectiveKind::ThermalEnergy,
                weight,
                {},
                {},
                copy_span(normalize));
        }
 
        static Objective ThermalEnergy(double weight, std::initializer_list<double> normalize)
        {
            return ThermalEnergy(
                weight,
                Span<const double>(normalize.begin(), normalize.size()));
        }

        static Objective TotalVariationTorque(double weight, Span<const double> normalize)
        {
            return Objective(
                ObjectiveKind::TotalVariationTorque,
                weight,
                {},
                {},
                copy_span(normalize));
        }
 
        static Objective TotalVariationTorque(double weight, std::initializer_list<double> normalize)
        {
            return TotalVariationTorque(
                weight,
                Span<const double>(normalize.begin(), normalize.size()));
        }
 
        ObjectiveKind kind() const noexcept { return kind_; }
        double weight() const noexcept { return weight_; }
 
        Span<const double> alpha() const noexcept
        {
            return Span<const double>(alpha_.data(), alpha_.size());
        }
 
        Span<const double> beta() const noexcept
        {
            return Span<const double>(beta_.data(), beta_.size());
        }
 
        Span<const double> normalize() const noexcept
        {
            return Span<const double>(normalize_.data(), normalize_.size());
        }
 
    private:
        Objective(
            ObjectiveKind kind,
            double weight,
            std::vector<double> alpha,
            std::vector<double> beta,
            std::vector<double> normalize)
            : kind_(kind),
              weight_(weight),
              alpha_(std::move(alpha)),
              beta_(std::move(beta)),
              normalize_(std::move(normalize)) {}
 
        static std::vector<double> copy_span(Span<const double> values)
        {
            if (values.empty())
            {
                return {};
            }
            return std::vector<double>(values.data(), values.data() + values.size());
        }
 
        ObjectiveKind kind_ = ObjectiveKind::Time;
        double weight_ = 1.0;
        std::vector<double> alpha_;
        std::vector<double> beta_;
        std::vector<double> normalize_;
    };

    namespace objective
    {
        inline Objective Time(double weight = 1.0)
        {
            return Objective::Time(weight);
        }
 
        inline Objective Linear(
            double weight,
            Span<const double> alpha,
            Span<const double> beta)
        {
            return Objective::Linear(weight, alpha, beta);
        }
 
        inline Objective Linear(
            double weight,
            std::initializer_list<double> alpha,
            std::initializer_list<double> beta)
        {
            return Objective::Linear(weight, alpha, beta);
        }
 
        inline Objective ThermalEnergy(double weight, Span<const double> normalize)
        {
            return Objective::ThermalEnergy(weight, normalize);
        }
 
        inline Objective ThermalEnergy(double weight, std::initializer_list<double> normalize)
        {
            return Objective::ThermalEnergy(weight, normalize);
        }
 
        inline Objective TotalVariationTorque(double weight, Span<const double> normalize)
        {
            return Objective::TotalVariationTorque(weight, normalize);
        }
 
        inline Objective TotalVariationTorque(
            double weight,
            std::initializer_list<double> normalize)
        {
            return Objective::TotalVariationTorque(weight, normalize);
        }
    } // namespace objective
 
} // namespace copp