source: anac2020/AzarAgent/src/main/java/geniusweb/exampleparties/simpleshaop/FrequencyModel.java@ 77

package geniusweb.exampleparties.simpleshaop;


import java.util.HashMap;
import java.util.Map.Entry;

import geniusweb.issuevalue.Bid;
import geniusweb.issuevalue.DiscreteValue;
import geniusweb.issuevalue.Domain;
import geniusweb.issuevalue.Value;
 

/**
 * This class contains main agent methods and algorithms that agent uses in a
 * negotiation session based on Alternating Offers protocol.
 * 
 * @author Siamak Hajizadeh, Thijs van Krimpen, Daphne Looije
 * 
 */
public class FrequencyModel {
        
        private BidHistory bidHistory;
        private final double LEARNING_COEF = 0.2D;
        private final int LEARNING_VALUE_ADDITION = 1;
        private Bid opponentLastBid = null;
        private Domain domain = null;
        private USpace oppUtility = null;
        private int numberOfIssues = 0;
        



        /**
         * handles some initializations. it is called when agent object is created
         * to start a negotiation session
         * 
         */

        public FrequencyModel(USpace utilitySpace) {
                

                bidHistory = new BidHistory(utilitySpace);
                oppUtility = utilitySpace;
                domain = utilitySpace.getDomain();
                numberOfIssues = domain.getIssues().size();
                

                /*
                double w = 1D / numberOfIssues;
                for ( String e : oppUtility.getEvals().keySet()) {
                        

                        oppUtility.setWeight(e, w);
                        try {
                                // set the initial weight for each value of each issue to 1.
                                
                                for ( String issue : oppUtility.getEvals().keySet() )
                                        for ( Value val : oppUtility.getValues(issue).keySet() )
                                                oppUtility.setEval(issue, val, 1.0);
                        } catch (Exception ex) {
                                ex.printStackTrace();
                        }
                        
                }
                */
                
                
        }




        /**
         * Contains an object of type {@link AdditiveUtilitySpace} that is updated
         * over time and as bids are received, to match the preference profile of
         * the opponent.
         * 
         */

        public void updateLearner(Bid bid) {

                opponentLastBid = bid;
                bidHistory.addOpponentBid(opponentLastBid);

                if (bidHistory.getOpponentBidCount() < 2)
                        return;

                int numberOfUnchanged = 0;
                HashMap<String, Integer> lastDiffSet = bidHistory
                                .BidDifferenceofOpponentsLastTwo();

                // counting the number of unchanged issues
                for (String i : lastDiffSet.keySet()) {
                        if (lastDiffSet.get(i) == 0)
                                numberOfUnchanged++;
                }

                
                // This is the value to be added to weights of unchanged issues before
                // normalization.
                // Also the value that is taken as the minimum possible weight,
                // (therefore defining the maximum possible also).
                double goldenValue = LEARNING_COEF / numberOfIssues;
                // The total sum of weights before normalization.
                double totalSum = 1D + goldenValue * numberOfUnchanged;
                // The maximum possible weight
                double maximumWeight = 1D - (numberOfIssues) * goldenValue / totalSum;

                // re-weighing issues while making sure that the sum remains 1
                for (String issue : lastDiffSet.keySet()) {
                        if (lastDiffSet.get(issue) == 0 && oppUtility.getWeight(issue) < maximumWeight)
                                oppUtility.setWeight(issue,
                                                (oppUtility.getWeight(issue) + goldenValue) / totalSum);
                        else
                                oppUtility.setWeight(issue, oppUtility.getWeight(issue) / totalSum);
                }


                // اضافه کردن مقدار یک به ولیو ها بدون نرمالایز
                for ( String issue : bid.getIssueValues().keySet() ) {
                                Value val = bid.getValue(issue);
                                oppUtility.setEval(issue, val,  (oppUtility.getValue(issue, val)+LEARNING_VALUE_ADDITION) );
                }

                
        }


        public USpace getOpponentUtilitySpace()
        {
                return oppUtility;
        }
        


}