.. _program_listing_file_include_games_ipg.h:

Program Listing for File ipg.h
==============================

|exhale_lsh| :ref:`Return to documentation for file <file_include_games_ipg.h>` (``include/games/ipg.h``)

.. |exhale_lsh| unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS

.. code-block:: cpp

   /* #############################################
    *             This file is part of
    *                    ZERO
    *
    *             Copyright (c) 2020
    *     Released under the Creative Commons
    *         CC BY-NC-SA 4.0 License
    *
    *              Find out more at
    *        https://github.com/ds4dm/ZERO
    * #############################################*/
   
   
   #pragma once
   #include "zero.h"
   #include <armadillo>
   #include <gurobi_c++.h>
   #include <iostream>
   #include <memory>
   #include <set>
   #include <string>
   
   namespace Data::IPG {
   
     enum class Algorithms {
        CutAndPlay, 
        ZERORegrets 
     };
   
     enum class CutsAggressiveness {
        NotEvenTry, 
        NoThanks,   
        KeepItCool, 
        Truculent   
     };
     enum class Objectives {
        Feasibility, 
        Quadratic,   
        Linear,      
        ZERORegrets_SocialCost, 
        ZERORegrets_PlayerOne 
     };
   
     class DataObject : public ZEROAlgorithmData {
     public:
        Attr<Data::IPG::CutsAggressiveness> CutAggressiveness = {
             Data::IPG::CutsAggressiveness::KeepItCool};
        Attr<Data::IPG::Algorithms> Algorithm = {
             Data::IPG::Algorithms::CutAndPlay}; 
        Attr<Data::LCP::Algorithms> LCPSolver;  
        Attr<Data::IPG::Objectives> Objective = {
             Data::IPG::Objectives::Linear}; 
        Attr<std::vector<std::pair<std::string, int>>>
             Cuts; 
   
        Attr<double> Presolve = {true};
        DataObject() : LCPSolver{static_cast<Data::LCP::Algorithms>(0)} {};
     };
   } // namespace Data::IPG
   
   
   namespace Game {
   
     class IPG : public AbstractGame<Data::IPG::DataObject> {
     protected: // Datafields
        std::vector<std::shared_ptr<MathOpt::IP_Param>>
             PlayersIP{}; 
   
        std::vector<unsigned int> PlayerVariables{}; 
   
   
        bool                   Finalized{false};
        std::vector<arma::vec> Solution;      
        double                 SocialWelfare; 
   
     private:
        std::shared_ptr<Algorithms::IPG::Algorithm> Algorithm{}; 
   
   
     protected:
        virtual void preFinalize() = 0;
        virtual void postFinalize() = 0;
   
     public: // functions
        friend class Algorithms::IPG::Algorithm;
        friend class Algorithms::IPG::CutAndPlay;
        friend class Algorithms::IPG::ZERORegrets;
        void finalize();
        IPG(GRBEnv *env) { this->Env = env; };
        IPG(GRBEnv *env, std::vector<std::shared_ptr<MathOpt::IP_Param>> players);
   
        void findNashEq() override;
        bool isSolved(double tol = 1e-5) const override;
        bool isPureStrategy(double tol = 1e-5) const override; 
   
   
        std::vector<arma::vec> getX() const { return this->Solution; }
   
        /***
         * @brief Gets the SocialWelfare associated to the incumbent solution
         * @return The payoff value
         */
        double getSocialWelfare() const { return this->SocialWelfare; }
   
        ZEROStatistics<Data::IPG::DataObject> getStatistics() const { return this->Stats; }
   
        void setAlgorithm(Data::IPG::Algorithms algorithm) {
           this->Stats.AlgorithmData.Algorithm = algorithm;
        }
   
        void setPresolve(bool value) {
           this->Stats.AlgorithmData.Presolve=value;
        }
        void setLCPAlgorithm(const Data::LCP::Algorithms algo) {
           this->Stats.AlgorithmData.LCPSolver.set(algo);
        }
        void setGameObjective(const Data::IPG::Objectives obj) {
           this->Stats.AlgorithmData.Objective.set(obj);
        }
        void setCutsAggressiveness(const Data::IPG::CutsAggressiveness aggressiveness) {
           this->Stats.AlgorithmData.CutAggressiveness.set(aggressiveness);
        }
     };
   
   
   } // namespace Game
   namespace std {
     string to_string(Data::IPG::Algorithms al);
     string to_string(Data::IPG::Objectives ob);
     string to_string(Data::IPG::CutsAggressiveness ct);
   
   }; // namespace std
   
   #include "algorithms/IPG/ipg_algorithms.h"
   #include "interfaces/ipg_models.h"