source: src/main/java/agents/anac/y2019/ibasic/boacomponents/IBasicPU.java@ 201

package agents.anac.y2019.ibasic.boacomponents;

import java.util.Arrays;
import java.util.List;
import java.util.ArrayList;

import genius.core.Bid;
import genius.core.Domain;
import genius.core.issue.Issue;
import genius.core.issue.IssueDiscrete;
import genius.core.issue.ValueDiscrete;
import genius.core.utility.AbstractUtilitySpace;
import genius.core.uncertainty.AdditiveUtilitySpaceFactory;
import genius.core.uncertainty.BidRanking;
import genius.core.uncertainty.UserModel;

import ilog.concert.*;
import ilog.cplex.*;

public class IBasicPU 
{
        public static AbstractUtilitySpace createUtilitySpace(Domain domain, UserModel userModel)
        {
                //Loading of the IloCplex Modeler
                IloCplexModeler icp = new IloCplexModeler();
                
                // Obtain the list of issues and the bid ranking.
                List<Issue> issueList = domain.getIssues();
                BidRanking bidRanking = userModel.getBidRanking();
                
                // Create an array that stores all issues for easy lookup of issue numbers.
                Issue[] issueArray = new Issue[issueList.size()];
                
                // Also create a list containing an array of discrete values for each issue for easy lookup later on.
                List<ValueDiscrete[]> valueArrayList = new ArrayList<ValueDiscrete[]>();
                
                // Fill the issue array and calculate the total number of values.
                for (int index = 0; index < issueList.size(); index++) 
                        issueArray[index] = issueList.get(index);

                // Fill the value array list.   
                for (int i = 0; i < issueList.size(); i++) 
                {
                        IssueDiscrete discIssue = (IssueDiscrete) issueArray[i];
                        List<ValueDiscrete> discValues = discIssue.getValues();
                        ValueDiscrete[] array = new ValueDiscrete[discValues.size()];
                        for (int index = 0; index < discValues.size(); index ++)
                        {
                                array[index] = discValues.get(index);
                        }
                        valueArrayList.add(array);
                }
                
                //The try catch is where the linear optimization problem is solved. This will happen in three steps:
                //1st: We determine the entry variables
                //2nd: We set the constraints
                //3rd: We solve the problem and create a utility space from the resulting soluion
                                
                try {
//--------------------------------------------------------------------------------------------------------------------------------------------------------              
                        //STEP 1: We initialize the entry variables. This happens using three sets of variables.
                        //1st: The phi values that correspond to each issue/value
                        //2nd: The set of slack variables
                        //3rd: The phi values that correspond to the maximum phi values
                        //Finally we initialize the objective function to be minimized.
                        
                        IloCplex cplexModel = new IloCplex();
                        
                        // Initialize the first set of entry arrays. Each issue corresponds to an array where its phi values are stored. 
                        List<IloNumVar[]> entryArrayList = new ArrayList<IloNumVar[]>();
                        for (int i=0; i<issueList.size(); i++) 
                        {
                                IssueDiscrete discIssue = (IssueDiscrete) issueArray[i];
                                List<ValueDiscrete> discValues = discIssue.getValues();
                                entryArrayList.add(new IloNumVar[discValues.size()]);
                        }
                        
                        // We fill these arrays with a default number.
                        for (IloNumVar[] array: entryArrayList) 
                                for (int index =0; index<array.length; index++) 
                                        array[index]=cplexModel.numVar(0.0, Double.MAX_VALUE);
                        
                        // Initialize the second entry array, which contains all slack variables and fill it.
                        IloNumVar[] slackVariables = new IloNumVar[bidRanking.getSize()-1];
                        for (int index=0; index<bidRanking.getSize()-1; index++) 
                                slackVariables[index] = cplexModel.numVar(0, Double.MAX_VALUE);
                        
                        // Initialise the third entry array, which contains the max phi values for each issue and fill it.
                        IloNumVar[] maxPhiVariables = new IloNumVar[issueList.size()];
                        for (int index=0; index<issueList.size(); index++) 
                                maxPhiVariables[index] = cplexModel.numVar(0, Double.MAX_VALUE);
                        
                        // Initialise the expression to be minimised, i.e. the sum of all slack variables.
                        IloLinearNumExpr objectiveFunction = cplexModel.linearNumExpr();
                        for (int index=0; index<bidRanking.getSize()-1; index++) {
                                objectiveFunction.addTerm(1, slackVariables[index]);
                        }
                        cplexModel.addMinimize(objectiveFunction);
                        
//--------------------------------------------------------------------------------------------------------------------------------------------------------              
//                       STEP 2: We initialize the constraints. A total of  
//                       Note that the positivity constraints are already contained in the definition of the unknown variables, therefore
//                       we do not explicitly have to add the constraints that the slack variables and the phi-variables should be positive.
//                       1st: For each pairwise comparison of the outcomes the sum of the difference in Utility and the slack variables should be higher than 0.
//                       2nd: The sum of the phi variables of the values of the highest bid should be the highest possible utility.
//                       3rd: The sum of the phi variables of the values of the lowest bid should be the lowest possible utility.
//                       More: The sum of the highest phi variables for each issue has to be 1.
//                       4th: We set of constraints that the maximum variables should be equal to the maximum phi values of the given index.
//                       5th: We set the constraint that the maximum variables should sum to 1.
                         
                        
                        //Initialization of each constraint and the highest and lowestbids. 
                        IloLinearNumExpr constraint1;
                        IloLinearNumExpr constraint2 = cplexModel.linearNumExpr();
                        IloLinearNumExpr constraint3 = cplexModel.linearNumExpr();
                        IloLinearNumExpr constraint5 = cplexModel.linearNumExpr();
                        Bid highestBid = bidRanking.getMaximalBid();
                        Bid lowestBid = bidRanking.getMinimalBid();
                        
                        for (int index=0; index<bidRanking.getSize()-1; index++) 
                        {
                                constraint1 = cplexModel.linearNumExpr();
                                
                                // We add the slack variable to the constraint. 
                                constraint1.addTerm(1, slackVariables[index]);
                                Bid higherBid = bidRanking.getBidOrder().get(bidRanking.getSize()-1-index);
                                Bid nextBid = bidRanking.getBidOrder().get(bidRanking.getSize()-2-index);
                                
                                // We add the difference in Utility in the phi variables for each issue.
                                for (int j=0; j<issueList.size(); j++) 
                                {
                                        ValueDiscrete higherValueDiscrete = (ValueDiscrete) higherBid.getValue(issueArray[j]);
                                        ValueDiscrete nextValueDiscrete = (ValueDiscrete) nextBid.getValue(issueArray[j]);
                                        
                                        int higherValueIndex = Arrays.asList(valueArrayList.get(j)).indexOf(higherValueDiscrete);
                                        int nextValueIndex = Arrays.asList(valueArrayList.get(j)).indexOf(nextValueDiscrete);
                                        
                                        constraint1.addTerm(1, entryArrayList.get(j)[higherValueIndex]);
                                        constraint1.addTerm(-1, entryArrayList.get(j)[nextValueIndex]);
                                }
                                
                                //Set the constraint that this sum has to be larger than 0
                                cplexModel.addGe(constraint1,0.0);
                        }
        
                        //We initialize the rest of the constraints in one loop over the issues. 
                        for (int index = 0; index < issueList.size(); index++) 
                        {
                                //2nd constraint
                                ValueDiscrete highestValueDiscrete = (ValueDiscrete) highestBid.getValue(issueArray[index]);
                                int highestValueIndex = Arrays.asList(valueArrayList.get(index)).indexOf(highestValueDiscrete);
                                constraint2.addTerm(1, entryArrayList.get(index)[highestValueIndex]);
                                
                                //3rd constraint 
                                ValueDiscrete lowestValueDiscrete = (ValueDiscrete) lowestBid.getValue(issueArray[index]);
                                int lowestValueIndex = Arrays.asList(valueArrayList.get(index)).indexOf(lowestValueDiscrete);
                                constraint3.addTerm(1, entryArrayList.get(index)[lowestValueIndex]);
                                
                                //4th constraint 
                                IloLinearNumExpr constraint4 = cplexModel.linearNumExpr();
                                constraint4.addTerm(1,maxPhiVariables[index]);
                                constraint4.addTerm(-1,(IloNumVar)icp.max(entryArrayList.get(index)));
                                cplexModel.addEq(constraint4,0);
                                
                                //5th constraint 
                                constraint5.addTerm(1, maxPhiVariables[index]);
                        }
                        // The sum has to be equal to the highest utility for the second constraint
                        cplexModel.addEq(constraint2,bidRanking.getHighUtility());
                        
                        // The sum has to be equal to the lowest utility for the third constraint.
                        cplexModel.addEq(constraint3,bidRanking.getLowUtility());
        
                        //Add the constraint of the 5th
                        cplexModel.addEq(constraint5, 1.0);
                        
//--------------------------------------------------------------------------------------------------------------------------------------------------------                      
                        //Step three: solve the linear optimisation problem and create a utility space from the resulting solution.
                        //This happens by simply setting each valuation of each value to the corresponding phi value. 
                        //We do not need to take weight into account, since this is already incorporated in the phi-value. 
                        
                        if (cplexModel.solve()) 
                        {
                                AdditiveUtilitySpaceFactory createdUtilitySpace = new AdditiveUtilitySpaceFactory(domain);

                                //We loop through the issues and get the valuation of the each value and if it is the highest value in the set, 
                                //we keep it and end by setting the weight to this number
                                for (int index = 0; index < issueList.size(); index++)
                                {
                                        IssueDiscrete issue = (IssueDiscrete) issueList.get(index);
                                        List<ValueDiscrete> values = issue.getValues();
                                        
                                        double totalPhi = 0.0;
                                        double maxphi = 0.0;
                                        
                                        for (ValueDiscrete singleValue: values) 
                                        {
                                                double valueValuation = cplexModel.getValue(entryArrayList.get(index)[Arrays.asList(valueArrayList.get(index)).indexOf(singleValue)]);
                                                if (valueValuation > maxphi) 
                                                        maxphi = valueValuation;
                                                totalPhi += valueValuation;
                                        }
                                        createdUtilitySpace.setWeight(issueList.get(index), maxphi);
                                        
                                        //Some phi values end up with 0 values, which needs to be corrected. As a solution we divide the highest value by the total amount of values. 
                                        double averagePhi = totalPhi / values.size();
                                        for (ValueDiscrete value: values) 
                                        {
                                                int valueIndex = Arrays.asList(valueArrayList.get(index)).indexOf(value);
                                                double valueEvaluation = cplexModel.getValue(entryArrayList.get(index)[valueIndex]);
                                                if (valueEvaluation == 0.0) 
                                                {
                                                        valueEvaluation = averagePhi;                                   
                                                }
                                                createdUtilitySpace.setUtility(issueList.get(index), value,valueEvaluation);
                                        }
                                }
                                
                                //We return the created utility space after the loop has finished, marking the end of this method. 
                                return createdUtilitySpace.getUtilitySpace();
                        
                        } 
                        else 
                                return null;
                        
                        
                } 
                catch (IloException ex) 
                {
                        return null;
                }
                        
        }
}