source: src/main/java/agents/anac/y2016/yxagent/YXAgent.java@ 126

Last change on this file since 126 was 126, checked in by Aron Hammond, 6 years ago

Added function to calculate opposition to MultiLateralAnalysis.java

Moved code to add RLBOA listeners to RLBOAUtils is misc package

Added input for strategyParameters to SessionPanel (gui)

!! close SessionInfo after tournament; this caused /tmp/ to fill up with GeniusData files

Our own package:

  • Added opponents and strategies that are mentioned in the report
  • Change class hierarchy, agents can now extend from RLBOAagentBilateral to inherit RL functionality.
  • States extend from AbstractState
File size: 24.5 KB
Line 
1package agents.anac.y2016.yxagent;
2
3import java.util.List;
4
5import java.util.ArrayList;
6import java.util.HashMap;
7import java.util.Random;
8
9import genius.core.AgentID;
10import genius.core.Bid;
11import genius.core.actions.Accept;
12import genius.core.actions.Action;
13import genius.core.actions.EndNegotiation;
14import genius.core.actions.Offer;
15import genius.core.issue.Issue;
16import genius.core.issue.IssueDiscrete;
17import genius.core.issue.IssueInteger;
18import genius.core.issue.IssueReal;
19import genius.core.issue.Value;
20import genius.core.issue.ValueDiscrete;
21import genius.core.issue.ValueInteger;
22import genius.core.issue.ValueReal;
23import genius.core.parties.AbstractNegotiationParty;
24import genius.core.parties.NegotiationInfo;
25import genius.core.utility.AdditiveUtilitySpace;
26import genius.core.utility.UtilitySpace;
27
28public class YXAgent extends AbstractNegotiationParty {
29 private UtilitySpace utilitySpace;
30 private AdditiveUtilitySpace additiveUtilitySpace;
31 private List<Issue> issues;
32 private Action myAction = null;
33 private Bid myLastBid = null;
34 private Bid lastOpponentBid = null;
35 private double myUtility = 0.;
36 private double oppUtility = 0.;
37 private double rv;
38 private double discountFactor;
39 private int rounds;
40 private boolean updatedValueIntegerWeight;
41 private boolean issueContainIntegerType;
42 private boolean searchedDiscountWithRV;
43
44 private ArrayList<Object> opponents;
45 private ArrayList<Bid> allBids;
46 private HashMap<Object, ArrayList<Bid>> oppBidHistory;
47 private HashMap<Object, HashMap<Issue, Double>> oppIssueWeight;
48 private HashMap<Object, HashMap<Issue, ArrayList<ValueInteger>>> oppIssueIntegerValue;
49 private HashMap<Object, HashMap<Issue, HashMap<Value, Double>>> oppValueFrequency;
50 private HashMap<Object, Double> oppSumDiff;
51 private Object hardestOpp;
52
53 private long startTime;
54 private long currTime;
55 private long diff;
56 private double totalTime;
57 private long normalizedTime;
58
59 @Override
60 public void init(NegotiationInfo info) {
61 super.init(info);
62 this.utilitySpace = getUtilitySpace();
63 this.rv = utilitySpace.getReservationValue();
64 discountFactor = getUtilitySpace().getDiscountFactor();
65 issues = utilitySpace.getDomain().getIssues();
66 allBids = new ArrayList<Bid>();
67 opponents = new ArrayList<Object>();
68 oppBidHistory = new HashMap<Object, ArrayList<Bid>>();
69 oppIssueWeight = new HashMap<Object, HashMap<Issue, Double>>();
70 oppIssueIntegerValue = new HashMap<Object, HashMap<Issue, ArrayList<ValueInteger>>>();
71 oppValueFrequency = new HashMap<Object, HashMap<Issue, HashMap<Value, Double>>>();
72 oppSumDiff = new HashMap<Object, Double>();
73 rounds = 0;
74 updatedValueIntegerWeight = false;
75 issueContainIntegerType = false;
76 searchedDiscountWithRV = false;
77 initTime();
78 issueContainIntegerType();
79 }
80
81 @Override
82 public void receiveMessage(AgentID sender, Action opponentAction) {
83 super.receiveMessage(sender, opponentAction);
84
85 // initialize below
86 if (sender != null) {// sender == null is for Inform messages
87 if (!opponents.contains(sender)) {
88 opponents.add(sender);
89 initOpp(sender);
90 }
91 }
92
93 if (sender != null && opponentAction != null) {
94 if (opponentAction instanceof Offer) {
95
96 lastOpponentBid = ((Offer) opponentAction).getBid();
97 oppUtility = utilitySpace.getUtility(lastOpponentBid);
98 allBids.add(lastOpponentBid);
99
100 updateOpp(sender);
101 }
102 }
103 }
104
105 @Override
106 public Action chooseAction(List<Class<? extends Action>> possibleActions) {
107 updateTime();
108 rounds++;
109 Bid testBid = null;
110 Value v;
111 double calUtil = 0;
112 double calThreshold;
113 double tempThreshold;
114 double minimalThreshold = 0.7;
115 double deductThreshold = 0.1;
116 double calculatedThreshold = 1 - (opponents.size() * deductThreshold);
117
118 tempThreshold = Math.max(minimalThreshold, calculatedThreshold);
119 tempThreshold = Math.max(tempThreshold, rv);
120
121 // YXAgent Start 1st
122 if (!possibleActions.contains(Accept.class)) {
123 do {
124 myLastBid = generateRandomBid();
125 myUtility = utilitySpace.getUtility(myLastBid);
126
127 } while (myUtility < minimalThreshold); // YXAgent starts 1st, so
128 // YXAgent cant use
129 // calculatedThreshold as
130 // opponents.size = 0
131 return myAction = new Offer(getPartyId(), myLastBid);
132 }
133
134 // YXAgent Start 2nd
135 if (!searchedDiscountWithRV && rounds > 1) {
136 if (evaluateDiscountFactorNReservationValue()) {
137 return new EndNegotiation(getPartyId());
138 }
139 }
140
141 do {
142 testBid = generateRandomBid();
143 myUtility = utilitySpace.getUtility(testBid);
144
145 } while (myUtility < tempThreshold);
146
147 // Acceptance Criteria
148 if (rounds > 10 && normalizedTime <= 0.9) {// Initialization of Value
149 // Integer is available
150 // after 11 rounds
151 for (Issue issue : issues) {
152 v = lastOpponentBid.getValue(issue.getNumber());
153 // Retrieve ToughestOpp issue weight and value weight
154 if (issue.getType().toString().equals("INTEGER")) {
155 for (Value vv : oppValueFrequency.get(hardestOpp).get(issue)
156 .keySet()) { // Usual
157 // way
158 // of
159 // key
160 // retrieval
161 // of
162 // Hashmap
163 // does
164 // not
165 // work
166 // for
167 // INTEGER
168 // type,
169 // thats
170 // why
171 // need
172 // to
173 // loop
174 // through
175 if (Integer.parseInt(vv.toString()) == Integer
176 .parseInt(v.toString())) {
177 calUtil += oppIssueWeight.get(hardestOpp).get(issue)
178 * oppValueFrequency.get(hardestOpp)
179 .get(issue).get(vv);
180 break;
181 }
182 }
183 } else {
184 calUtil += oppIssueWeight.get(hardestOpp).get(issue)
185 * oppValueFrequency.get(hardestOpp).get(issue)
186 .get(v);
187 }
188 }
189
190 try {
191 calThreshold = (calUtil
192 - ((opponents.size() * deductThreshold) * 3 / 4));
193 calThreshold = Math.max(tempThreshold, calThreshold);
194 myAction = oppUtility > calThreshold
195 ? new Accept(getPartyId(), lastOpponentBid)
196 : new Offer(getPartyId(), testBid);
197 } catch (Exception e) {
198 e.printStackTrace();
199 }
200 return myAction;
201 } else { // Run when rounds <= 10 or normalizedTime > 0.9
202 try {
203 myAction = oppUtility > tempThreshold
204 ? new Accept(getPartyId(), lastOpponentBid)
205 : new Offer(getPartyId(), testBid);
206 } catch (Exception e) {
207 e.printStackTrace();
208 }
209 return myAction;
210 }
211 }
212
213 // ---------------------------------------------------------------------------------------------------------//
214 // Check Discount Factor wrt Reservation Value
215 private boolean evaluateDiscountFactorNReservationValue() {
216 double init = 1.0;
217 double initRV1 = 0.75;
218 double initRV2 = 0.86;
219 double initRV3 = 0.95;
220 double selfDiscount = 0.998;
221 double deduction = 0.005;
222 boolean endNegotiation = false;
223
224 if (opponents.size() >= 3) { // Applicable for 3 or more opponent
225 // scenario
226 for (double i = init; i >= 0.; i -= 0.01) {
227 String df = String.format("%.2f", i);
228 double df1 = Double.parseDouble(df);
229 if (discountFactor == df1 && rv >= initRV1) {
230 endNegotiation = true;
231 }
232 initRV1 -= 0.005; // Every "i" decrement 0.01, RV -= 0.005
233 }
234 searchedDiscountWithRV = true;
235 }
236
237 if (opponents.size() == 2) { // Applicable for 2 opponent scenario only
238 for (double i = init; i >= 0.; i -= 0.01) {
239 String df = String.format("%.2f", i);
240 double df1 = Double.parseDouble(df);
241 if (discountFactor == df1 && rv >= initRV2) {
242 endNegotiation = true;
243 }
244 initRV2 -= 0.006; // Every "i" decrement 0.01, RV -= 0.006
245 }
246 searchedDiscountWithRV = true;
247 }
248
249 if (opponents.size() == 1) { // Applicable for 1 opponent scenario only
250 for (double i = init; i >= 0.; i -= 0.01) {
251 String df = String.format("%.2f", i);
252 double df1 = Double.parseDouble(df);
253 if (discountFactor == df1 && rv >= initRV3) {
254 endNegotiation = true;
255 }
256 initRV3 = (initRV3 - deduction) * selfDiscount; // Every "i"
257 // decrement
258 // 0.01, RV =
259 // (RV -
260 // deduction) *
261 // selfDiscount;
262 }
263 searchedDiscountWithRV = true;
264 }
265 return endNegotiation;
266 }
267
268 // ---------------------------------------------------------------------------------------------------------//
269 // Update Opponent
270 private void updateOpp(AgentID sender) {
271
272 if (rounds <= 10) {
273 updateValueIntegerWeight(sender);
274 }
275 updateModelOppIssueWeight(sender);
276 updateModelOppValueWeight(sender);
277 oppBidHistory.get(sender).add(lastOpponentBid);
278 retrieveToughestOpp();
279 // printableWeight();
280 // printableValue();
281 // printableIntegerIssue();
282 // printableToughest();
283 }
284
285 private void updateValueIntegerWeight(AgentID sender) {
286 for (Issue issue : issues) {
287 if (issue.getType().toString().equals("INTEGER")) {
288 ValueInteger currIssueValueInteger = (ValueInteger) lastOpponentBid
289 .getValue(issue.getNumber());
290 oppIssueIntegerValue.get(sender).get(issue)
291 .add(currIssueValueInteger);
292 }
293 }
294 if (rounds == 10 && !updatedValueIntegerWeight) { // rounds = [0, 10]
295 // meant 11 value
296 // points
297 int sumLower;
298 int sumUpper;
299 for (Object o1 : oppIssueIntegerValue.keySet()) {
300 for (Issue issue : issues) {
301 if (issue.getType().toString().equals("INTEGER")) {
302 sumLower = 0;
303 sumUpper = 0;
304 int lowerB = ((IssueInteger) issue).getLowerBound();
305 int upperB = ((IssueInteger) issue).getUpperBound();
306 int mid = (lowerB + upperB) / 2;
307 double average = 1. / (upperB - lowerB);
308 double adjustment;
309
310 // Loop to retrieve sum of points which lie on upper or
311 // lower range
312 for (int i = 0; i < oppIssueIntegerValue.get(o1)
313 .get(issue).size(); i++) {
314 int vv = Integer.parseInt(oppIssueIntegerValue
315 .get(o1).get(issue).get(i).toString());
316 if (vv <= mid) {
317 sumLower += 1;
318 } else {
319 sumUpper += 1;
320 }
321 }
322 ValueInteger vL = new ValueInteger(lowerB);
323 ValueInteger vU = new ValueInteger(upperB);
324
325 if (sumLower > sumUpper) {
326 oppValueFrequency.get(o1).get(issue).put(vL, 1.);
327 oppValueFrequency.get(o1).get(issue).put(vU, 0.);
328
329 adjustment = 1.;
330 // for loop assigning values between
331 // lowerbound(exclusive) and upperbound(exclusive)
332 for (int i = lowerB + 1; i < upperB; i++) {
333 adjustment -= average;
334 ValueInteger vI = new ValueInteger(i);
335 oppValueFrequency.get(o1).get(issue).put(vI,
336 adjustment);
337 }
338 } else {
339 oppValueFrequency.get(o1).get(issue).put(vU, 1.);
340 oppValueFrequency.get(o1).get(issue).put(vL, 0.);
341
342 adjustment = 0.;
343 // for loop assigning values between
344 // lowerbound(exclusive) and upperbound(exclusive)
345 for (int i = lowerB + 1; i < upperB; i++) {
346 adjustment += average;
347 ValueInteger vI = new ValueInteger(i);
348 oppValueFrequency.get(o1).get(issue).put(vI,
349 adjustment);
350 }
351 }
352 }
353 }
354 }
355 updatedValueIntegerWeight = true;
356 }
357 }
358
359 private void updateModelOppIssueWeight(AgentID sender) {
360 if (oppBidHistory.get(sender).size() != 0 && rounds >= 10) {
361 Bid previousRoundBid = oppBidHistory.get(sender)
362 .get(oppBidHistory.get(sender).size() - 1);// -1
363 // since
364 // current
365 // lastOpponentBid
366 // not
367 // added
368 // yet
369 double issueWeightFormula = (Math.pow((1 - normalizedTime), 10))
370 / (issues.size() * 100);
371 double issueWeightInteger = (Math.pow((1 - normalizedTime), 10))
372 / (issues.size() * 10);
373 double issueSum = 0.;
374 double normalizedIssueW;
375
376 for (Issue issue : issues) {
377 Value prevIssueValue = previousRoundBid
378 .getValue(issue.getNumber());
379 Value currIssueValue = lastOpponentBid
380 .getValue(issue.getNumber());
381
382 if (issueContainIntegerType) { // For Discrete & Integer Mix
383 // Domain
384 if (issue.getType().toString().equals("INTEGER")) { // Integer
385 // Handling
386 if (incrementIntegerIssueWeight(issue, prevIssueValue,
387 currIssueValue)) {
388 oppIssueWeight.get(sender).put(issue,
389 oppIssueWeight.get(sender).get(issue)
390 + issueWeightInteger);
391 }
392 } else {// Discrete Handling
393 if (prevIssueValue == currIssueValue) {
394 oppIssueWeight.get(sender).put(issue,
395 oppIssueWeight.get(sender).get(issue)
396 + issueWeightInteger);
397 }
398 }
399 } else { // For Discrete Only Domain
400 if (prevIssueValue == currIssueValue) {
401 oppIssueWeight.get(sender).put(issue,
402 oppIssueWeight.get(sender).get(issue)
403 + issueWeightFormula);
404 }
405 }
406 issueSum += oppIssueWeight.get(sender).get(issue);
407 }
408
409 // After Sum computed, Normalized Issue Weight
410 for (Issue issue : issues) {
411 normalizedIssueW = oppIssueWeight.get(sender).get(issue)
412 / issueSum;
413 oppIssueWeight.get(sender).put(issue, normalizedIssueW);
414 }
415 }
416 }
417
418 public boolean incrementIntegerIssueWeight(Issue issue,
419 Value prevIssueValue, Value currIssueValue) {
420 double[] arraySlot = new double[5];
421 boolean sameSection = false;
422 double increment;// Store
423 int pastV = Integer.parseInt(prevIssueValue.toString()); // past bid
424 // value
425 int currV = Integer.parseInt(currIssueValue.toString()); // current bid
426 // value
427 int lowerB = ((IssueInteger) issue).getLowerBound();
428 int upperB = ((IssueInteger) issue).getUpperBound();
429 double formula = (upperB - lowerB + 1) / 5;
430
431 increment = lowerB + formula;
432
433 for (int i = 0; i < 4; i++) {
434 arraySlot[i] = increment;
435 increment += formula;
436 }
437 arraySlot[4] = upperB;
438
439 if (pastV <= arraySlot[0] && currV <= arraySlot[0]) {
440 sameSection = true;
441 } else if (pastV <= arraySlot[1] && currV <= arraySlot[1]
442 && pastV > arraySlot[0] && currV > arraySlot[0]) {
443 sameSection = true;
444 } else if (pastV <= arraySlot[2] && currV <= arraySlot[2]
445 && pastV > arraySlot[1] && currV > arraySlot[1]) {
446 sameSection = true;
447 } else if (pastV <= arraySlot[3] && currV <= arraySlot[3]
448 && pastV > arraySlot[2] && currV > arraySlot[2]) {
449 sameSection = true;
450 } else if (pastV <= arraySlot[4] && currV <= arraySlot[4]
451 && pastV > arraySlot[3] && currV > arraySlot[3]) {
452 sameSection = true;
453 }
454 return sameSection;
455 }
456
457 private void updateModelOppValueWeight(AgentID sender) {
458 double maxValueBase;
459 double currValueBase;
460 double normalizedValue;
461 double valueWeightFormula = Math.pow(0.2, normalizedTime) / 30000;
462 double valueWeightInteger = Math.pow(0.2, normalizedTime) / 955;
463 // (Normal Rounds avg - 11000 rounds, Integer issue type round avg - 350
464 // rounds)
465
466 for (Issue issue : issues) {
467 if (issueContainIntegerType) { // For Discrete & Integer Mix Domain
468 if (!issue.getType().toString().equals("INTEGER")) {
469 Value value = lastOpponentBid.getValue(issue.getNumber());
470 oppValueFrequency.get(sender).get(issue).put(value,
471 oppValueFrequency.get(sender).get(issue).get(value)
472 + valueWeightInteger);
473 }
474
475 } else { // For Discrete Only Domain
476 Value value = lastOpponentBid.getValue(issue.getNumber());
477 oppValueFrequency.get(sender).get(issue).put(value,
478 oppValueFrequency.get(sender).get(issue).get(value)
479 + valueWeightFormula);
480 }
481 }
482
483 // Normalization of Value Weight
484 for (Issue issue : issues) {
485 if (!issue.getType().toString().equals("INTEGER")) {
486 maxValueBase = 0;
487
488 // Compute Max Value for specific issue
489 for (Value v : oppValueFrequency.get(sender).get(issue)
490 .keySet()) {
491 currValueBase = oppValueFrequency.get(sender).get(issue)
492 .get(v);
493 if (currValueBase > maxValueBase) {
494 maxValueBase = currValueBase;
495 }
496 }
497
498 // After Max Value computed, Normalized Value Weight
499 for (Value v : oppValueFrequency.get(sender).get(issue)
500 .keySet()) {
501 normalizedValue = oppValueFrequency.get(sender).get(issue)
502 .get(v) / maxValueBase;
503 oppValueFrequency.get(sender).get(issue).put(v,
504 normalizedValue);
505 }
506 }
507 }
508 }
509
510 private void retrieveToughestOpp() {
511 double sumDiff;
512 double maxDiff;
513 double diff;
514 double hardestOppSumDiff = 0.;
515
516 // Compute SumDiff of each opponent using value weight
517 for (Object o : oppValueFrequency.keySet()) {
518 sumDiff = 0;
519 for (Issue issue : issues) {
520 maxDiff = 0;
521 for (Value v : oppValueFrequency.get(o).get(issue).keySet()) {
522 if (!issue.getType().toString().equals("INTEGER")) { // Exclusive
523 // of
524 // Integer
525 // Type
526 // Issues
527 diff = 1 - oppValueFrequency.get(o).get(issue).get(v);
528 if (diff > maxDiff) {
529 maxDiff = diff;
530 }
531 }
532 }
533 sumDiff += maxDiff;
534 }
535 oppSumDiff.put(o, sumDiff); // Store opponent with sumDiff
536 }
537
538 // Retrieve Toughest Opponent
539 for (Object o : oppSumDiff.keySet()) {
540 if (oppSumDiff.get(o) > hardestOppSumDiff) {
541 hardestOppSumDiff = oppSumDiff.get(o);
542 hardestOpp = o; // Update hardest opponent
543 }
544 }
545 }
546
547 /*
548 * private void printableWeight(){ PrintWriter aout = null; try { aout = new
549 * PrintWriter(new FileWriter("negotiationWeight")); } catch (IOException
550 * e1) { e1.printStackTrace(); }
551 *
552 * StringBuilder rez;
553 *
554 * for (Object a1 : oppIssueWeight.keySet()){ rez = new StringBuilder() ;
555 * rez.append(a1); rez.append("|"); rez.append(oppIssueWeight.get(a1));
556 * rez.append("|"); rez.append("\n"); aout.println(rez.toString()); }
557 *
558 * rez = new StringBuilder(); rez.append("\n");
559 * rez.append("Number of rounds: " + rounds); aout.println(rez.toString());
560 * aout.close(); }
561 *
562 * private void printableValue(){ PrintWriter aout = null; try { aout = new
563 * PrintWriter(new FileWriter("negotiationValue")); } catch (IOException e1)
564 * { e1.printStackTrace(); }
565 *
566 * StringBuilder rez;
567 *
568 * for (Object a1 : oppValueFrequency.keySet()){ rez = new StringBuilder();
569 * rez.append(a1); rez.append("|"); rez.append(oppValueFrequency.get(a1));
570 * rez.append("|"); rez.append("\n"); aout.println(rez.toString()); }
571 *
572 * rez = new StringBuilder(); rez.append("\n");
573 * rez.append("Number of rounds: " + rounds); aout.println(rez.toString());
574 * aout.close(); }
575 *
576 * private void printableIntegerIssue(){ PrintWriter aout = null; try { aout
577 * = new PrintWriter(new FileWriter("negotiationIntegerIssue")); } catch
578 * (IOException e1) { e1.printStackTrace(); }
579 *
580 * StringBuilder rez;
581 *
582 * for (Object a1 : oppIssueIntegerValue.keySet()){ rez = new
583 * StringBuilder(); rez.append(a1); rez.append("|");
584 * rez.append(oppIssueIntegerValue.get(a1)); rez.append("|");
585 * rez.append("\n"); aout.println(rez.toString()); } aout.close(); }
586 *
587 * private void printableToughest(){ PrintWriter aout = null; try { aout =
588 * new PrintWriter(new FileWriter("negotiationHardestOpp")); } catch
589 * (IOException e1) { e1.printStackTrace(); }
590 *
591 * StringBuilder rez;
592 *
593 * for (Object a1 : oppSumDiff.keySet()){ rez = new StringBuilder();
594 * rez.append(a1); rez.append("|"); rez.append(oppSumDiff.get(a1));
595 * rez.append("|"); rez.append("\n"); aout.println(rez.toString()); } rez =
596 * new StringBuilder(); rez.append("\n"); rez.append("Toughest Opp is: " +
597 * hardestOpp); aout.println(rez.toString());
598 *
599 * rez = new StringBuilder(); rez.append("\n");
600 * rez.append("Number of rounds: " + rounds); aout.println(rez.toString());
601 * aout.close(); }
602 */
603
604 // ---------------------------------------------------------------------------------------------------------//
605 // Initialize Opponent
606 private void initOpp(AgentID sender) {// Initialize new Agent and Issues
607 try {
608 issueIntegerHandler(sender);
609 initModelOppIssueWeight(sender);
610 initModelOppValueFrequency(sender);
611 oppBidHistory.put(sender, new ArrayList<Bid>());
612 } catch (Exception e) {
613 e.printStackTrace();
614 }
615 }
616
617 private void issueIntegerHandler(AgentID sender) {
618 oppIssueIntegerValue.put(sender,
619 new HashMap<Issue, ArrayList<ValueInteger>>());
620 for (Issue issue : issues) {
621 if (issue.getType().toString().equals("INTEGER")) {
622 oppIssueIntegerValue.get(sender).put(issue,
623 new ArrayList<ValueInteger>());
624 }
625 }
626 }
627
628 private void initModelOppIssueWeight(AgentID sender) {
629 int numIssues;
630 double avgW;
631 oppIssueWeight.put(sender, new HashMap<Issue, Double>());
632 for (Issue issue : issues) {
633 oppIssueWeight.get(sender).put(issue, 0.);
634 }
635
636 numIssues = oppIssueWeight.get(sender).keySet().size();
637 avgW = (double) 1 / numIssues;
638 for (Issue i : oppIssueWeight.get(sender).keySet()) {
639 oppIssueWeight.get(sender).put(i, avgW);
640 }
641 }
642
643 private void initModelOppValueFrequency(AgentID sender) {
644 ArrayList<Value> values = new ArrayList<Value>();
645 oppValueFrequency.put(sender,
646 new HashMap<Issue, HashMap<Value, Double>>());
647 for (Issue issue : issues) {
648 oppValueFrequency.get(sender).put(issue,
649 new HashMap<Value, Double>());
650 if (!issue.getType().toString().equals("INTEGER")) {
651 values = getValues(issue);
652 for (Value value : values) {
653 oppValueFrequency.get(sender).get(issue).put(value, 1.);
654 }
655 }
656 }
657 }
658
659 public ArrayList<Value> getValues(Issue issue) {
660 ArrayList<Value> values = new ArrayList<Value>();
661 switch (issue.getType()) {
662 case DISCRETE:
663 List<ValueDiscrete> valuesDis = ((IssueDiscrete) issue).getValues();
664 for (Value value : valuesDis) {
665 values.add(value);
666 }
667 break;
668 case INTEGER:
669 int min_value = ((IssueInteger) issue).getLowerBound();
670 int max_value = ((IssueInteger) issue).getUpperBound();
671 for (int i = min_value; i <= max_value; i++) {
672 Object valueObject = new Integer(i);
673 values.add((Value) valueObject);
674 }
675 break;
676 case REAL:
677 double min_value1 = ((IssueReal) issue).getLowerBound();
678 double max_value1 = ((IssueReal) issue).getUpperBound();
679 for (int i = (int) min_value1; i <= max_value1; i++) {
680 Object valueObject = new Integer(i);
681 values.add((Value) valueObject);
682 }
683 break;
684 default:
685 try {
686 throw new Exception("issue type: " + issue.getType());
687 } catch (Exception e) {
688 e.printStackTrace();
689 }
690 }
691 return values;
692 }
693
694 // ---------------------------------------------------------------------------------------------------------//
695 // Check for Integer Type in Issue
696 private void issueContainIntegerType() {
697 for (Issue issue : issues) {
698 if (issue.getType().toString().equals("INTEGER")) {
699 issueContainIntegerType = true;
700 break;
701 }
702 }
703 }
704
705 // ---------------------------------------------------------------------------------------------------------//
706 // Initialize and Update Time
707 private void updateTime() {
708 currTime = System.currentTimeMillis();
709 diff = currTime - startTime;
710 normalizedTime = (long) (diff / totalTime);
711 }
712
713 private void initTime() {
714 startTime = System.currentTimeMillis();
715 totalTime = 3 * 60 * 1000; // 3min total time converted to millsecond
716 diff = 0;
717 }
718
719 // ---------------------------------------------------------------------------------------------------------//
720 // Generate Random Bid
721 @Override
722 protected Bid generateRandomBid() {
723 Bid randomBid = null;
724 HashMap<Integer, Value> values = new HashMap<Integer, Value>();
725 List<Issue> issues = utilitySpace.getDomain().getIssues();
726 for (Issue currentIssue : issues) {
727 try {
728 values.put(currentIssue.getNumber(),
729 getRandomValue(currentIssue));
730 } catch (Exception e) {
731 e.printStackTrace();
732 }
733 }
734 try {
735 randomBid = new Bid(utilitySpace.getDomain(), values);
736 } catch (Exception e) {
737 e.printStackTrace();
738 }
739 return randomBid;
740 }
741
742 @Override
743 protected Value getRandomValue(Issue currentIssue) throws Exception {
744 Value currentValue = null;
745 int index = 0;
746
747 Random randomnr = new Random();
748 switch (currentIssue.getType()) {
749 case DISCRETE:
750 IssueDiscrete lIssueDiscrete = (IssueDiscrete) currentIssue;
751 index = randomnr.nextInt(lIssueDiscrete.getNumberOfValues());
752 currentValue = lIssueDiscrete.getValue(index);
753 break;
754 case REAL:
755 IssueReal lIssueReal = (IssueReal) currentIssue;
756 index = randomnr
757 .nextInt(lIssueReal.getNumberOfDiscretizationSteps());
758 currentValue = new ValueReal(
759 lIssueReal.getLowerBound() + (((lIssueReal.getUpperBound()
760 - lIssueReal.getLowerBound()))
761 / (lIssueReal.getNumberOfDiscretizationSteps()))
762 * index);
763 break;
764 case INTEGER:
765 IssueInteger lIssueInteger = (IssueInteger) currentIssue;
766 index = randomnr.nextInt(lIssueInteger.getUpperBound()
767 - lIssueInteger.getLowerBound() + 1);
768 currentValue = new ValueInteger(
769 lIssueInteger.getLowerBound() + index);
770 break;
771 default:
772 throw new Exception(
773 "issue type " + currentIssue.getType() + " not supported");
774 }
775 return currentValue;
776 }
777
778 /**
779 * @return the agentID
780 */
781 public String getName() {
782 return "YXAgent";
783 }
784
785 @Override
786 public String getDescription() {
787 return "ANAC2016";
788 }
789
790}
Note: See TracBrowser for help on using the repository browser.