profit_oracle.hpp

Go to the documentation of this file.

 
// -*- coding: utf-8 -*-
#pragma once
 
#include <cmath>  // for log
#include <tuple>  // for tuple
#include <valarray>
 
#include "../round_robin.hpp"
 
class ProfitOracle {
    using Vec = std::valarray<double>;
    using Cut = std::pair<Vec, double>;
 
    RoundRobin _rr{2};
    const double _log_pA;
    const double _log_k;
    const Vec _price_out;
    double _log_Cobb = 0.0;
    double _vx = 0.0;
    Vec _elasticities;
 
    auto _constraint_capacity(const Vec& y, const Vec&, const double) -> Cut*;
 
    auto _constraint_profit(const Vec& y, const Vec& x, const double gamma) -> Cut*;
 
  public:
    ProfitOracle(double p, double A, double k, const Vec& a, const Vec& v)
        : _log_pA{std::log(p * A)}, _log_k{std::log(k)}, _price_out{v}, _elasticities{a} {}
 
    ProfitOracle(const ProfitOracle&) = delete;
    ProfitOracle& operator=(const ProfitOracle&) = delete;
    ProfitOracle(ProfitOracle&&) = delete;
    ProfitOracle& operator=(ProfitOracle&&) = delete;
    ~ProfitOracle() = default;
 
    auto set_elasticities(const Vec& elasticities) { this->_elasticities = elasticities; }
 
    auto assess_feas(const Vec& y, const double& gamma) -> Cut*;
 
    auto assess_optim(const Vec& y, double& gamma) -> std::tuple<Cut, bool>;
};
 
class ProfitOracleRb {
    using Vec = std::valarray<double>;
    using Cut = std::pair<Vec, double>;
 
    const Vec _uie;
    Vec _elasticities;
    ProfitOracle P;
 
  public:
    ProfitOracleRb(double p, double A, double k, const Vec& a, const Vec& v, const Vec& e,
                   double e3)
        : _uie{e}, _elasticities{a}, P(p - e3, A, k - e3, a, v + Vec{e3, e3}) {}
 
    auto assess_optim(const Vec& y, double& gamma) -> std::tuple<Cut, bool> {
        auto a_rb = this->_elasticities;
        a_rb[0] += y[0] > 0.0 ? -this->_uie[0] : this->_uie[0];
        a_rb[1] += y[1] > 0.0 ? -this->_uie[1] : this->_uie[1];
        this->P.set_elasticities(a_rb);
        return this->P.assess_optim(y, gamma);
    }
};
 
class ProfitOracleQ {
    using Vec = std::valarray<double>;
    using Cut = std::pair<Vec, double>;
 
    ProfitOracle P;
    Vec _yd;
 
  public:
    ProfitOracleQ(double p, double A, double k, const Vec& a, const Vec& v) : P{p, A, k, a, v} {}
 
    auto assess_optim_q(const Vec& y, double& gamma, bool retry)
        -> std::tuple<Cut, bool, Vec, bool>;
};