source: src/main/java/agents/anac/y2015/cuhkagent2015/CUHKAgent2015.java@ 1

Last change on this file since 1 was 1, checked in by Wouter Pasman, 6 years ago

Initial import : Genius 9.0.0
File size: 64.0 KB
Line 
1package agents.anac.y2015.cuhkagent2015;
2
3import java.io.FileNotFoundException;
4import java.io.FileOutputStream;
5import java.io.PrintStream;
6import java.util.ArrayList;
7import java.util.HashMap;
8import java.util.Iterator;
9import java.util.List;
10import java.util.Random;
11
12import genius.core.AgentID;
13import genius.core.Bid;
14import genius.core.BidIterator;
15import genius.core.actions.Accept;
16import genius.core.actions.Action;
17import genius.core.actions.ActionWithBid;
18import genius.core.actions.EndNegotiation;
19import genius.core.actions.Offer;
20import genius.core.issue.Issue;
21import genius.core.issue.IssueDiscrete;
22import genius.core.issue.IssueInteger;
23import genius.core.issue.IssueReal;
24import genius.core.issue.Value;
25import genius.core.issue.ValueDiscrete;
26import genius.core.issue.ValueInteger;
27import genius.core.issue.ValueReal;
28import genius.core.parties.AbstractNegotiationParty;
29import genius.core.parties.NegotiationInfo;
30import genius.core.utility.AdditiveUtilitySpace;
31
32/**
33 *
34 * @author Tom
35 */
36public class CUHKAgent2015 extends AbstractNegotiationParty {
37 boolean debug = false;
38
39 private final double totalTime = 180;
40 // private Action ActionOfOpponent = null;
41 private double maximumOfBid;
42 private OwnBidHistory ownBidHistory;
43 private OpponentBidHistory opponentBidHistory1;
44 private OpponentBidHistory opponentBidHistory2;
45 private double minimumUtilityThreshold;
46 private double AvgUtilitythreshold;
47 private double AvgConcedeTime;
48 private double MaximumUtility;
49 private int limit;// the maximimum number of trials for each searching range
50 private double numberOfRounds;
51 private double timeLeftBefore;
52 private double timeLeftAfter;
53 private double maximumTimeOfOpponent;
54 private double maximumTimeOfOwn;
55 private double discountingFactor;
56 private double concedeToDiscountingFactor;
57 private double concedeToDiscountingFactor_original;
58 private double minConcedeToDiscountingFactor;
59 private ArrayList<ArrayList<Bid>> bidsBetweenUtility;
60 private double previousToughnessDegree;
61 private boolean concedeToOpponent;
62 private boolean toughAgent; // if we propose a bid that was proposed by the
63 // opponnet, then it should be accepted.
64 private double alpha1;// the larger alpha is, the more tough the agent is.
65 private Bid bid_maximum_utility;// the bid with the maximum utility over the
66 // utility space.
67 private double reservationValue;
68
69 /* UpdateConcede function's Constant */
70 private double k = 1;
71 private double N = 0;
72 private int FirstTimeInterval;
73 private int SecondTimeInterval;
74 private int ThirdTimeInterval;
75
76 /* Agent 1 Analysis */
77 private double utility_maximum_from_opponent_Session1_Agent1 = 0;
78 private double utility_maximum_from_opponent_Session2_Agent1 = 0;
79 private double utility_maximum_from_opponent_Session3_Agent1 = 0;
80 private double count_Agent1 = -1;
81 private double concedePartOfdiscountingFactor_Agent1 = 0;
82 private double concedePartOfOppBehaviour_Agent1 = 0;
83 private double minThreshold_Agent1;
84 private double oppFirstBidUtility_Agent1;
85 private Bid oppFirstBid_Agent1;
86 private double relstdevUtility_Agent1;
87 private boolean startConcede_Agent1 = false;
88 private double relcountUpperBoundMid1_Agent1;
89 private double relcountLowerBoundMid1_Agent1;
90 private double relcountUpperBoundMid2_Agent1;
91 private double relcountLowerBoundMid2_Agent1;
92 private double relsumUtility_Agent1 = 0;
93 private double relcountUtility_Agent1 = 0;
94 private double relavgUtility_Agent1 = 0;
95 private double relSqRootOfAvgUtility_Agent1 = 0;
96 private double relcountUtilityInSmallSD_Agent1 = 0;
97 private double utility_FirstMaximum_Agent1 = 0;
98 private double utility_SecondMaximum_Agent1 = 0;
99 private double midPointOfSlopeSessionMax1_Agent1 = 0;
100 private double midPointOfSlopeSessionMax2_Agent1 = 0;
101 private double slopeOfSlopeOfSessionMax1_Agent1 = 0;
102 private double slopeOfSlopeOfSessionMax2_Agent1 = 0;
103 private boolean IsOppFirstBid_Agent1;
104 private Bid oppPreviousBid_Agent1;
105 private Bid minAcceptableBid;
106 private double opponentFirstBidUtility_Agent;
107 private double concedeTime_Agent1;
108 private double MinimumUtility_Agent1;
109 private double utilitythreshold_Agent1;
110
111 /* Agent 2 Analysis */
112 private double utility_maximum_from_opponent_Session1_Agent2 = 0;
113 private double utility_maximum_from_opponent_Session2_Agent2 = 0;
114 private double utility_maximum_from_opponent_Session3_Agent2 = 0;
115 private double count_Agent2 = -1;
116 private double concedePartOfdiscountingFactor_Agent2 = 0;
117 private double concedePartOfOppBehaviour_Agent2 = 0;
118 private double minThreshold_Agent2;
119 private Bid oppFirstBid_Agent2;
120 private double oppFirstBidUtility_Agent2;
121 private double relstdevUtility_Agent2;
122 private boolean startConcede_Agent2 = false;
123 private double relcountUpperBoundMid1_Agent2;
124 private double relcountLowerBoundMid1_Agent2;
125 private double relcountUpperBoundMid2_Agent2;
126 private double relcountLowerBoundMid2_Agent2;
127 private double relsumUtility_Agent2 = 0;
128 private double relcountUtility_Agent2 = 0;
129 private double relavgUtility_Agent2 = 0;
130 private double relSqRootOfAvgUtility_Agent2 = 0;
131 private double relcountUtilityInSmallSD_Agent2 = 0;
132 private double utility_FirstMaximum_Agent2 = 0;
133 private double utility_SecondMaximum_Agent2 = 0;
134 private double midPointOfSlopeSessionMax1_Agent2 = 0;
135 private double midPointOfSlopeSessionMax2_Agent2 = 0;
136 private double slopeOfSlopeOfSessionMax1_Agent2 = 0;
137 private double slopeOfSlopeOfSessionMax2_Agent2 = 0;
138 private boolean IsOppFirstBid_Agent2;
139 private Bid oppPreviousBid_Agent2;
140 private double concedeTime_Agent2;
141 private double MinimumUtility_Agent2;
142 private double utilitythreshold_Agent2;
143
144 private double MinimumUtility;
145 private AgentID partyId;
146 private final double domainthreshold = 2000;
147 private final double totaltime = 180;
148 private Action ActionOfOpponent = null;
149 private double NumberOfBid;
150 private final int NumberofDivisions = 20;
151 private double SpacebetweenDivisions;
152 private int CurrentrangeNumber;
153 private int maximumOfRound;
154 private final int limitValue = 5;// 10;
155 private double delta; // searching range
156 private double concedeTime_original;
157 private double minConcedeTime;
158 private List<Issue> Issues;
159 private Bid bid_minimum_utility;// the bid with the minimum utility over the
160 // utility space.
161 private Bid mylastBid = this.bid_maximum_utility;
162 private ArrayList<Bid> OppBids1;
163 private ArrayList<Bid> OppBids2;
164 private int storingcapacity = 500;
165
166 private double nextbidutil;
167 private double mindistance;
168 private double averagedistance;
169 private int test = 0;
170 private int test2 = 0;
171 private int test3 = 0;
172 private int except = 0;
173 private int size;
174 private double minUtilityUhreshold = 1.1;
175 private double oppbid;
176 private int countOpp;
177 private int EachRoundCount;
178 private Bid myLastBid;
179
180 PrintStream file, SysOut;
181 String fileName;
182
183 @Override
184 public void init(NegotiationInfo info) {
185 super.init(info);
186 try {
187 this.NumberOfBid = this.utilitySpace.getDomain()
188 .getNumberOfPossibleBids();
189 this.ownBidHistory = new OwnBidHistory();
190 this.opponentBidHistory1 = new OpponentBidHistory();
191 this.opponentBidHistory2 = new OpponentBidHistory();
192 this.Issues = this.utilitySpace.getDomain().getIssues();
193 this.bidsBetweenUtility = new ArrayList<ArrayList<Bid>>();
194 this.OppBids1 = new ArrayList<Bid>();
195 this.OppBids2 = new ArrayList<Bid>();
196 for (int i = 0; i < this.storingcapacity; i++) {
197 this.OppBids1.add(i, null);
198 this.OppBids2.add(i, null);
199 }
200 this.bid_maximum_utility = this.utilitySpace.getMaxUtilityBid();
201 this.bid_minimum_utility = this.utilitySpace.getMinUtilityBid();
202 this.MaximumUtility = this.utilitySpace
203 .getUtility(this.bid_maximum_utility);
204 this.reservationValue = utilitySpace.getReservationValue();
205 this.MinimumUtility_Agent1 = this.reservationValue;
206 this.MinimumUtility_Agent2 = this.reservationValue;
207 this.delta = 0.01; // searching range
208 this.limit = 10;
209 this.previousToughnessDegree = 0;
210 this.numberOfRounds = 0;
211 this.timeLeftAfter = 0;
212 this.timeLeftBefore = 0;
213 this.maximumTimeOfOpponent = 0;
214 this.maximumTimeOfOwn = 0;
215 this.minConcedeTime = 0.08;// 0.1;
216 this.discountingFactor = 1;
217 if (utilitySpace.getDiscountFactor() <= 1D
218 && utilitySpace.getDiscountFactor() > 0D) {
219 this.discountingFactor = utilitySpace.getDiscountFactor();
220 }
221 this.calculateBidsBetweenUtility();
222 if (this.discountingFactor <= 0.5D) {
223 this.chooseConcedeToDiscountingDegree();
224 }
225 if (debug) {
226 fileName = "plotData" + hashCode() + ".txt";
227 file = new PrintStream(new FileOutputStream(fileName, false));
228 file.println("\n");
229 }
230 this.opponentBidHistory1
231 .initializeDataStructures(utilitySpace.getDomain());
232 this.opponentBidHistory2
233 .initializeDataStructures(utilitySpace.getDomain());
234 this.timeLeftAfter = timeline.getCurrentTime();
235 this.concedeToOpponent = false;
236 this.toughAgent = false;
237 this.alpha1 = 2;
238
239 if (this.NumberOfBid < 100) {
240 this.k = 1;
241 } else if (this.NumberOfBid < 1000) {
242 this.k = 2;
243 } else if (this.NumberOfBid < 10000) {
244 this.k = 3;
245 } else {
246 this.k = 4;
247 }
248 this.concedeTime_Agent1 = 0.5;
249 this.concedeTime_Agent2 = 0.5;
250 this.oppFirstBid_Agent1 = null;
251 this.oppFirstBidUtility_Agent1 = 0;
252 this.oppFirstBid_Agent2 = null;
253 this.oppFirstBidUtility_Agent2 = 0;
254 this.IsOppFirstBid_Agent1 = true;
255 this.IsOppFirstBid_Agent2 = true;
256 this.FirstTimeInterval = 20;
257 this.SecondTimeInterval = 40;
258 this.ThirdTimeInterval = 60;
259 this.utilitythreshold_Agent1 = 0.5;
260 this.utilitythreshold_Agent2 = 0.5;
261 this.AvgUtilitythreshold = 0.5;
262 this.AvgConcedeTime = 0.5;
263 this.EachRoundCount = 0;
264 this.myLastBid = this.bid_maximum_utility;
265 } catch (Exception e) {
266 System.out.println("initialization error" + e.getMessage());
267 }
268 }
269
270 public String getVersion() {
271 return "CUHKAgent2015";
272 }
273
274 public String getName() {
275 return "CUHKAgent2015 Test Temp";
276 }
277
278 @Override
279 public Action chooseAction(List<Class<? extends Action>> possibleActions) {
280 Action action = null;
281 this.EachRoundCount = this.countOpp;
282 try {
283 // System.out.println("i propose " + debug + " bid at time " +
284 // timeline.getTime());
285 this.timeLeftBefore = timeline.getCurrentTime();
286 Bid bid = null;
287 // we propose first and propose the bid with maximum utility
288 if ((!possibleActions.contains(Accept.class))
289 || (this.oppFirstBid_Agent1 == null)
290 || (this.oppFirstBid_Agent2 == null)) {
291 bid = this.bid_maximum_utility;
292 action = new Offer(getPartyId(), bid);
293 }
294 // else if (ActionOfOpponent instanceof Offer)
295 else {
296 // the opponent propose first and we response secondly
297 // update opponent model first
298 this.opponentBidHistory1.updateOpponentModel(
299 this.oppPreviousBid_Agent1, utilitySpace.getDomain(),
300 (AdditiveUtilitySpace) this.utilitySpace);
301 this.opponentBidHistory2.updateOpponentModel(
302 this.oppPreviousBid_Agent2, utilitySpace.getDomain(),
303 (AdditiveUtilitySpace) this.utilitySpace);
304 if (this.discountingFactor == 1) {
305 this.updateConcedeDegree_nonDiscountingFactor_Agent1();
306 this.updateConcedeDegree_nonDiscountingFactor_Agent2();
307 } else if (this.discountingFactor <= 0.5) {
308 this.updateConcedeDegree_smallDiscountingFactor();
309 } else {
310 this.updateConcedeDegree_largeDiscountingFactor_Agent1();
311 this.updateConcedeDegree_largeDiscountingFactor_Agent2();
312 }
313 // update the estimation
314 if (ownBidHistory.numOfBidsProposed() == 0) {
315 bid = this.bid_maximum_utility;
316 action = new Offer(getPartyId(), bid);
317 } else { // other conditions
318 if (estimateRoundLeft(true) > 10) {
319 // still have some rounds left to further negotiate (the
320 // major negotiation period)
321 bid = BidToOffer_original();
322 Boolean IsAccept = AcceptOpponentOffer(
323 this.oppPreviousBid_Agent2, bid);
324 IsAccept = OtherAcceptCondition(IsAccept);
325
326 Boolean IsTerminate = TerminateCurrentNegotiation(bid);
327 if (IsAccept && !IsTerminate) {
328 action = new Accept(getPartyId(),
329 ((ActionWithBid) getLastReceivedAction())
330 .getBid());
331 System.out.println("accept the offer");
332 } else if (IsTerminate && !IsAccept) {
333 action = new EndNegotiation(getPartyId());
334 System.out.println(
335 "we determine to terminate the negotiation");
336 } else if (IsAccept && IsTerminate) {
337 if (this.utilitySpace.getUtility(
338 this.oppPreviousBid_Agent2) > this.reservationValue) {
339 action = new Accept(getPartyId(),
340 ((ActionWithBid) getLastReceivedAction())
341 .getBid());
342 System.out.println(
343 "we accept the offer RANDOMLY");
344 } else {
345 action = new EndNegotiation(getPartyId());
346 System.out.println(
347 "we determine to terminate the negotiation RANDOMLY");
348 }
349 } else {
350 // we expect that the negotiation is over once we
351 // select a bid from the opponent's history.
352 if (this.concedeToOpponent == true) {
353 // bid =
354 // opponentBidHistory.chooseBestFromHistory(this.utilitySpace);
355 Bid bid1 = opponentBidHistory1
356 .getBestBidInHistory();
357 Bid bid2 = opponentBidHistory2
358 .getBestBidInHistory();
359 if (this.utilitySpace
360 .getUtility(bid1) > this.utilitySpace
361 .getUtility(bid2)) {
362 bid = bid2;
363 } else if (this.utilitySpace
364 .getUtility(bid1) == this.utilitySpace
365 .getUtility(bid2)
366 && Math.random() < 0.5) {
367 bid = bid2;
368 } else {
369 bid = bid1;
370 }
371 action = new Offer(getPartyId(), bid);
372 // System.out.println("we offer the best bid in
373 // the history and the opponent should accept
374 // it");
375 this.toughAgent = true;
376 this.concedeToOpponent = false;
377 } else {
378 action = new Offer(getPartyId(), bid);
379 this.toughAgent = false;
380 // System.out.println("i propose " + debug +
381 // " bid at time " + timeline.getTime());
382 }
383 }
384 } else {// this is the last chance and we concede by
385 // providing the opponent the best offer he ever
386 // proposed to us
387 // in this case, it corresponds to an opponent whose
388 // decision time is short
389
390 if (timeline.getTime() > 0.9985
391 && estimateRoundLeft(true) < 5) {
392 bid = BidToOffer_original();
393
394 Boolean IsAccept = AcceptOpponentOffer(
395 this.oppPreviousBid_Agent2, bid);
396 IsAccept = OtherAcceptCondition(IsAccept);
397
398 Boolean IsTerminate = TerminateCurrentNegotiation(
399 bid);
400 if (IsAccept && !IsTerminate) {
401 action = new Accept(getPartyId(),
402 ((ActionWithBid) getLastReceivedAction())
403 .getBid());
404 System.out.println("accept the offer");
405 } else if (IsTerminate && !IsAccept) {
406 action = new EndNegotiation(getPartyId());
407 System.out.println(
408 "we determine to terminate the negotiation");
409 } else if (IsTerminate && IsAccept) {
410 if (this.utilitySpace.getUtility(
411 this.oppPreviousBid_Agent2) > this.reservationValue) {
412 action = new Accept(getPartyId(),
413 ((ActionWithBid) getLastReceivedAction())
414 .getBid());
415 System.out.println(
416 "we accept the offer RANDOMLY");
417 } else {
418 action = new EndNegotiation(getPartyId());
419 System.out.println(
420 "we determine to terminate the negotiation RANDOMLY");
421 }
422 } else {
423 if (this.toughAgent == true) {
424 action = new Accept(getPartyId(),
425 ((ActionWithBid) getLastReceivedAction())
426 .getBid());
427 System.out.println(
428 "the opponent is tough and the deadline is approching thus we accept the offer");
429 } else {
430 action = new Offer(getPartyId(), bid);
431 // this.toughAgent = true;
432 System.out.println(
433 "this is really the last chance"
434 + bid.toString()
435 + " with utility of "
436 + utilitySpace
437 .getUtility(bid));
438 }
439 }
440 // in this case, it corresponds to the situation
441 // that we encounter an opponent who needs more
442 // computation to make decision each round
443 } else {// we still have some time to negotiate,
444 // and be tough by sticking with the lowest one
445 // in previous offer history.
446 // we also have to make the decisin fast to
447 // avoid reaching the deadline before the
448 // decision is made
449 // bid =
450 // ownBidHistory.GetMinBidInHistory();//reduce
451 // the computational cost
452 bid = BidToOffer_original();
453 // System.out.println("test----------------------------------------------------------"
454 // + timeline.getTime());
455 Boolean IsAccept = AcceptOpponentOffer(
456 this.oppPreviousBid_Agent2, bid);
457 IsAccept = OtherAcceptCondition(IsAccept);
458
459 Boolean IsTerminate = TerminateCurrentNegotiation(
460 bid);
461 if (IsAccept && !IsTerminate) {
462 action = new Accept(getPartyId(),
463 ((ActionWithBid) getLastReceivedAction())
464 .getBid());
465 System.out.println("accept the offer");
466 } else if (IsTerminate && !IsAccept) {
467 action = new EndNegotiation(getPartyId());
468 System.out.println(
469 "we determine to terminate the negotiation");
470 } else if (IsAccept && IsTerminate) {
471 if (this.utilitySpace.getUtility(
472 this.oppPreviousBid_Agent2) > this.reservationValue) {
473 action = new Accept(getPartyId(),
474 ((ActionWithBid) getLastReceivedAction())
475 .getBid());
476 System.out.println(
477 "we accept the offer RANDOMLY");
478 } else {
479 action = new EndNegotiation(getPartyId());
480 System.out.println(
481 "we determine to terminate the negotiation RANDOMLY");
482 }
483 } else {
484 action = new Offer(getPartyId(), bid);
485 // System.out.println("we have to be tough now"
486 // + bid.toString() + " with utility of " +
487 // utilitySpace.getUtility(bid));
488 }
489 }
490 }
491 }
492 }
493 this.myLastBid = bid;
494 // System.out.println("i propose " + debug + " bid at time " +
495 // timeline.getTime());
496 this.ownBidHistory.addBid(bid, (AdditiveUtilitySpace) utilitySpace);
497 this.timeLeftAfter = timeline.getCurrentTime();
498 if (this.timeLeftAfter
499 - this.timeLeftBefore > this.maximumTimeOfOwn) {
500 this.maximumTimeOfOwn = this.timeLeftAfter
501 - this.timeLeftBefore;
502 } // update the estimation
503 // System.out.println(this.utilitythreshold + "-***-----" +
504 // this.timeline.getElapsedSeconds());
505 if (debug) {
506 try {
507 SysOut = System.out;
508 file = new PrintStream(
509 new FileOutputStream(fileName, true));
510 System.setOut(file);
511 } catch (FileNotFoundException ex) {
512
513 }
514 System.out.println(Double.toString(this.timeline.getTime())
515 + "," + Double.toString(this.AvgUtilitythreshold) + ","
516 + Double.toString(this.minUtilityUhreshold));
517 System.setOut(SysOut);
518 }
519 } catch (Exception e) {
520 System.out.println("Exception in ChooseAction:" + e.getMessage());
521 System.out.println(estimateRoundLeft(false));
522 action = new EndNegotiation(getPartyId()); // terminate if anything
523 // goes wrong.
524 }
525 return action;
526 }
527
528 @Override
529 public void receiveMessage(AgentID sender, Action opponentAction) {
530 super.receiveMessage(sender, opponentAction);
531 // sender.getClass().getName();
532 this.ActionOfOpponent = opponentAction;
533
534 this.countOpp = this.countOpp + 1;
535 if (this.countOpp == this.EachRoundCount + 1)// Next Agent w.r.t. us
536 {
537 if ((this.ActionOfOpponent instanceof Offer)) {
538 if (this.oppFirstBid_Agent1 == null) {
539 oppFirstBid_Agent1 = ((Offer) this.ActionOfOpponent)
540 .getBid();
541 }
542 for (int i = 0; i < this.storingcapacity - 1; i++) {
543 this.OppBids1.set(i, this.OppBids1.get(i + 1));
544 }
545 this.oppPreviousBid_Agent1 = ((Offer) this.ActionOfOpponent)
546 .getBid();
547 this.OppBids1.set(this.storingcapacity - 1,
548 this.oppPreviousBid_Agent1);
549 } else if ((this.ActionOfOpponent instanceof Accept)) {
550 this.oppPreviousBid_Agent1 = this.myLastBid;
551 }
552 } else if (this.countOpp == this.EachRoundCount + 2)// Previous Agent
553 // w.r.t. us
554 {
555 if ((this.ActionOfOpponent instanceof Offer)) {
556 if (this.oppFirstBid_Agent2 == null) {
557 oppFirstBid_Agent2 = ((Offer) this.ActionOfOpponent)
558 .getBid();
559 }
560 for (int i = 0; i < this.storingcapacity - 1; i++) {
561 this.OppBids2.set(i, this.OppBids2.get(i + 1));
562 }
563 this.oppPreviousBid_Agent2 = ((Offer) this.ActionOfOpponent)
564 .getBid();
565 this.OppBids2.set(this.storingcapacity - 1,
566 this.oppPreviousBid_Agent2);
567 } else if ((this.ActionOfOpponent instanceof Accept)) {
568 this.oppPreviousBid_Agent2 = this.oppPreviousBid_Agent1;
569 }
570 }
571 }
572
573 private double BidToOffer() {
574 try {
575
576 double maximumOfBid = this.MaximumUtility;// utilitySpace.getUtility(utilitySpace.getMaxUtilityBid());
577 AvgConcedeTime = (this.concedeTime_Agent2 + this.concedeTime_Agent1)
578 / 2;
579
580 if (timeline.getTime() <= AvgConcedeTime) {
581 if (this.discountingFactor <= 0.5) {
582 this.minThreshold_Agent1 = (maximumOfBid
583 * this.discountingFactor)
584 / Math.pow(this.discountingFactor,
585 this.concedeTime_Agent1);
586 this.minThreshold_Agent2 = (maximumOfBid
587 * this.discountingFactor)
588 / Math.pow(this.discountingFactor,
589 this.concedeTime_Agent2);
590 this.utilitythreshold_Agent1 = maximumOfBid
591 - (maximumOfBid - this.minThreshold_Agent1)
592 * Math.pow(
593 (timeline.getTime()
594 / this.concedeTime_Agent1),
595 alpha1);
596 this.utilitythreshold_Agent2 = maximumOfBid
597 - (maximumOfBid - this.minThreshold_Agent2)
598 * Math.pow(
599 (timeline.getTime()
600 / this.concedeTime_Agent2),
601 alpha1);
602 } else {
603 this.utilitythreshold_Agent1 = this.minThreshold_Agent1
604 + (maximumOfBid - this.minThreshold_Agent1) * (1
605 - Math.sin((Math.PI / 2) * (timeline
606 .getTime() / this.concedeTime_Agent1)));
607 this.utilitythreshold_Agent2 = this.minThreshold_Agent2
608 + (maximumOfBid - this.minThreshold_Agent2) * (1
609 - Math.sin((Math.PI / 2) * (timeline
610 .getTime() / this.concedeTime_Agent2)));
611 }
612 } else {
613 if (this.discountingFactor <= 0.5) {
614 this.utilitythreshold_Agent1 = (maximumOfBid
615 * this.discountingFactor)
616 / Math.pow(this.discountingFactor,
617 timeline.getTime());
618 this.utilitythreshold_Agent2 = (maximumOfBid
619 * this.discountingFactor)
620 / Math.pow(this.discountingFactor,
621 timeline.getTime());
622 } else {
623 this.utilitythreshold_Agent1 = this.minThreshold_Agent1
624 + (maximumOfBid - this.minThreshold_Agent1)
625 / (1 - concedeTime_Agent1)
626 * Math.pow(
627 (timeline.getTime()
628 - this.concedeTime_Agent1),
629 this.discountingFactor);
630 this.utilitythreshold_Agent2 = this.minThreshold_Agent2
631 + (maximumOfBid - this.minThreshold_Agent2)
632 / (1 - concedeTime_Agent2)
633 * Math.pow(
634 (timeline.getTime()
635 - this.concedeTime_Agent2),
636 this.discountingFactor);
637 }
638 }
639 this.AvgUtilitythreshold = (this.utilitythreshold_Agent2
640 + this.utilitythreshold_Agent1) / 2;
641
642 if (this.AvgUtilitythreshold > MaximumUtility) {
643 this.AvgUtilitythreshold = MaximumUtility;
644 }
645
646 boolean accept = false;
647 int count = 0;
648 while (!accept) {
649 // BidIterator myBidIterator = new
650 // BidIterator(this.utilitySpace.getDomain());
651 if (count < 2) {
652 for (double temputil = this.AvgUtilitythreshold; temputil <= this.MaximumUtility; temputil += 0.01) {
653 // Bid tempbid = myBidIterator.next();
654 // double temputil =
655 // this.utilitySpace.getUtility(tempbid);
656 double pchoose1 = (1 / this.relstdevUtility_Agent1
657 * (1 / Math.sqrt(2 * Math.PI)))
658 * Math.exp(-Math.pow(
659 temputil - this.relavgUtility_Agent1, 2)
660 / (2 * Math.pow(
661 this.relstdevUtility_Agent1,
662 2)));
663 double pchoose2 = (1 / this.relstdevUtility_Agent2
664 * (1 / Math.sqrt(2 * Math.PI)))
665 * Math.exp(-Math.pow(
666 temputil - this.relavgUtility_Agent2, 2)
667 / (2 * Math.pow(
668 this.relstdevUtility_Agent2,
669 2)));
670 double pchoose = (pchoose1 + pchoose2) / 2;
671 if (pchoose >= Math.random()/*
672 * && temputil >=
673 * this.utilitythreshold
674 */) {
675 return temputil;
676 }
677 }
678 } else {
679 return this.AvgUtilitythreshold;
680 }
681 count++;
682 }
683
684 } catch (Exception e) {
685 System.out
686 .println(e.getMessage() + "exception in method BidToOffer");
687 this.except = 4;
688 }
689 // System.out.println("the current threshold is " +
690 // this.utilitythreshold + " with the value of alpha1 is " + alpha1);
691 return 1.0;
692 }
693
694 /*
695 * decide whether to accept the current offer or not
696 */
697 private boolean AcceptOpponentOffer(Bid opponentBid, Bid ownBid) {
698 try {
699 double currentUtility = 0;
700 double nextRoundUtility = 0;
701 double maximumUtility = 0;
702 this.concedeToOpponent = false;
703 currentUtility = this.utilitySpace.getUtility(opponentBid);
704 maximumUtility = this.MaximumUtility;// utilitySpace.getUtility(utilitySpace.getMaxUtilityBid());
705 nextRoundUtility = this.utilitySpace.getUtility(ownBid);
706
707 // System.out.println(this.utilitythreshold +"at time "+
708 // timeline.getTime());
709 if (currentUtility >= this.AvgUtilitythreshold
710 || currentUtility >= nextRoundUtility) {
711 return true;
712 } else {
713 // if the current utility with discount is larger than the
714 // predicted maximum utility with discount
715 // then accept it.
716 double predictMaximumUtility = maximumUtility
717 * this.discountingFactor;
718 // double currentMaximumUtility =
719 // this.utilitySpace.getUtilityWithDiscount(opponentBidHistory.chooseBestFromHistory(utilitySpace),
720 // timeline);
721 double currentMaximumUtility1 = this.utilitySpace
722 .getUtilityWithDiscount(
723 opponentBidHistory1.getBestBidInHistory(),
724 timeline);
725 double currentMaximumUtility2 = this.utilitySpace
726 .getUtilityWithDiscount(
727 opponentBidHistory2.getBestBidInHistory(),
728 timeline);
729 double currentMaximumUtility = Math.min(currentMaximumUtility1,
730 currentMaximumUtility2);
731 if (currentMaximumUtility > predictMaximumUtility
732 && timeline.getTime() > this.AvgConcedeTime) {
733 try {
734 // if the current offer is approximately as good as the
735 // best one in the history, then accept it.
736 if (utilitySpace.getUtilityWithDiscount(opponentBid,
737 timeline) >= currentMaximumUtility - 0.01) {
738 System.out.println("he offered me "
739 + currentMaximumUtility
740 + " we predict we can get at most "
741 + predictMaximumUtility
742 + "we concede now to avoid lower payoff due to conflict");
743 return true;
744 } else {
745 this.concedeToOpponent = true;
746 return false;
747 }
748 } catch (Exception e) {
749 System.out.println(
750 "exception in Method AcceptOpponentOffer");
751 this.except = 7;
752 return true;
753 }
754 // retrieve the opponent's biding history and utilize it
755 } else if (currentMaximumUtility > this.AvgUtilitythreshold
756 * Math.pow(this.discountingFactor,
757 timeline.getTime())) {
758 try {
759 // if the current offer is approximately as good as the
760 // best one in the history, then accept it.
761 if (utilitySpace.getUtilityWithDiscount(opponentBid,
762 timeline) >= currentMaximumUtility - 0.01) {
763 return true;
764 } else {
765 System.out.println("test"
766 + utilitySpace.getUtility(opponentBid)
767 + this.AvgUtilitythreshold);
768 this.concedeToOpponent = true;
769 return false;
770 }
771 } catch (Exception e) {
772 System.out.println(
773 "exception in Method AcceptOpponentOffer");
774 this.except = 8;
775 return true;
776 }
777 } else {
778 return false;
779 }
780 }
781 } catch (Exception e) {
782 System.out.println("exception in Method AcceptOpponentOffer");
783 return true;
784 }
785
786 }
787
788 /*
789 * decide whether or not to terminate now
790 */
791 private boolean TerminateCurrentNegotiation(Bid ownBid) {
792 double currentUtility = 0;
793 double nextRoundUtility = 0;
794 double maximumUtility = 0;
795 this.concedeToOpponent = false;
796 try {
797 currentUtility = this.reservationValue;
798 nextRoundUtility = this.utilitySpace.getUtility(ownBid);
799 maximumUtility = this.MaximumUtility;
800
801 if (this.discountingFactor == 1 || this.reservationValue == 0) {
802 return false;
803 }
804
805 if (currentUtility >= nextRoundUtility) {
806 return true;
807 } else {
808 // if the current reseravation utility with discount is larger
809 // than the predicted maximum utility with discount
810 // then terminate the negotiation.
811 double predictMaximumUtility = maximumUtility
812 * this.discountingFactor;
813 double currentMaximumUtility = this.utilitySpace
814 .getReservationValueWithDiscount(timeline);
815 // System.out.println("the current reserved value is "+
816 // this.reservationValue+" after discounting is
817 // "+currentMaximumUtility);
818 if (currentMaximumUtility > predictMaximumUtility
819 && timeline.getTime() > this.AvgConcedeTime) {
820 return true;
821 } else {
822 return false;
823 }
824 }
825 } catch (Exception e) {
826 System.out.println(e.getMessage()
827 + "Exception in method TerminateCurrentNegotiation");
828 this.except = 9;
829 return true;
830 }
831 }
832
833 /*
834 * estimate the number of rounds left before reaching the deadline @param
835 * opponent @return
836 */
837 private int estimateRoundLeft(boolean opponent) {
838 double round;
839 try {
840 if (opponent == true) {
841 if (this.timeLeftBefore
842 - this.timeLeftAfter > this.maximumTimeOfOpponent) {
843 this.maximumTimeOfOpponent = this.timeLeftBefore
844 - this.timeLeftAfter;
845 }
846 } else {
847 if (this.timeLeftAfter
848 - this.timeLeftBefore > this.maximumTimeOfOwn) {
849 this.maximumTimeOfOwn = this.timeLeftAfter
850 - this.timeLeftBefore;
851 }
852 }
853 if (this.maximumTimeOfOpponent + this.maximumTimeOfOwn == 0) {
854 System.out.println("divided by zero exception");
855
856 this.except = 10;
857 }
858 round = (this.totalTime - timeline.getCurrentTime())
859 / (this.maximumTimeOfOpponent + this.maximumTimeOfOwn);
860 // System.out.println("current time is " +
861 // timeline.getElapsedSeconds() + "---" + round + "----" +
862 // this.maximumTimeOfOpponent);
863 } catch (Exception e) {
864 System.out.println(e.getMessage()
865 + "Exception in method TerminateCurrentNegotiation");
866 this.except = 9;
867 return 20;
868 }
869 return ((int) (round));
870 }
871
872 /*
873 * pre-processing to save the computational time each round
874 */
875 private void calculateBidsBetweenUtility() {
876 BidIterator myBidIterator = null;
877 myBidIterator = new BidIterator(this.utilitySpace.getDomain());
878 int counts[] = new int[this.NumberofDivisions];
879 try {
880 this.MinimumUtility = Math.min(this.MinimumUtility_Agent1,
881 this.MinimumUtility_Agent2);
882 this.SpacebetweenDivisions = (this.MaximumUtility
883 - this.MinimumUtility) / this.NumberofDivisions;
884 // initalization for each arraylist storing the bids between each
885 // range
886 for (int i = 0; i < this.NumberofDivisions; i++) {
887 ArrayList<Bid> BidList = null;
888 BidList = new ArrayList<Bid>();
889 // BidList.add(this.bid_maximum_utility);
890 this.bidsBetweenUtility.add(i, BidList);
891 }
892 this.bidsBetweenUtility.get(this.NumberofDivisions - 1).add(
893 counts[this.NumberofDivisions - 1],
894 this.bid_maximum_utility);
895 // note that here we may need to use some trick to reduce the
896 // computation cost (to be checked later);
897 // add those bids in each range into the corresponding arraylist
898 while (myBidIterator.hasNext()) {
899 Bid b = myBidIterator.next();
900 for (int i = 0; i < this.NumberofDivisions; i++) {
901 if (this.utilitySpace.getUtility(
902 b) <= (i + 1) * this.SpacebetweenDivisions
903 + this.MinimumUtility
904 && this.utilitySpace.getUtility(b) >= i
905 * this.SpacebetweenDivisions
906 + Math.min(this.MinimumUtility_Agent1,
907 this.MinimumUtility_Agent2)) {
908 this.bidsBetweenUtility.get(i).add(counts[i], b);
909 counts[i]++;
910 break;
911 }
912 }
913 }
914 } catch (Exception e) {
915 System.out.println("Exception in calculateBidsBetweenUtility()");
916 this.except = 11;
917 }
918 }
919
920 private Bid RandomSearchBid() throws Exception {
921 HashMap<Integer, Value> values = new HashMap<Integer, Value>();
922 List<Issue> issues = utilitySpace.getDomain().getIssues();
923 Bid bid = null;
924
925 for (Issue lIssue : issues) {
926 Random random = new Random();
927 switch (lIssue.getType()) {
928 case DISCRETE:
929 IssueDiscrete lIssueDiscrete = (IssueDiscrete) lIssue;
930 int optionIndex = random
931 .nextInt(lIssueDiscrete.getNumberOfValues());
932 values.put(lIssue.getNumber(),
933 lIssueDiscrete.getValue(optionIndex));
934 break;
935 case REAL:
936 IssueReal lIssueReal = (IssueReal) lIssue;
937 int optionInd = random.nextInt(
938 lIssueReal.getNumberOfDiscretizationSteps() - 1);
939 values.put(lIssueReal.getNumber(),
940 new ValueReal(lIssueReal.getLowerBound() + (lIssueReal
941 .getUpperBound() - lIssueReal.getLowerBound())
942 * (optionInd) / (lIssueReal
943 .getNumberOfDiscretizationSteps())));
944 break;
945 case INTEGER:
946 IssueInteger lIssueInteger = (IssueInteger) lIssue;
947 int optionIndex2 = lIssueInteger.getLowerBound()
948 + random.nextInt(lIssueInteger.getUpperBound()
949 - lIssueInteger.getLowerBound());
950 values.put(lIssueInteger.getNumber(),
951 new ValueInteger(optionIndex2));
952 break;
953 default:
954 this.except = 12;
955 throw new Exception(
956 "issue type " + lIssue.getType() + " not supported");
957 }
958 }
959 bid = new Bid(utilitySpace.getDomain(), values);
960 return bid;
961 }
962
963 /*
964 * Get all the bids within a given utility range.
965 */
966 private List<Bid> getBidsBetweenUtility(double lowerBound,
967 double upperBound) {
968 List<Bid> bidsInRange = new ArrayList<Bid>();
969 try {
970 int range = (int) ((upperBound - this.minimumUtilityThreshold)
971 / 0.01);
972 int initial = (int) ((lowerBound - this.minimumUtilityThreshold)
973 / 0.01);
974 // System.out.println(range+"---"+initial);
975 for (int i = initial; i < range; i++) {
976 bidsInRange.addAll(i, this.bidsBetweenUtility.get(i));
977 }
978 if (bidsInRange.isEmpty()) {
979 bidsInRange.add(range - 1, this.bid_maximum_utility);
980 }
981 } catch (Exception e) {
982 System.out.println("Exception in getBidsBetweenUtility");
983 this.except = 13;
984 e.printStackTrace();
985 }
986 return bidsInRange;
987 }
988
989 /*
990 * determine concede-to-time degree based on the discounting factor.
991 */
992 private void chooseConcedeToDiscountingDegree() {
993 try {
994 double alpha = 0;
995 double beta = 1.5;// 1.3;//this value controls the rate at which the
996 // agent concedes to the discouting factor.
997 // the larger beta is, the more the agent makes concesions.
998 // if (utilitySpace.getDomain().getNumberOfPossibleBids() > 100) {
999 /*
1000 * if (this.maximumOfBid > 100) { beta = 2;//1.3; } else { beta =
1001 * 1.5; }
1002 */
1003 // the vaule of beta depends on the discounting factor (trade-off
1004 // between concede-to-time degree and discouting factor)
1005 if (this.discountingFactor > 0.75) {
1006 beta = 1.8;
1007 } else if (this.discountingFactor > 0.5) {
1008 beta = 1.5;
1009 } else {
1010 beta = 1.2;
1011 }
1012 alpha = Math.pow(this.discountingFactor, beta);
1013 this.AvgConcedeTime = this.minConcedeTime
1014 + (1 - this.minConcedeTime) * alpha;
1015 this.concedeTime_original = this.AvgConcedeTime;
1016 // System.out.println("concedeToDiscountingFactor is " +
1017 // this.AvgConcedeTime + "current time is " + timeline.getTime());
1018 } catch (Exception e) {
1019 System.out.println(
1020 "Exception in method chooseConcedeToDiscountingDegree");
1021 }
1022 }
1023
1024 /*
1025 * update the concede-to-time degree based on the predicted toughness degree
1026 * of the opponent
1027 */
1028
1029 private Bid regeneratebid(double bidutil) {
1030 Bid ans = null;
1031 ArrayList<Bid> Bids = null;
1032 this.mindistance = 999;
1033 this.averagedistance = 999;
1034 int count = 0;
1035 try {
1036 int check = 0;
1037 if (this.OppBids1.get(this.storingcapacity - 1) == null
1038 || this.OppBids2.get(this.storingcapacity - 1) == null) {
1039 ans = this.bid_maximum_utility;
1040 } else {
1041 for (this.CurrentrangeNumber = 0; check == 0; this.CurrentrangeNumber++) {
1042 if (bidutil < ((this.CurrentrangeNumber + 1)
1043 * this.SpacebetweenDivisions
1044 + this.MinimumUtility)) {
1045 check = 1;
1046 break;
1047 }
1048 }
1049 Bids = this.bidsBetweenUtility.get(this.CurrentrangeNumber);
1050 while (Bids.size() <= 10) {
1051 if (this.CurrentrangeNumber <= this.NumberofDivisions - 2) {
1052 for (int i = 0; i < this.bidsBetweenUtility
1053 .get(this.CurrentrangeNumber + 1).size(); i++) {
1054 Bids.add(Bids.size(), this.bidsBetweenUtility
1055 .get(this.CurrentrangeNumber + 1).get(i));
1056 }
1057 } else {
1058 break;
1059 }
1060 this.CurrentrangeNumber++;
1061 }
1062 this.size = Bids.size();
1063 if (Bids == null) {
1064 ans = this.mylastBid;
1065 } else {
1066 if (Math.random() > 0.1) {
1067 for (Bid Bid1 : Bids) {
1068 if (this.utilitySpace.getUtility(
1069 Bid1) > this.AvgUtilitythreshold) {
1070 count = 0;
1071 for (int i = 0; i < this.storingcapacity; i++) {
1072 if (this.OppBids1.get(i) != null) {
1073 this.averagedistance += calculatedistance(
1074 Bid1, this.OppBids1.get(i));
1075 count++;
1076 }
1077 if (this.OppBids2.get(i) != null) {
1078 this.averagedistance += calculatedistance(
1079 Bid1, this.OppBids2.get(i));
1080 count++;
1081 }
1082 }
1083 this.averagedistance /= count;
1084 if (this.averagedistance < this.mindistance) {
1085 this.mindistance = this.averagedistance;
1086 ans = Bid1;
1087 } else if (this.averagedistance == this.mindistance
1088 && Math.random() <= 0.5) {
1089 this.mindistance = this.averagedistance;
1090 ans = Bid1;
1091 }
1092 }
1093 }
1094 } else {
1095 ans = Bids.get((int) (Math.random() * Bids.size()));
1096 }
1097 }
1098 }
1099 } catch (Exception e) {
1100 System.out.println("Exception in method regeneratebid");
1101 this.except = 17;
1102 ans = this.bid_maximum_utility;
1103 }
1104 return ans;
1105
1106 }
1107
1108 private HashMap<Issue, Value> getBidValues(Bid bid) {
1109 try {
1110 HashMap<Issue, Value> Values = new HashMap<Issue, Value>();
1111 for (Issue lIssue : this.Issues) {
1112 int issueNum = lIssue.getNumber();
1113 Value v = bid.getValue(issueNum);
1114 Values.put(lIssue, v);
1115 }
1116 return Values;
1117 } catch (Exception e) {
1118 System.out
1119 .println("Exception in getBidValues(): " + e.getMessage());
1120 this.except = 18;
1121 }
1122 return null;
1123 }
1124
1125 private double calculatedistance(Bid Bid1, Bid Bid2) {
1126 try {
1127 double distance = 0.0D;
1128 HashMap<Issue, Value> Map1 = this.getBidValues(Bid1);
1129 HashMap<Issue, Value> Map2 = this.getBidValues(Bid2);
1130 for (Issue Issue1 : this.Issues) {
1131 switch (Issue1.getType()) {
1132 case DISCRETE:
1133 IssueDiscrete lIssueDiscrete = (IssueDiscrete) Issue1;
1134 ValueDiscrete value1 = (ValueDiscrete) Map1.get(Issue1);
1135 ValueDiscrete value2 = (ValueDiscrete) Map2.get(Issue1);
1136 int index1 = lIssueDiscrete.getValueIndex(value1);
1137 int index2 = lIssueDiscrete.getValueIndex(value2);
1138 distance += Math.abs(index1 - index2);
1139
1140 break;
1141 case REAL:
1142 ValueReal valueReal1 = (ValueReal) Map1.get(Issue1);
1143 ValueReal valueReal2 = (ValueReal) Map2.get(Issue1);
1144 double indexReal1 = valueReal1.getValue();
1145 double indexReal2 = valueReal2.getValue();
1146 distance += Math.abs(indexReal1 - indexReal2);
1147 break;
1148 case INTEGER:
1149 ValueInteger valueInteger1 = (ValueInteger) Map1
1150 .get(Issue1);
1151 ValueInteger valueInteger2 = (ValueInteger) Map2
1152 .get(Issue1);
1153 double indexInteger1 = valueInteger1.getValue();
1154 double indexInteger2 = valueInteger2.getValue();
1155 distance += Math.abs(indexInteger1 - indexInteger2);
1156 break;
1157 }
1158 }
1159 return distance;
1160 } catch (Exception e) {
1161 System.out.println("Exception in method calculatedistance");
1162 this.except = 19;
1163 return 999;
1164 }
1165 }
1166
1167 private void updateConcedeDegree_smallDiscountingFactor() {
1168 double gama = 10;
1169 double weight = 0.1;
1170 double opponnetToughnessDegree = this.opponentBidHistory2
1171 .getConcessionDegree();
1172 try {
1173 if (IsOppFirstBid_Agent1) {
1174 this.oppFirstBidUtility_Agent1 = utilitySpace
1175 .getUtility(this.oppFirstBid_Agent1);
1176 if (this.reservationValue <= this.oppFirstBidUtility_Agent1) {
1177 this.MinimumUtility_Agent1 = this.oppFirstBidUtility_Agent1;
1178 }
1179 IsOppFirstBid_Agent1 = false;
1180 }
1181
1182 if (IsOppFirstBid_Agent2) {
1183 this.oppFirstBidUtility_Agent2 = utilitySpace
1184 .getUtility(this.oppFirstBid_Agent2);
1185 if (this.reservationValue <= this.oppFirstBidUtility_Agent2) {
1186 this.MinimumUtility_Agent2 = this.oppFirstBidUtility_Agent2;
1187 }
1188 IsOppFirstBid_Agent2 = false;
1189 }
1190
1191 double temp = this.concedeTime_original
1192 + weight * (1 - this.concedeTime_original)
1193 * Math.pow(opponnetToughnessDegree, gama);
1194 this.concedeTime_Agent1 = temp;
1195 this.concedeTime_Agent2 = temp;
1196 if ((this.concedeTime_Agent1 >= 1)
1197 || (this.concedeTime_Agent2 >= 1)) {
1198 this.concedeTime_Agent1 = 1;
1199 this.concedeTime_Agent2 = 1;
1200 }
1201 } catch (Exception e) {
1202 System.out.println(
1203 "Exception in method updateConcedeDegree_smallDiscountingFactor");
1204 this.except = 20;
1205 }
1206 // System.out.println("concedeToDiscountingFactor is " +
1207 // this.concedeToDiscountingFactor + "current time is " +
1208 // timeline.getTime() + "original concedetodiscoutingfactor is " +
1209 // this.concedeToDiscountingFactor_original);
1210 }
1211
1212 private void updateConcedeDegree_largeDiscountingFactor_Agent1() {
1213 try {
1214 double i = 0;
1215 if (IsOppFirstBid_Agent1) {
1216 this.CalculateMinThreshold_Agent1();
1217 IsOppFirstBid_Agent1 = false;
1218 }
1219
1220 this.MeasureConcedePartOfOppBehaviour_Agent1();
1221
1222 this.concedePartOfdiscountingFactor_Agent1 = this.discountingFactor
1223 - 1;
1224 this.concedePartOfOppBehaviour_Agent1 = (((((this.relcountLowerBoundMid2_Agent1
1225 / this.relcountUpperBoundMid2_Agent1)
1226 * this.slopeOfSlopeOfSessionMax2_Agent1)
1227 - ((this.relcountLowerBoundMid1_Agent1
1228 / this.relcountUpperBoundMid1_Agent1)
1229 * this.slopeOfSlopeOfSessionMax1_Agent1))
1230 / this.k) / this.relstdevUtility_Agent1) - this.N;
1231 if (this.startConcede_Agent1 == true) {
1232 i = this.concedePartOfdiscountingFactor_Agent1
1233 + this.concedePartOfOppBehaviour_Agent1;
1234 this.concedeTime_Agent1 = Math.exp(i);
1235 if (this.concedeTime_Agent1 > 1) {
1236 this.concedeTime_Agent1 = 1;
1237 }
1238 } else {
1239 this.concedeTime_Agent2 = 0.5;
1240 }
1241 } catch (Exception e) {
1242 this.except = 23;
1243 System.out.println(
1244 "updateConcedeDegree_largeDiscountingFactor_Agent1 exception");
1245 }
1246 }
1247
1248 private void updateConcedeDegree_largeDiscountingFactor_Agent2() {
1249 try {
1250 double i = 0;
1251 if (IsOppFirstBid_Agent2) {
1252 this.CalculateMinThreshold_Agent2();
1253 IsOppFirstBid_Agent2 = false;
1254 }
1255
1256 this.MeasureConcedePartOfOppBehaviour_Agent2();
1257
1258 this.concedePartOfdiscountingFactor_Agent2 = this.discountingFactor
1259 - 1;
1260 this.concedePartOfOppBehaviour_Agent2 = (((((this.relcountLowerBoundMid2_Agent2
1261 / this.relcountUpperBoundMid2_Agent2)
1262 * this.slopeOfSlopeOfSessionMax2_Agent2)
1263 - ((this.relcountLowerBoundMid1_Agent2
1264 / this.relcountUpperBoundMid1_Agent2)
1265 * this.slopeOfSlopeOfSessionMax1_Agent2))
1266 / this.k) / this.relstdevUtility_Agent2) - this.N;
1267 if (this.startConcede_Agent2 == true) {
1268 i = this.concedePartOfdiscountingFactor_Agent2
1269 + this.concedePartOfOppBehaviour_Agent2;
1270 this.concedeTime_Agent2 = Math.exp(i);
1271 if (this.concedeTime_Agent2 > 1) {
1272 this.concedeTime_Agent2 = 1;
1273 }
1274 } else {
1275 this.concedeTime_Agent2 = 0.5;
1276 }
1277 } catch (Exception e) {
1278 this.except = 23;
1279 System.out.println(
1280 "updateConcedeDegree_largeDiscountingFactor_Agent2 exception");
1281 }
1282 }
1283
1284 private void updateConcedeDegree_nonDiscountingFactor_Agent1() {
1285 try {
1286 if (IsOppFirstBid_Agent1) {
1287 this.CalculateMinThreshold_Agent1();
1288 IsOppFirstBid_Agent1 = false;
1289 }
1290
1291 this.concedeTime_Agent1 = 1;
1292 } catch (Exception e) {
1293 this.except = 25;
1294 System.out.println(
1295 "updateConcedeDegree_nonDiscountingFactor_Agent1 exception");
1296 }
1297 }
1298
1299 private void updateConcedeDegree_nonDiscountingFactor_Agent2() {
1300 try {
1301 if (IsOppFirstBid_Agent2) {
1302 this.CalculateMinThreshold_Agent2();
1303 IsOppFirstBid_Agent2 = false;
1304 }
1305
1306 this.concedeTime_Agent2 = 1;
1307 } catch (Exception e) {
1308 this.except = 25;
1309 System.out.println(
1310 "updateConcedeDegree_nonDiscountingFactor_Agent2 exception");
1311 }
1312 }
1313
1314 private void CalculateMinThreshold_Agent1() {
1315 try {
1316 ArrayList<Double> bidsUtil = new ArrayList();
1317 bidsUtil = this.CalculateSumAndCount_Agent1(bidsUtil);
1318
1319 this.relavgUtility_Agent1 = this.relsumUtility_Agent1
1320 / this.relcountUtility_Agent1;
1321
1322 for (Iterator f = bidsUtil.iterator(); f.hasNext();) {
1323 double bidUtil = (Double) f.next();
1324
1325 if (bidUtil >= this.oppFirstBidUtility_Agent1) {
1326 this.relSqRootOfAvgUtility_Agent1 += (bidUtil
1327 - this.relavgUtility_Agent1)
1328 * (bidUtil - this.relavgUtility_Agent1);
1329 }
1330 }
1331 this.relstdevUtility_Agent1 = Math
1332 .sqrt(this.relSqRootOfAvgUtility_Agent1
1333 / this.relcountUtility_Agent1);
1334
1335 if (this.relstdevUtility_Agent1 < 0.1) {
1336 this.relSqRootOfAvgUtility_Agent1 = 0;
1337 for (Iterator g = bidsUtil.iterator(); g.hasNext();) {
1338 double bidUtil = (Double) g.next();
1339
1340 if (bidUtil >= this.oppFirstBidUtility_Agent1
1341 && (bidUtil < (this.relavgUtility_Agent1
1342 - this.relstdevUtility_Agent1)
1343 || bidUtil > (this.relavgUtility_Agent1
1344 + this.relstdevUtility_Agent1))) {
1345 this.relSqRootOfAvgUtility_Agent1 += (bidUtil
1346 - this.relavgUtility_Agent1)
1347 * (bidUtil - this.relavgUtility_Agent1);
1348 this.relcountUtilityInSmallSD_Agent1++;
1349 }
1350 }
1351 this.relstdevUtility_Agent1 = Math
1352 .sqrt(this.relSqRootOfAvgUtility_Agent1
1353 / this.relcountUtilityInSmallSD_Agent1);
1354 }
1355
1356 this.minThreshold_Agent1 = this.relavgUtility_Agent1
1357 + this.discountingFactor * this.relstdevUtility_Agent1
1358 * this.reservationValue;
1359
1360 if (this.relcountUtility_Agent1 < 20) {
1361 this.minThreshold_Agent1 = this.relavgUtility_Agent1;
1362 }
1363
1364 this.Compare_MinThreshold_And_SecondMax_Agent1();
1365 } catch (Exception e) {
1366 System.out.println(e.getMessage()
1367 + "exception in method CalculateMinThreshold_Agent1");
1368 }
1369 }
1370
1371 private void CalculateMinThreshold_Agent2() {
1372 try {
1373 ArrayList<Double> bidsUtil = new ArrayList();
1374 bidsUtil = this.CalculateSumAndCount_Agent2(bidsUtil);
1375
1376 this.relavgUtility_Agent2 = this.relsumUtility_Agent2
1377 / this.relcountUtility_Agent2;
1378
1379 for (Iterator f = bidsUtil.iterator(); f.hasNext();) {
1380 double bidUtil = (Double) f.next();
1381
1382 if (bidUtil >= this.oppFirstBidUtility_Agent2) {
1383 this.relSqRootOfAvgUtility_Agent2 += (bidUtil
1384 - this.relavgUtility_Agent2)
1385 * (bidUtil - this.relavgUtility_Agent2);
1386 }
1387 }
1388 this.relstdevUtility_Agent2 = Math
1389 .sqrt(this.relSqRootOfAvgUtility_Agent2
1390 / this.relcountUtility_Agent2);
1391
1392 if (this.relstdevUtility_Agent2 < 0.1) {
1393 this.relSqRootOfAvgUtility_Agent2 = 0;
1394 for (Iterator g = bidsUtil.iterator(); g.hasNext();) {
1395 double bidUtil = (Double) g.next();
1396
1397 if (bidUtil >= this.oppFirstBidUtility_Agent2
1398 && (bidUtil < (this.relavgUtility_Agent2
1399 - this.relstdevUtility_Agent2)
1400 || bidUtil > (this.relavgUtility_Agent2
1401 + this.relstdevUtility_Agent2))) {
1402 this.relSqRootOfAvgUtility_Agent2 += (bidUtil
1403 - this.relavgUtility_Agent2)
1404 * (bidUtil - this.relavgUtility_Agent2);
1405 this.relcountUtilityInSmallSD_Agent2++;
1406 }
1407 }
1408 this.relstdevUtility_Agent2 = Math
1409 .sqrt(this.relSqRootOfAvgUtility_Agent2
1410 / this.relcountUtilityInSmallSD_Agent2);
1411 }
1412
1413 this.minThreshold_Agent2 = this.relavgUtility_Agent2
1414 + this.discountingFactor * this.relstdevUtility_Agent2
1415 * this.reservationValue;
1416
1417 if (this.relcountUtility_Agent2 < 20) {
1418 this.minThreshold_Agent2 = this.relavgUtility_Agent2;
1419 }
1420
1421 this.Compare_MinThreshold_And_SecondMax_Agent2();
1422 } catch (Exception e) {
1423 System.out.println(e.getMessage()
1424 + "exception in method CalculateMinThreshold_Agent2");
1425 }
1426 }
1427
1428 private void Compare_MinThreshold_And_SecondMax_Agent1() {
1429 if (this.minThreshold_Agent1 > utility_SecondMaximum_Agent1) {
1430 this.minThreshold_Agent1 = utility_SecondMaximum_Agent1 * 0.9;
1431 }
1432 }
1433
1434 private void Compare_MinThreshold_And_SecondMax_Agent2() {
1435 if (this.minThreshold_Agent2 > utility_SecondMaximum_Agent2) {
1436 this.minThreshold_Agent2 = utility_SecondMaximum_Agent2 * 0.9;
1437 }
1438 }
1439
1440 private ArrayList<Double> CalculateSumAndCount_Agent1(
1441 ArrayList<Double> bidsUtil) {
1442 try {
1443 this.oppFirstBidUtility_Agent1 = utilitySpace
1444 .getUtility(this.oppFirstBid_Agent1);
1445 if (this.reservationValue <= this.oppFirstBidUtility_Agent1) {
1446 this.MinimumUtility_Agent1 = this.oppFirstBidUtility_Agent1;
1447 }
1448
1449 BidIterator myBidIterator = new BidIterator(
1450 this.utilitySpace.getDomain());
1451 for (; myBidIterator.hasNext();) {
1452 try {
1453 bidsUtil.add(
1454 this.utilitySpace.getUtility(myBidIterator.next()));
1455 } catch (Exception e) {
1456 System.out.println(e.getMessage()
1457 + "exception in method CalculateSumAndCount_Agent1");
1458 return null;
1459 }
1460 }
1461 this.relavgUtility_Agent1 = 0;
1462 this.relsumUtility_Agent1 = 0;
1463 this.relcountUtility_Agent1 = 0;
1464 this.relSqRootOfAvgUtility_Agent1 = 0;
1465 this.relstdevUtility_Agent1 = 0;
1466 this.minThreshold_Agent1 = 0;
1467
1468 for (Iterator e = bidsUtil.iterator(); e.hasNext();) {
1469 double bidUtil = (Double) e.next();
1470 if (this.utility_FirstMaximum_Agent1 < bidUtil) {
1471 this.utility_FirstMaximum_Agent1 = bidUtil;
1472 } else if (utility_SecondMaximum_Agent1 < bidUtil) {
1473 this.utility_SecondMaximum_Agent1 = bidUtil;
1474 }
1475
1476 if (bidUtil >= this.oppFirstBidUtility_Agent1) {
1477 this.relsumUtility_Agent1 += bidUtil;
1478 this.relcountUtility_Agent1 += 1;
1479 }
1480 }
1481
1482 return bidsUtil;
1483 } catch (Exception e) {
1484 System.out.println(e.getMessage()
1485 + "exception in method CalculateSumAndCount_Agent1");
1486 }
1487
1488 return null;
1489 }
1490
1491 private ArrayList<Double> CalculateSumAndCount_Agent2(
1492 ArrayList<Double> bidsUtil) {
1493 try {
1494 this.oppFirstBidUtility_Agent2 = utilitySpace
1495 .getUtility(this.oppFirstBid_Agent2);
1496 if (this.reservationValue <= this.oppFirstBidUtility_Agent2) {
1497 this.MinimumUtility_Agent2 = this.oppFirstBidUtility_Agent2;
1498 }
1499
1500 BidIterator myBidIterator = new BidIterator(
1501 this.utilitySpace.getDomain());
1502 for (; myBidIterator.hasNext();) {
1503 bidsUtil.add(
1504 this.utilitySpace.getUtility(myBidIterator.next()));
1505 }
1506 this.relavgUtility_Agent2 = 0;
1507 this.relsumUtility_Agent2 = 0;
1508 this.relcountUtility_Agent2 = 0;
1509 this.relSqRootOfAvgUtility_Agent2 = 0;
1510 this.relstdevUtility_Agent2 = 0;
1511 this.minThreshold_Agent2 = 0;
1512
1513 for (Iterator e = bidsUtil.iterator(); e.hasNext();) {
1514 double bidUtil = (Double) e.next();
1515 if (this.utility_FirstMaximum_Agent2 < bidUtil) {
1516 this.utility_FirstMaximum_Agent2 = bidUtil;
1517 } else if (utility_SecondMaximum_Agent2 < bidUtil) {
1518 this.utility_SecondMaximum_Agent2 = bidUtil;
1519 }
1520
1521 if (bidUtil >= this.oppFirstBidUtility_Agent2) {
1522 this.relsumUtility_Agent2 += bidUtil;
1523 this.relcountUtility_Agent2 += 1;
1524 }
1525 }
1526
1527 return bidsUtil;
1528 } catch (Exception e) {
1529 System.out.println(e.getMessage()
1530 + "exception in method CalculateSumAndCount_Agent2");
1531 return null;
1532 }
1533 }
1534
1535 private void MeasureConcedePartOfOppBehaviour_Agent1() {
1536 try {
1537 count_Agent1++;
1538
1539 if (count_Agent1 < this.FirstTimeInterval) {
1540 if (utilitySpace.getUtility(
1541 this.oppPreviousBid_Agent1) > this.utility_maximum_from_opponent_Session1_Agent1) {
1542 this.utility_maximum_from_opponent_Session1_Agent1 = utilitySpace
1543 .getUtility(this.oppPreviousBid_Agent1);
1544 }
1545 } else if (count_Agent2 < this.SecondTimeInterval) {
1546 if (utilitySpace.getUtility(
1547 this.oppPreviousBid_Agent1) > this.utility_maximum_from_opponent_Session2_Agent1) {
1548 this.utility_maximum_from_opponent_Session2_Agent1 = utilitySpace
1549 .getUtility(this.oppPreviousBid_Agent1);
1550 }
1551 } else if (count_Agent2 < this.ThirdTimeInterval) {
1552 if (utilitySpace.getUtility(
1553 this.oppPreviousBid_Agent1) > this.utility_maximum_from_opponent_Session3_Agent1) {
1554 this.utility_maximum_from_opponent_Session3_Agent1 = utilitySpace
1555 .getUtility(this.oppPreviousBid_Agent1);
1556 }
1557 } else {
1558 this.relcountUpperBoundMid1_Agent1 = 0;
1559 this.relcountUpperBoundMid2_Agent1 = 0;
1560 this.relcountLowerBoundMid1_Agent1 = 0;
1561 this.relcountLowerBoundMid2_Agent1 = 0;
1562 this.midPointOfSlopeSessionMax1_Agent1 = (this.utility_maximum_from_opponent_Session2_Agent1
1563 + this.utility_maximum_from_opponent_Session1_Agent1)
1564 / 2;
1565 this.midPointOfSlopeSessionMax2_Agent1 = (this.utility_maximum_from_opponent_Session3_Agent1
1566 + this.utility_maximum_from_opponent_Session2_Agent1)
1567 / 2;
1568 this.slopeOfSlopeOfSessionMax1_Agent1 = this.utility_maximum_from_opponent_Session2_Agent1
1569 - this.utility_maximum_from_opponent_Session1_Agent1;
1570 this.slopeOfSlopeOfSessionMax2_Agent1 = this.utility_maximum_from_opponent_Session3_Agent1
1571 - this.utility_maximum_from_opponent_Session2_Agent1;
1572
1573 ArrayList<Double> bidsUtil = new ArrayList();
1574 BidIterator myBidIterator = new BidIterator(
1575 this.utilitySpace.getDomain());
1576 for (; myBidIterator.hasNext();) {
1577 bidsUtil.add(
1578 this.utilitySpace.getUtility(myBidIterator.next()));
1579 }
1580 for (Iterator e = bidsUtil.iterator(); e.hasNext();) {
1581 double bidUtil = (Double) e.next();
1582 if (bidUtil >= this.midPointOfSlopeSessionMax1_Agent1) {
1583 this.relcountUpperBoundMid1_Agent1 += 1;
1584 } else {
1585 this.relcountLowerBoundMid1_Agent1 += 1;
1586 }
1587
1588 if (bidUtil >= this.midPointOfSlopeSessionMax2_Agent1) {
1589 this.relcountUpperBoundMid2_Agent1 += 1;
1590 } else {
1591 this.relcountLowerBoundMid2_Agent1 += 1;
1592 }
1593 }
1594 this.utility_maximum_from_opponent_Session1_Agent1 = this.utility_maximum_from_opponent_Session2_Agent1;
1595 this.utility_maximum_from_opponent_Session2_Agent1 = this.utility_maximum_from_opponent_Session3_Agent1;
1596 this.utility_maximum_from_opponent_Session3_Agent1 = 0;
1597 this.count_Agent1 = this.SecondTimeInterval - 1;
1598 this.startConcede_Agent1 = true;
1599 }
1600 } catch (Exception e) {
1601 System.out.println(e.getMessage()
1602 + "exception in method MeasureConcedePartOfOppBehaviour_Agent1");
1603 }
1604 }
1605
1606 private void MeasureConcedePartOfOppBehaviour_Agent2() {
1607 try {
1608 count_Agent2++;
1609
1610 if (count_Agent2 < this.FirstTimeInterval) {
1611 if (utilitySpace.getUtility(
1612 this.oppPreviousBid_Agent2) > this.utility_maximum_from_opponent_Session1_Agent2) {
1613 this.utility_maximum_from_opponent_Session1_Agent2 = utilitySpace
1614 .getUtility(this.oppPreviousBid_Agent2);
1615 }
1616 } else if (count_Agent2 < this.SecondTimeInterval) {
1617 if (utilitySpace.getUtility(
1618 this.oppPreviousBid_Agent2) > this.utility_maximum_from_opponent_Session2_Agent2) {
1619 this.utility_maximum_from_opponent_Session2_Agent2 = utilitySpace
1620 .getUtility(this.oppPreviousBid_Agent2);
1621 }
1622 } else if (count_Agent2 < this.ThirdTimeInterval) {
1623 if (utilitySpace.getUtility(
1624 this.oppPreviousBid_Agent2) > this.utility_maximum_from_opponent_Session3_Agent2) {
1625 this.utility_maximum_from_opponent_Session3_Agent2 = utilitySpace
1626 .getUtility(this.oppPreviousBid_Agent2);
1627 }
1628 } else {
1629 this.relcountUpperBoundMid1_Agent2 = 0;
1630 this.relcountUpperBoundMid2_Agent2 = 0;
1631 this.relcountLowerBoundMid1_Agent2 = 0;
1632 this.relcountLowerBoundMid2_Agent2 = 0;
1633 this.midPointOfSlopeSessionMax1_Agent2 = (this.utility_maximum_from_opponent_Session2_Agent2
1634 + this.utility_maximum_from_opponent_Session1_Agent2)
1635 / 2;
1636 this.midPointOfSlopeSessionMax2_Agent2 = (this.utility_maximum_from_opponent_Session3_Agent2
1637 + this.utility_maximum_from_opponent_Session2_Agent2)
1638 / 2;
1639 this.slopeOfSlopeOfSessionMax1_Agent2 = this.utility_maximum_from_opponent_Session2_Agent2
1640 - this.utility_maximum_from_opponent_Session1_Agent2;
1641 this.slopeOfSlopeOfSessionMax2_Agent2 = this.utility_maximum_from_opponent_Session3_Agent2
1642 - this.utility_maximum_from_opponent_Session2_Agent2;
1643
1644 ArrayList<Double> bidsUtil = new ArrayList();
1645 BidIterator myBidIterator = new BidIterator(
1646 this.utilitySpace.getDomain());
1647 for (; myBidIterator.hasNext();) {
1648 bidsUtil.add(
1649 this.utilitySpace.getUtility(myBidIterator.next()));
1650 }
1651 for (Iterator e = bidsUtil.iterator(); e.hasNext();) {
1652 double bidUtil = (Double) e.next();
1653 if (bidUtil >= this.midPointOfSlopeSessionMax1_Agent2) {
1654 this.relcountUpperBoundMid1_Agent2 += 1;
1655 } else {
1656 this.relcountLowerBoundMid1_Agent2 += 1;
1657 }
1658
1659 if (bidUtil >= this.midPointOfSlopeSessionMax2_Agent2) {
1660 this.relcountUpperBoundMid2_Agent2 += 1;
1661 } else {
1662 this.relcountLowerBoundMid2_Agent2 += 1;
1663 }
1664 }
1665 this.utility_maximum_from_opponent_Session1_Agent2 = this.utility_maximum_from_opponent_Session2_Agent2;
1666 this.utility_maximum_from_opponent_Session2_Agent2 = this.utility_maximum_from_opponent_Session3_Agent2;
1667 this.utility_maximum_from_opponent_Session3_Agent2 = 0;
1668 this.count_Agent2 = SecondTimeInterval - 1;
1669 this.startConcede_Agent2 = true;
1670 }
1671 } catch (Exception e) {
1672 System.out.println(e.getMessage()
1673 + "exception in method MeasureConcedePartOfOppBehaviour_Agent2");
1674 }
1675 }
1676
1677 private Bid BidToOffer_original() {
1678 Bid bidReturned = null;
1679 int test = 0;
1680
1681 try {
1682 double maximumOfBid = this.MaximumUtility;// utilitySpace.getUtility(utilitySpace.getMaxUtilityBid());
1683 double minimumOfBid;
1684
1685 if (timeline.getTime() <= ((this.concedeTime_Agent2
1686 + this.concedeTime_Agent1) / 2)) {
1687 if (this.discountingFactor <= 0.5) {
1688 this.minThreshold_Agent1 = (maximumOfBid
1689 * this.discountingFactor)
1690 / Math.pow(this.discountingFactor,
1691 this.concedeTime_Agent1);
1692 this.minThreshold_Agent2 = (maximumOfBid
1693 * this.discountingFactor)
1694 / Math.pow(this.discountingFactor,
1695 this.concedeTime_Agent2);
1696 this.utilitythreshold_Agent1 = maximumOfBid
1697 - (maximumOfBid - this.minThreshold_Agent1)
1698 * Math.pow(
1699 (timeline.getTime()
1700 / this.concedeTime_Agent1),
1701 alpha1);
1702 this.utilitythreshold_Agent2 = maximumOfBid
1703 - (maximumOfBid - this.minThreshold_Agent2)
1704 * Math.pow(
1705 (timeline.getTime()
1706 / this.concedeTime_Agent2),
1707 alpha1);
1708 } else {
1709 this.utilitythreshold_Agent1 = this.minThreshold_Agent1
1710 + (maximumOfBid - this.minThreshold_Agent1) * (1
1711 - Math.sin((Math.PI / 2) * (timeline
1712 .getTime() / this.concedeTime_Agent1)));
1713 this.utilitythreshold_Agent2 = this.minThreshold_Agent2
1714 + (maximumOfBid - this.minThreshold_Agent2) * (1
1715 - Math.sin((Math.PI / 2) * (timeline
1716 .getTime() / this.concedeTime_Agent2)));
1717 }
1718 } else {
1719 if (this.discountingFactor <= 0.5) {
1720 this.utilitythreshold_Agent1 = (maximumOfBid
1721 * this.discountingFactor)
1722 / Math.pow(this.discountingFactor,
1723 timeline.getTime());
1724 this.utilitythreshold_Agent2 = (maximumOfBid
1725 * this.discountingFactor)
1726 / Math.pow(this.discountingFactor,
1727 timeline.getTime());
1728 } else {
1729 this.utilitythreshold_Agent1 = this.minThreshold_Agent1
1730 + (maximumOfBid - this.minThreshold_Agent1)
1731 / (1 - concedeTime_Agent1)
1732 * Math.pow(
1733 (timeline.getTime()
1734 - this.concedeTime_Agent1),
1735 this.discountingFactor);
1736 this.utilitythreshold_Agent2 = this.minThreshold_Agent2
1737 + (maximumOfBid - this.minThreshold_Agent2)
1738 / (1 - concedeTime_Agent2)
1739 * Math.pow(
1740 (timeline.getTime()
1741 - this.concedeTime_Agent2),
1742 this.discountingFactor);
1743 }
1744 }
1745 this.AvgUtilitythreshold = (this.utilitythreshold_Agent2
1746 + this.utilitythreshold_Agent1) / 2;
1747 if (this.AvgUtilitythreshold > MaximumUtility) {
1748 this.AvgUtilitythreshold = MaximumUtility;
1749 }
1750
1751 minimumOfBid = this.AvgUtilitythreshold;
1752
1753 /*
1754 * if(minimumOfBid < 0.9 && this.guessOpponentType == false){
1755 * if(this.opponentBidHistory.getSize() <= 2){ this.opponentType =
1756 * 1;//tough opponent alpha1 = 2; } else{ this.opponentType = 0;
1757 * alpha1 = 4; } this.guessOpponentType = true;//we only guess the
1758 * opponent type once here System.out.println("we guess the opponent
1759 * type is "+this.opponentType); }
1760 */
1761
1762 // choose from the opponent bid history first to reduce calculation
1763 // time
1764 Bid bestBidOfferedByOpponent1 = opponentBidHistory1
1765 .getBestBidInHistory();
1766 Bid bestBidOfferedByOpponent2 = opponentBidHistory2
1767 .getBestBidInHistory();
1768 Bid bestBidOfferedByOpponent = this
1769 .getUtility(bestBidOfferedByOpponent1) > this
1770 .getUtility(bestBidOfferedByOpponent2)
1771 ? bestBidOfferedByOpponent2
1772 : bestBidOfferedByOpponent1;
1773 if (utilitySpace.getUtility(
1774 bestBidOfferedByOpponent) >= this.AvgUtilitythreshold
1775 || utilitySpace.getUtility(
1776 bestBidOfferedByOpponent) >= minimumOfBid) {
1777 return bestBidOfferedByOpponent;
1778 }
1779 this.nextbidutil = this.BidToOffer();
1780 bidReturned = this.regeneratebid(this.nextbidutil);
1781 if (bidReturned == null) {
1782 System.out.println("no bid is searched warning");
1783 bidReturned = this.utilitySpace.getMaxUtilityBid();
1784 }
1785 MinAcceptCondition(bidReturned);
1786 } catch (Exception e) {
1787 System.out.println(
1788 e.getMessage() + "exception in method BidToOffer_original");
1789 this.except = 26;
1790 return this.bid_maximum_utility;
1791 }
1792 // System.out.println("the current threshold is " +
1793 // this.utilitythreshold + " with the value of alpha1 is " + alpha1);
1794 return bidReturned;
1795 }
1796
1797 private boolean OtherAcceptCondition(boolean IsAccept) {
1798 try {
1799 if ((timeline.getTime() >= ((this.concedeTime_Agent2
1800 + this.concedeTime_Agent1) / 2))
1801 && (this.utilitySpace.getUtility(
1802 this.oppPreviousBid_Agent2) >= this.minUtilityUhreshold)) {
1803 IsAccept = true;
1804 }
1805 } catch (Exception e) {
1806 this.except = 27;
1807 System.out.println(e.getMessage()
1808 + "exception in method OtherAcceptCondition");
1809 return true;
1810 }
1811 return IsAccept;
1812 }
1813
1814 private void MinAcceptCondition(Bid bidReturned) {
1815 try {
1816 if (this.minUtilityUhreshold > this.utilitySpace
1817 .getUtility(bidReturned)) {
1818 this.minUtilityUhreshold = this.utilitySpace
1819 .getUtility(bidReturned);
1820 }
1821 } catch (Exception e) {
1822 this.except = 28;
1823 System.out.println(
1824 e.getMessage() + "exception in method MinAcceptCondition");
1825 }
1826 }
1827
1828 @Override
1829 public String getDescription() {
1830 return "ANAC2015";
1831 }
1832}
Note: See TracBrowser for help on using the repository browser.