source: src/main/java/agents/FuzzyAgent.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: 30.3 KB
Line 
1package agents;
2
3import java.util.HashMap;
4import java.util.Random;
5
6import genius.core.Agent;
7import genius.core.Bid;
8import genius.core.SupportedNegotiationSetting;
9import genius.core.actions.Accept;
10import genius.core.actions.Action;
11import genius.core.actions.Offer;
12import genius.core.issue.Value;
13import genius.core.issue.ValueReal;
14
15public class FuzzyAgent extends Agent {
16
17 private static int deadline = 100;
18 private static int deadlineB = 100;
19 private static int deadlineS = 100;
20 private static double[][] BuyOffer;
21 private static double[][] SellOffer;
22 private static int tacticB;
23 private static int tacticS;
24
25 // private static int tacticBStretch,tacticSStretch;
26 private static double K = 0.1;
27 private static double MaxB = 40;
28 private static double MinB = 10;
29 // private static double MinB2=10;
30 private static double MaxS = 40;
31 // private static double MaxS2=40;
32 private static double MinS = 10;
33
34 private static boolean deal = false;
35 private static double Utl = 0;
36 private static double BBuy, BSell;
37 // parameters for stretch 260307
38 private static double BBuyStretch, BSellStretch;
39 private static int LBuy, LSell;
40 // private static int LBuyStretch,LSellStretch;
41 private static int iteration = 1;
42 // private static double constant=0.05;
43 private static int MBuy, MSell;
44 // private static int MBuyStretch,MSellStretch;
45 // private static boolean dealB=false;
46 // private static boolean dealS=false;
47 private static double AcceptedValue = 0;
48 // for counting rounds in resource dependat
49 private static int itercount = 0;
50 // The stretch constant
51 private static double Scons, Bcons;
52 private static boolean CBuy = false;
53 private static boolean CSell = false;
54 // private static double[][] Distance;
55 // private static double DST;
56 private static double[] dist;
57 private static double percentageB1, percentageB2, percentageS1,
58 percentageS2;
59 // A threshhold parameter which determines when we should and should not
60 // accept or propose crisp 230407
61 private static double threshholdB, threshholdS;
62
63 private static final int BUYER = 1;
64 private static final int SELLER = 2;
65 private int fPlayingFor;
66 private int fRound;
67 private Bid lastReceivedOffer;
68
69 @Override
70 public Action chooseAction() {
71 double lNextBidValue = 0;
72 Action lAction = null;
73
74 switch (fPlayingFor) {
75 case BUYER:
76 deal = Buyer(fRound);
77 lNextBidValue = BuyOffer[fRound][0];
78 break;
79
80 case SELLER:
81 deal = Seller(fRound);
82 lNextBidValue = SellOffer[fRound][0];
83 break;
84 }
85 if (deal)
86 lAction = new Accept(getAgentID(), lastReceivedOffer);
87
88 else {
89 HashMap<Integer, Value> lValues = new HashMap<Integer, Value>();
90 ValueReal lValue = new ValueReal(lNextBidValue);
91 lValues.put(utilitySpace.getDomain().getIssues().get(0).getNumber(),
92 lValue);
93 try {
94 Bid lBid = new Bid(utilitySpace.getDomain(), lValues);
95 lAction = new Offer(getAgentID(), lBid);
96 } catch (Exception e) {
97 e.printStackTrace();
98 }
99
100 }
101 return lAction;
102 }
103
104 @Override
105 public String getVersion() {
106 return "1.0";
107 }
108
109 @Override
110 public void init() {
111
112 fRound = 0;
113 dist = new double[deadline + 1];
114 BuyOffer = new double[deadlineB + 1][2];
115 SellOffer = new double[deadlineS + 1][2];
116 BuyOffer[0][0] = MinB;
117 SellOffer[0][0] = MaxS;
118 BuyOffer[0][1] = BuyOffer[0][0] + (percentageB1 * Bcons);
119 SellOffer[0][1] = SellOffer[0][0] - (percentageS1 * Scons);
120 if (getName().equals("Seller"))
121 fPlayingFor = BUYER;
122 else
123 fPlayingFor = SELLER;
124 tacticB = 1;
125 tacticS = 1;
126 BBuy = 0.01;
127 LBuy = 2;
128 MBuy = 2;
129 BSell = 50;
130 LSell = 2;
131 MSell = 2;
132 Bcons = 1;
133 Scons = 1;
134 BBuyStretch = 0.1;
135 BSellStretch = 0.1;
136 // Initializing the value of the threshold for the first offers
137 threshholdB = ThreshFind(deadlineB, 0, BuyOffer[0][0], BuyOffer[0][1]);
138 threshholdS = ThreshFind(deadlineS, 0, SellOffer[0][0],
139 SellOffer[0][1]);
140
141 }
142
143 @Override
144 public void ReceiveMessage(Action opponentAction) {
145 fRound++;
146 if (opponentAction instanceof Offer) {
147 Offer lOffer = (Offer) opponentAction;
148 lastReceivedOffer = lOffer.getBid();
149 switch (fPlayingFor) {
150 case BUYER:
151 try {
152 SellOffer[fRound][0] = ((ValueReal) (lastReceivedOffer
153 .getValue(utilitySpace.getDomain().getIssues()
154 .get(0).getNumber()))).getValue();
155 SellOffer[fRound][1] = SellOffer[fRound][0]
156 + (percentageB1 * Bcons);
157 } catch (Exception e) {
158 e.printStackTrace();
159 }
160 break;
161 case SELLER:
162 try {
163 BuyOffer[fRound][0] = ((ValueReal) (lastReceivedOffer
164 .getValue(utilitySpace.getDomain().getIssues()
165 .get(0).getNumber()))).getValue();
166 BuyOffer[fRound][1] = BuyOffer[fRound][0]
167 - (percentageS1 * Scons);
168 } catch (Exception e) {
169 e.printStackTrace();
170 }
171
172 break;
173 }// switch
174 } // if
175 }
176
177 public static double CalculateCost(double constant, int NoIteration) {
178 double cost;
179 cost = (java.lang.Math.exp(NoIteration * constant)
180 - java.lang.Math.exp(-NoIteration * constant))
181 / (java.lang.Math.pow(java.lang.Math.E, NoIteration * constant)
182 + java.lang.Math.pow(java.lang.Math.E,
183 -NoIteration * constant));
184 return cost;
185 }
186
187 protected static boolean Buyer(int i) {
188 double A = 0;
189 itercount++;
190 double[] inter = {};
191 switch (tacticB) {
192 case 1:
193 // If it has reached the deadline terminate negotiaiton
194 if (i > deadlineB) {
195 // System.out.println("Finished");
196 return true;
197 }
198 // if it has not reached the deadline continue negotiation
199 else {
200 Utl = (MaxB - SellOffer[i - 1][0]) / (MaxB - MinB);
201 if (i > 0) {
202 Utl = (MaxB - SellOffer[i - 1][0]) / (MaxB - MinB);
203 if (CSell == false) {
204 /*
205 * if
206 * (((double)SellOffer[i-1][0]<=(double)BuyOffer[i-1][
207 * 1]) && (i<deadlineB)) {
208 * System.out.println("Accepted");
209 * AcceptedValue=SellOffer[i-1][0]; return true; }
210 */
211 if ((SellOffer[i - 1][1] <= BuyOffer[i - 1][1])
212 && (i <= deadlineB)) {
213 double[] xParams = { SellOffer[i - 1][1],
214 SellOffer[i - 1][0], BuyOffer[i - 1][0],
215 BuyOffer[i - 1][1] };
216 if (BuyOffer[i - 1][1] == BuyOffer[i - 1][0]) {
217 CBuy = false;
218 } else {
219 double[] x = { SellOffer[i - 1][1],
220 SellOffer[i - 1][0], BuyOffer[i - 1][0],
221 BuyOffer[i - 1][1] };
222 xParams = x;
223 double[] yParams = { 0.0, 1.0, 1.0, 0.0 };
224 inter = Intersection(xParams, yParams);
225 // Checks if the the intersection pointis lower
226 // than the threshhold, if so agent will
227 // propose the crisp value
228 if (inter[0] <= threshholdB) {
229 CBuy = true;
230 } else {
231 CBuy = false;
232 }
233 }
234
235 }
236 }
237 }
238 if (BBuy == 0.01 || BBuy == 0.2) {
239 A = java.lang.Math.exp(java.lang.Math.pow(
240 1 - ((double) java.lang.Math.min(i + 1, deadlineB)
241 / (double) deadlineB),
242 (BBuy)) * java.lang.Math.log(K));
243 } else {
244 A = K + ((1 - K) * (java.lang.Math
245 .pow(((double) java.lang.Math.min(i + 1, deadlineB)
246 / (double) deadlineB), (1 / BBuy))));
247 }
248 double tmp = MinB + ((MaxB - MinB) * A);
249 double tmpUtl = (MaxB - tmp) / (MaxB - MinB);
250 if (CSell == true && i >= 2) {
251 if (SellOffer[i - 1][0] <= threshholdB) {
252 AcceptedValue = SellOffer[i - 1][0];
253 return true;
254 } else {
255 CSell = false;
256 }
257 }
258 if ((float) tmpUtl < (float) Utl && (CBuy == false)) {
259 // System.out.println("Accepted"+SellOffer[i-1][0]);
260 AcceptedValue = SellOffer[i - 1][0];
261 return true;
262 } else {
263
264 if (CBuy == true) {
265 BuyOffer[i][0] = inter[0];
266 BuyOffer[i][1] = BuyOffer[i][0];
267
268 } else {
269 BuyOffer[i][0] = tmp;
270 // code added to calculate the stretch reduction
271 if (BBuyStretch == 0.01 || BBuyStretch == 0.2) {
272 A = java.lang.Math.exp(java.lang.Math.pow(
273 1 - ((double) java.lang.Math.min(i + 1,
274 deadlineB) / (double) deadlineB),
275 (BBuyStretch)) * java.lang.Math.log(K));
276
277 } else {
278 A = K + ((1 - K) * (java.lang.Math.pow(
279 ((double) java.lang.Math.min(i + 1,
280 deadlineB) / (double) deadlineB),
281 (1 / BBuyStretch))));
282 }
283 double tmpBcons = ((percentageB2 * (Bcons))
284 + ((percentageB1 - percentageB2) * (Bcons)
285 * (1 - A)));
286
287 if (BuyOffer[i][0] + tmpBcons >= MaxB) {
288 BuyOffer[i][1] = MaxB;
289
290 } else {
291 BuyOffer[i][1] = BuyOffer[i][0] + tmpBcons;
292 }
293 }
294 threshholdB = ThreshFind(deadlineB, i + 1, BuyOffer[i][0],
295 BuyOffer[i][1]);
296 return false;
297 }
298
299 }
300
301 case 2:
302 if (i > deadlineB) {
303 // System.out.println("Finished");
304 return true;
305 } else {
306 if (i > 0) {
307 Utl = (MaxB - SellOffer[i - 1][0]) / (MaxB - MinB);
308 if (CSell == false) {
309 /*
310 * if
311 * (((double)SellOffer[i-1][0]<=(double)BuyOffer[i-1][
312 * 1]) && (i<deadlineB)) {
313 * System.out.println("Accepted");
314 * AcceptedValue=SellOffer[i-1][0]; return true; }
315 */
316
317 if ((SellOffer[i - 1][1] <= BuyOffer[i - 1][1])
318 && (i <= deadlineB)) {
319 double[] xParams = new double[4];
320 if (BuyOffer[i - 1][0] == BuyOffer[i - 1][1]) {
321 CBuy = false;
322 } else {
323 double[] x = { SellOffer[i - 1][1],
324 SellOffer[i - 1][0], BuyOffer[i - 1][0],
325 BuyOffer[i - 1][1] };
326 xParams = x;
327 CBuy = true;
328 double[] yParams = { 0.0, 1.0, 1.0, 0.0 };
329 inter = Intersection(xParams, yParams);
330 double DifUtlOurs = (MaxB - BuyOffer[i - 1][0])
331 / (MaxB - MinB);
332 double MidUtl = (MaxB - inter[0])
333 / (MaxB - MinB);
334 DifUtlOurs -= MidUtl;
335 double DifUtlOps = (MaxB - SellOffer[i - 1][0])
336 / (MaxB - MinB);
337 DifUtlOps = MidUtl - DifUtlOps;
338 // if ((float)DifUtlOurs<=(float)DifUtlOps){
339 CBuy = true;
340 MinB = inter[0];
341 // }
342 // else
343 // {
344 // CBuy=false;
345 // }
346
347 }
348 /*
349 * double[] yParams={0.0,1.0,1.0,0.0}; double[]
350 * inter={}; inter=Intersection(xParams, yParams);
351 * CBuy=true; MinB=BuyOffer[i-1][0];
352 * MaxB=SellOffer[i-1][0]; MinS=BuyOffer[i-1][0];
353 * MaxS=SellOffer[i-1][0]; BBuy=40;
354 * BuyOffer[i][0]=inter[0]; BuyOffer[i][1]=0; return
355 * false;
356 */
357 }
358 }
359 }
360 if (CSell == true && i >= 2) {
361 double DifUtlOurs = (MaxB - BuyOffer[i - 1][0])
362 / (MaxB - MinB);
363 DifUtlOurs -= Utl;
364 double DifUtlOps = (MaxB - SellOffer[i - 1][0])
365 / (MaxB - MinB);
366 DifUtlOps = Utl - DifUtlOps;
367 if ((float) DifUtlOurs <= (float) DifUtlOps) {
368 // System.out.println("Accepted the middle value");
369 AcceptedValue = SellOffer[i - 1][0];
370 return true;
371 } else {
372 CSell = false;
373 }
374 }
375 if (LBuy == 3) {
376 Random generator = new Random();
377 if (i > LBuy) {
378 // double
379 // tmp3=java.lang.Math.min(java.lang.Math.max((BuyOffer[i-1][0]+(double)SellOffer[i-1-LBuy][0]-(double)SellOffer[i-1][0]+(generator.nextInt(4))),MinB),MaxB);
380 double tmp3 = java.lang.Math.min(java.lang.Math.max(
381 (BuyOffer[i - 1][0] + SellOffer[i - 1 - LBuy][0]
382 - SellOffer[i - 1][0] + 2),
383 MinB), MaxB);
384 double tmpUtl3 = (MaxB - tmp3) / (MaxB - MinB);
385 if (((float) tmpUtl3 <= (float) Utl)
386 && (CBuy == false)) {
387 // System.out.println("Accepted");
388 AcceptedValue = SellOffer[i - 1][0];
389 return true;
390 } else {
391
392 if (CBuy == true) {
393 BuyOffer[i][0] = inter[0];
394 BuyOffer[i][1] = BuyOffer[i][0];
395 } else {
396 BuyOffer[i][0] = tmp3;
397 if (BuyOffer[i][0] + Bcons >= MaxB) {
398 BuyOffer[i][1] = MaxB;
399 } else {
400 BuyOffer[i][1] = BuyOffer[i][0] + Bcons;
401 }
402 }
403 return false;
404 }
405 } else {
406 BuyOffer[i][0] = MinB + (i * 0.5);
407 BuyOffer[i][1] = MinB + (i * 0.5) + Bcons;
408 return false;
409 }
410 } else {
411 if (i > LBuy) {
412 double tmp2 = java.lang.Math.min(
413 java.lang.Math.max((SellOffer[i - 1 - LBuy][0]
414 / SellOffer[i - 1][0])
415 * BuyOffer[i - 1][0], MinB),
416 MaxB);
417 // double
418 // tmp3=java.lang.Math.min(java.lang.Math.max((BuyOffer[i-1][0]+(double)SellOffer[i-1-LBuy][0]-(double)SellOffer[i-1][0]+2),MinB),MaxB);
419 // Utl=(double)(MaxB-SellOffer[i-1])/(double)(MaxB-MinB);
420 double tmpUtl2 = (MaxB - tmp2) / (MaxB - MinB);
421 if (((float) tmpUtl2 <= (float) Utl)
422 && (CBuy == false)) {
423 // System.out.println("Accepted");
424 AcceptedValue = SellOffer[i - 1][0];
425 return true;
426
427 } else {
428
429 if (CBuy == true) {
430 BuyOffer[i][0] = inter[0];
431 BuyOffer[i][1] = BuyOffer[i][0];
432 } else {
433 BuyOffer[i][0] = tmp2;
434 if (BuyOffer[i][0] + Bcons >= MaxB) {
435 BuyOffer[i][1] = MaxB;
436 } else {
437 BuyOffer[i][1] = BuyOffer[i][0] + Bcons;
438 }
439 }
440 return false;
441 }
442 } else {
443 BuyOffer[i][0] = MinB + ((i) * 0.5);
444 BuyOffer[i][1] = MinB + ((i) * 0.5) + Bcons;
445 return false;
446 }
447 }
448 }
449 case 3:
450 // If it has reached the termiantion condition stop negotiating
451 if (i > deadlineB) {
452 // System.out.println("Finished");
453 return true;
454
455 }
456 // if it has not reached the deadline continue negotiation
457 else {
458 if (i > 0) {
459
460 Utl = (MaxB - SellOffer[i - 1][0]) / (MaxB - MinB);
461 if (CSell == false) {
462 /*
463 * if
464 * (((double)SellOffer[i-1][0]<=(double)BuyOffer[i-1][
465 * 1]) && (i<deadlineB)) {
466 * System.out.println("Accepted");
467 * AcceptedValue=SellOffer[i-1][0]; return true; }
468 */
469
470 if ((SellOffer[i - 1][1] <= BuyOffer[i - 1][1])
471 && (i <= deadlineB)) {
472 double[] xParams = new double[4];
473 if (BuyOffer[i - 1][0] == BuyOffer[i - 1][1]) {
474 CBuy = false;
475 } else {
476 double[] x = { SellOffer[i - 1][1],
477 SellOffer[i - 1][0], BuyOffer[i - 1][0],
478 BuyOffer[i - 1][1] };
479 xParams = x;
480 CBuy = true;
481 double[] yParams = { 0.0, 1.0, 1.0, 0.0 };
482 inter = Intersection(xParams, yParams);
483 double DifUtlOurs = (MaxB - BuyOffer[i - 1][0])
484 / (MaxB - MinB);
485 double MidUtl = (MaxB - inter[0])
486 / (MaxB - MinB);
487 DifUtlOurs -= MidUtl;
488 // System.out.println(inter[0]);
489 double DifUtlOps = (MaxB - SellOffer[i - 1][0])
490 / (MaxB - MinB);
491 DifUtlOps = MidUtl - DifUtlOps;
492 // System.out.println((float)DifUtlOps);
493 // System.out.println(DifUtlOurs);
494 // if ((float)DifUtlOurs<=(float)DifUtlOps){
495 CBuy = true;
496 MinB = inter[0];
497 // }
498 // else
499 // {
500 // CBuy=false;
501 // }
502
503 }
504 /*
505 * double[]
506 * xParams={SellOffer[i-1][1],SellOffer[i-1]
507 * [0],BuyOffer[i-1][0],BuyOffer[i-1][1]}; double[]
508 * yParams={0.0,1.0,1.0,0.0}; //double[] inter={};
509 * inter=Intersection(xParams, yParams); CBuy=true;
510 * MinB=BuyOffer[i-1][0]; MaxB=SellOffer[i-1][0];
511 * MinS=BuyOffer[i-1][0]; MaxS=SellOffer[i-1][0];
512 * BBuy=40; BuyOffer[i][0]=inter[0];
513 * BuyOffer[i][1]=0; return false;
514 */
515 }
516 }
517 }
518 if (CSell == true && i >= 2) {
519 double DifUtlOurs = (MaxB - BuyOffer[i - 1][0])
520 / (MaxB - MinB);
521 DifUtlOurs -= Utl;
522 double DifUtlOps = (MaxB - SellOffer[i - 1][0])
523 / (MaxB - MinB);
524 DifUtlOps = Utl - DifUtlOps;
525 if ((float) DifUtlOurs <= (float) DifUtlOps) {
526 // System.out.println("Accepted the middle value");
527 AcceptedValue = SellOffer[i - 1][0];
528 return true;
529 } else {
530 CSell = false;
531 }
532 }
533 double resource = new Double(
534 MBuy * ((double) 1 / (double) (i + 1)));
535 A = K + ((1 - K) * (1 / (java.lang.Math.exp(resource))));
536 double tmp4 = MinB + ((MaxB - MinB) * A);
537 double tmpUtl4 = (MaxB - tmp4) / (MaxB - MinB);
538 if (((float) tmpUtl4 <= (float) Utl) && (CBuy == false)) {
539 // System.out.println("Accepted");
540 AcceptedValue = SellOffer[i - 1][0];
541 return true;
542
543 } else {
544
545 if (CBuy == true) {
546 BuyOffer[i][0] = inter[0];
547 BuyOffer[i][1] = BuyOffer[i][0];
548 } else {
549 BuyOffer[i][0] = tmp4;
550 if (BuyOffer[i][0] + Bcons >= MaxB) {
551 BuyOffer[i][1] = MaxB;
552 } else {
553 BuyOffer[i][1] = BuyOffer[i][0] + Bcons;
554 }
555 }
556 return false;
557 }
558
559 }
560 }
561 return false;
562 }
563
564 protected static boolean Seller(int i) {
565 double A = 0;
566 itercount++;
567 double[] inter = {};
568 switch (tacticS) {
569 case 1:
570 // If it has reached the deadline terminate negotiaiton
571 if (i > deadlineS) {
572 // System.out.println("Finished");
573 return true;
574 }
575 // if it has not reached the deadline continue negotiation
576 else {
577 Utl = (BuyOffer[i][0] - MinS) / (MaxS - MinS);
578 if (i > 0) {
579 if (CBuy == false) {
580 /*
581 * if
582 * (((double)SellOffer[i-1][1]<=(double)BuyOffer[i][0]
583 * )&& (i<deadlineS)) { System.out.println("Accepted");
584 * AcceptedValue=BuyOffer[i-1][0]; return true; }
585 */
586 if ((SellOffer[i - 1][1] <= BuyOffer[i][1])
587 && (i <= deadlineS)) {
588 double[] xParams = new double[4];
589 if (SellOffer[i - 1][0] == SellOffer[i - 1][1]) {
590 CSell = false;
591 } else {
592 double[] x = { SellOffer[i - 1][1],
593 SellOffer[i - 1][0], BuyOffer[i][0],
594 BuyOffer[i][1] };
595 xParams = x;
596 double[] yParams = { 0.0, 1.0, 1.0, 0.0 };
597 inter = Intersection(xParams, yParams);
598 if (inter[0] >= threshholdS) {
599 CSell = true;
600 } else {
601 CSell = false;
602 }
603 }
604
605 }
606 }
607 }
608 if (BSell == 0.01 || BSell == 0.2) {
609 A = java.lang.Math.exp(java.lang.Math.pow(
610 (1 - ((double) java.lang.Math.min(i + 1, deadlineS)
611 / (double) deadlineS)),
612 (BSell)) * java.lang.Math.log(K));
613 } else {
614 A = K + ((1 - K) * (java.lang.Math
615 .pow(((double) java.lang.Math.min(i + 1, deadlineS)
616 / (double) deadlineS), (1 / BSell))));
617 }
618 double tmp = MinS + ((MaxS - MinS) * (1 - A));
619 double tmpUtl = (tmp - MinS) / (MaxS - MinS);
620 if (CBuy == true) {
621 if (BuyOffer[i][0] >= threshholdS) {
622 AcceptedValue = BuyOffer[i][0];
623 return true;
624 } else {
625 CBuy = false;
626 }
627 }
628 if (((float) tmpUtl <= (float) Utl) && (CSell == false)) {
629 // System.out.println("Accepted");
630 AcceptedValue = BuyOffer[i][0];
631 return true;
632 } else {
633
634 if (CSell == true) {
635 SellOffer[i][0] = inter[0];
636 SellOffer[i][1] = SellOffer[i][0];
637 } else {
638 SellOffer[i][0] = tmp;
639 // code added to calculate the stretch for fuzzy offers
640 if (BSellStretch == 0.01 || BSellStretch == 0.2) {
641 A = java.lang.Math.exp(java.lang.Math.pow(
642 (1 - ((double) java.lang.Math.min(i + 1,
643 deadlineS) / (double) deadlineS)),
644 (BSellStretch)) * java.lang.Math.log(K));
645 } else {
646 A = K + ((1 - K) * (java.lang.Math.pow(
647 ((double) java.lang.Math.min(i + 1,
648 deadlineS) / (double) deadlineS),
649 (1 / BSellStretch))));
650 }
651 double tmpScons = ((percentageS2 * (Scons))
652 + ((percentageS1 - percentageS2) * (Scons)
653 * (1 - A)));
654 if ((SellOffer[i][0] - tmpScons) <= MinS) {
655 SellOffer[i][1] = MinS;
656 } else {
657 SellOffer[i][1] = SellOffer[i][0] - tmpScons;
658 }
659 }
660 threshholdS = ThreshFind(deadlineS, i + 1, SellOffer[i][0],
661 SellOffer[i][1]);
662 return false;
663 }
664 }
665 case 2:
666 if (i > deadlineS) {
667 // System.out.println("Finished");
668 return true;
669 } else {
670 Utl = (BuyOffer[i][0] - MinS) / (MaxS - MinS);
671 if (i > 0) {
672 if (CBuy == false) {
673 /*
674 * if
675 * (((double)SellOffer[i-1][1]<=(double)BuyOffer[i][0]
676 * )&& (i<deadlineS)) { System.out.println("Accepted");
677 * AcceptedValue=BuyOffer[i-1][0]; return true; }
678 */
679 if ((SellOffer[i - 1][1] <= BuyOffer[i][1])
680 && (i <= deadlineS)) {
681 double[] xParams = new double[4];
682 if (SellOffer[i - 1][0] == SellOffer[i - 1][1]) {
683 CSell = false;
684 } else {
685 double[] x = { SellOffer[i - 1][1],
686 SellOffer[i - 1][0], BuyOffer[i][0],
687 BuyOffer[i][1] };
688 xParams = x;
689 CSell = true;
690 double[] yParams = { 0.0, 1.0, 1.0, 0.0 };
691 inter = Intersection(xParams, yParams);
692 double DifUtlOurs = (SellOffer[i - 1][0] - MinS)
693 / (MaxS - MinS);
694 double MinUtl = (inter[0] - MinS)
695 / (MaxS - MinS);
696 DifUtlOurs -= MinUtl;
697 double DifUtlOps = (BuyOffer[i - 1][0] - MinS)
698 / (MaxS - MinS);
699 DifUtlOps = Utl - DifUtlOps;
700 // if ((float)DifUtlOurs<=(float)DifUtlOps){
701 MaxS = inter[0];
702 CSell = true;
703 // }
704 // else
705 // {
706 // CSell=false;
707 // }
708 }
709 /*
710 * double[]
711 * xParams={SellOffer[i-1][1],SellOffer[i-1]
712 * [0],BuyOffer[i][0],BuyOffer[i][1]}; double[]
713 * yParams={0.0,1.0,1.0,0.0}; //double[] inter={};
714 * inter=Intersection(xParams, yParams); CSell=true;
715 * //MinB=BuyOffer[i-1][0];
716 * //MaxB=SellOffer[i-1][0];
717 * //MinS=BuyOffer[i-1][0];
718 * //MaxS=SellOffer[i-1][0]; //BSell=40;
719 * //SellOffer[i][0]=inter[0]; //SellOffer[i][1]=0;
720 * //return false;
721 */
722 }
723 }
724 if (CBuy == true) {
725 double DifUtlOurs = (SellOffer[i - 1][0] - MinS)
726 / (MaxS - MinS);
727 DifUtlOurs -= Utl;
728 double DifUtlOps = (BuyOffer[i - 1][0] - MinS)
729 / (MaxS - MinS);
730 DifUtlOps = Utl - DifUtlOps;
731 if ((float) DifUtlOurs <= (float) DifUtlOps) {
732 // System.out.println("Accepted");
733 AcceptedValue = BuyOffer[i][0];
734 return true;
735 } else {
736 CBuy = false;
737 }
738 }
739 }
740 if (LSell == 3) {
741 Random generator = new Random();
742 int rand = generator.nextInt(4);
743 rand = 2;
744 if (i >= LSell) {
745 double tmp3 = java.lang.Math.min(
746 java.lang.Math.max((SellOffer[i - 1][0]
747 + BuyOffer[i - LSell][0]
748 - BuyOffer[i][0] - rand), MinS),
749 MaxS);
750 double tmpUtl3 = (tmp3 - MinS) / (MaxS - MinS);
751 if (((float) tmpUtl3 <= (float) Utl)
752 && (CSell == false)) {
753 // System.out.println("Accepted");
754 AcceptedValue = BuyOffer[i][0];
755 return true;
756 } else {
757
758 if (CSell == true) {
759 SellOffer[i][0] = inter[0];
760 SellOffer[i][1] = SellOffer[i][0];
761 } else {
762 SellOffer[i][0] = tmp3;
763 if ((SellOffer[i][0] - Scons) <= MinS) {
764 SellOffer[i][1] = MinS;
765 } else {
766 SellOffer[i][1] = SellOffer[i][0] - Scons;
767 }
768 }
769 return false;
770 }
771 } else {
772 SellOffer[i][0] = MaxS - ((i) * 0.5);
773 SellOffer[i][1] = MaxS - ((i) * 0.5) - Scons;
774 return false;
775 }
776 } else {
777 if (i >= LSell) {
778
779 double tmp2 = java.lang.Math.min(java.lang.Math
780 .max((BuyOffer[i - LSell][0] / BuyOffer[i][0])
781 * SellOffer[i - 1][0], MinS),
782 MaxS);
783 Utl = (BuyOffer[i][0] - MinS) / (MaxS - MinS);
784 double tmpUtl2 = (tmp2 - MinS) / (MaxS - MinS);
785 if (((float) tmpUtl2 <= (float) Utl)
786 && (CSell == false)) {
787 // System.out.println("Accepted");
788 AcceptedValue = BuyOffer[i][0];
789 return true;
790 } else {
791
792 if (CSell == true) {
793 SellOffer[i][0] = inter[0];
794 SellOffer[i][1] = SellOffer[i][0];
795 } else {
796 SellOffer[i][0] = tmp2;
797 if ((SellOffer[i][0] - Scons) <= MinS) {
798 SellOffer[i][1] = MinS;
799 } else {
800 SellOffer[i][1] = SellOffer[i][0] - Scons;
801 }
802 }
803 return false;
804 }
805 } else {
806 SellOffer[i][0] = MaxS - ((i) * 0.5);
807 SellOffer[i][1] = MaxS - ((i) * 0.5) - Scons;
808 return false;
809 }
810
811 }
812 }
813 case 3:
814 // If it has reached the deadline terminate negotiaiton
815 if (i > deadlineS) {
816 // System.out.println("Finished");
817 return true;
818 }
819 // if it has not reached the deadline continue negotiation
820 else {
821 Utl = (BuyOffer[i][0] - MinS) / (MaxS - MinS);
822 if (i > 0) {
823 if (CBuy == false) {
824 /*
825 * if
826 * (((double)SellOffer[i-1][1]<=(double)BuyOffer[i][0]
827 * )&& (i<deadlineS)) { System.out.println("Accepted");
828 * AcceptedValue=BuyOffer[i-1][0]; return true; }
829 */
830 if ((SellOffer[i - 1][1] <= BuyOffer[i][1])
831 && (i <= deadlineS)) {
832 double[] xParams = new double[4];
833 if (SellOffer[i - 1][0] == SellOffer[i - 1][1]) {
834 CSell = false;
835 } else {
836 double[] x = { SellOffer[i - 1][1],
837 SellOffer[i - 1][0], BuyOffer[i][0],
838 BuyOffer[i][1] };
839 xParams = x;
840 CSell = true;
841 double[] yParams = { 0.0, 1.0, 1.0, 0.0 };
842 inter = Intersection(xParams, yParams);
843 double DifUtlOurs = (SellOffer[i - 1][0] - MinS)
844 / (MaxS - MinS);
845 double MinUtl = (inter[0] - MinS)
846 / (MaxS - MinS);
847 DifUtlOurs -= MinUtl;
848 double DifUtlOps = (BuyOffer[i - 1][0] - MinS)
849 / (MaxS - MinS);
850 DifUtlOps = Utl - DifUtlOps;
851 // if ((float)DifUtlOurs<=(float)DifUtlOps){
852 MaxS = inter[0];
853 CSell = true;
854 // }
855 // else
856 // {
857 // CSell=false;
858 // }
859 }
860 /*
861 * double[]
862 * xParams={SellOffer[i-1][1],SellOffer[i-1]
863 * [0],BuyOffer[i][0],BuyOffer[i][1]}; double[]
864 * yParams={0.0,1.0,1.0,0.0}; //double[] inter={};
865 * inter=Intersection(xParams, yParams); CSell=true;
866 * //MinB=BuyOffer[i-1][0];
867 * //MaxB=SellOffer[i-1][0];
868 * //MinS=BuyOffer[i-1][0];
869 * //MaxS=SellOffer[i-1][0]; //BSell=40;
870 * //SellOffer[i][0]=inter[0]; //SellOffer[i][1]=0;
871 * //return false;
872 */
873 }
874 } else if (CBuy == true) {
875 double DifUtlOurs = (SellOffer[i - 1][0] - MinS)
876 / (MaxS - MinS);
877 DifUtlOurs -= Utl;
878 double DifUtlOps = (BuyOffer[i - 1][0] - MinS)
879 / (MaxS - MinS);
880 DifUtlOps = Utl - DifUtlOps;
881 if ((float) DifUtlOurs <= (float) DifUtlOps) {
882 // System.out.println("Accepted");
883 AcceptedValue = BuyOffer[i][0];
884 return true;
885 } else {
886 CBuy = false;
887 }
888 }
889 }
890 double resource = new Double(
891 MSell * ((double) 1 / (double) (i + 1)));
892 A = K + ((1 - K) * (1 / (java.lang.Math.exp(resource))));
893 double tmp4 = MinS + ((MaxS - MinS) * (1 - A));
894 double tmpUtl4 = (tmp4 - MinS) / (MaxS - MinS);
895 if (((float) tmpUtl4 < (float) Utl) && (CSell == false)) {
896 // System.out.println("Accepted");
897 AcceptedValue = BuyOffer[i][0];
898 return true;
899 } else {
900
901 if (CSell == true) {
902 SellOffer[i][0] = inter[0];
903 SellOffer[i][1] = SellOffer[i][0];
904 } else {
905 SellOffer[i][0] = tmp4;
906 if ((SellOffer[i][0] - Scons) <= MinS) {
907 SellOffer[i][1] = MinS;
908 } else {
909 SellOffer[i][1] = SellOffer[i][0] - Scons;
910 }
911 }
912 return false;
913 }
914
915 }
916 }
917 return false;
918 }
919
920 /**
921 * Function threshfind() which receives the current time of negotiation,
922 * pick value and stretch value of the offers and generates the threshhold
923 * for each offer
924 */
925 public static double ThreshFind(int deadline, int time, double pick,
926 double stretch) {
927 double weightPick, weightStretch;
928 weightStretch = (double) time / (double) deadline;
929 weightPick = (double) (deadline - time) / (double) deadline;
930 double thresh = (weightPick * pick) + (weightStretch * stretch);
931 return thresh;
932 }
933
934 /**
935 * Function Intersection returns intersection of two lines
936 */
937 public static double[] Intersection(double[] xPars, double[] yPars) {
938 // Calculating the intersection point of the two fuzzy offers
939 double ua = 0;
940 ua = (((xPars[3] - xPars[2]) * (yPars[0] - yPars[2]))
941 - ((yPars[3] - yPars[2]) * (xPars[0] - xPars[2])))
942 / (((yPars[3] - yPars[2]) * (xPars[1] - xPars[0]))
943 - ((xPars[3] - xPars[2]) * (yPars[1] - yPars[0])));
944 double[] interPoint = new double[2];
945 interPoint[0] = xPars[0] + (ua * (xPars[1] - xPars[0]));
946 interPoint[1] = yPars[0] + (ua * (yPars[1] - yPars[0]));
947 return interPoint;
948 }
949
950 public static void FuzzyDist() {
951 double midPointXB = 0;
952 double midPointYB = 0;
953 double midPointXS = 0;
954 double midPointYS = 0;
955 // midPointXB=((double)(java.lang.Math.pow(BuyOffer[iteration-1][0],2)-java.lang.Math.pow(MinB,2))/(double)(2));
956 if (BuyOffer[iteration - 1][0] != BuyOffer[iteration - 1][1]) {
957 midPointXB += (((3
958 * (java.lang.Math.pow(BuyOffer[iteration - 1][0], 2)
959 * BuyOffer[iteration - 1][1]))
960 - java.lang.Math.pow(BuyOffer[iteration - 1][1], 3)
961 - (2 * java.lang.Math.pow(BuyOffer[iteration - 1][0], 3)))
962 / (6 * (BuyOffer[iteration - 1][0]
963 - BuyOffer[iteration - 1][1])));
964 midPointXB = midPointXB / (((2 * BuyOffer[iteration - 1][1]
965 * BuyOffer[iteration - 1][0])
966 - java.lang.Math.pow(BuyOffer[iteration - 1][1], 2)
967 - java.lang.Math.pow(BuyOffer[iteration - 1][0], 2))
968 / (2 * (BuyOffer[iteration - 1][0]
969 - BuyOffer[iteration - 1][1])));
970 midPointYB = 0.5;
971 } else {
972 midPointXB = BuyOffer[iteration - 1][0];
973 }
974 if (SellOffer[iteration - 1][0] != SellOffer[iteration - 1][1]) {
975 // midPointXS=((double)(java.lang.Math.pow(MaxS,2)-java.lang.Math.pow(SellOffer[iteration-1][0],2))/(double)(2));
976 midPointXS += (((3
977 * (java.lang.Math.pow(SellOffer[iteration - 1][1], 2)
978 * SellOffer[iteration - 1][0]))
979 - java.lang.Math.pow(SellOffer[iteration - 1][0], 3)
980 - (2 * java.lang.Math.pow(SellOffer[iteration - 1][1], 3)))
981 / (6 * (SellOffer[iteration - 1][0]
982 - SellOffer[iteration - 1][1])));
983 midPointXS = midPointXS / (((2 * SellOffer[iteration - 1][1]
984 * SellOffer[iteration - 1][0])
985 - java.lang.Math.pow(SellOffer[iteration - 1][1], 2)
986 - java.lang.Math.pow(SellOffer[iteration - 1][0], 2))
987 / (2 * (SellOffer[iteration - 1][0]
988 - SellOffer[iteration - 1][1])));
989 midPointYS = 0.5;
990 } else {
991 midPointXS = SellOffer[iteration - 1][0];
992 }
993 double last = java.lang.Math
994 .sqrt(java.lang.Math.pow((midPointXS - midPointXB), 2)
995 + java.lang.Math.pow((midPointYS - midPointYB), 2));
996 dist[iteration - 1] = last;
997 }
998
999 public static double FinalDistance(double[] dist) {
1000 double last = 0;
1001 for (int i = 0; i < iteration; i++) {
1002 last += dist[i];
1003 }
1004 return last;
1005 }
1006
1007 @Override
1008 public SupportedNegotiationSetting getSupportedNegotiationSetting() {
1009 return SupportedNegotiationSetting.getLinearUtilitySpaceInstance();
1010 }
1011
1012 @Override
1013 public String getDescription() {
1014 return "Fuzzy negotiator";
1015 }
1016
1017}
Note: See TracBrowser for help on using the repository browser.