Changeset 53 for exampleparties/timedependentparty

Timestamp:

12/18/24 13:28:59 (4 days ago)

Author:

ruud

Message:

All TimeDependent parties now support the nonlinear SumOfGroupsUtilitySpace. Example Nonlinear space in the computer domain

Location:

exampleparties/timedependentparty

Files:

• pom.xml (modified) (2 diffs)
• src/main/java/geniusweb/exampleparties/timedependentparty/ExtendedUtilSpace.java (modified) (6 diffs)
• src/main/java/geniusweb/exampleparties/timedependentparty/TimeDependentParty.java (modified) (2 diffs)
• src/test/java/geniusweb/exampleparties/timedependentparty/ExtendedUtilSpaceTest.java (modified) (5 diffs)
• src/test/resources/computer (added)
• src/test/resources/computer/computerbuy.json (added)

exampleparties/timedependentparty/pom.xml

@@ -6 +6 @@
         <groupId>geniusweb.exampleparties</groupId>
         <artifactId>timedependentparty</artifactId>
-        <version>2.1.6</version>  <!-- equals the geniusweb version -->
+        <version>2.2.1</version>  <!-- equals the geniusweb version -->
         <packaging>jar</packaging>
 
@@ -53 +53 @@
                         <groupId>tudelft.utilities</groupId>
                         <artifactId>utilities</artifactId>
-                        <version>1.2.1</version>
+                        <version>1.3.1</version>
                 </dependency>
 

exampleparties/timedependentparty/src/main/java/geniusweb/exampleparties/timedependentparty/ExtendedUtilSpace.java

@@ -9 +9 @@
 import geniusweb.bidspace.Interval;
 import geniusweb.bidspace.IssueInfo;
+import geniusweb.bidspace.SumOfGroupsLinAdditiveAdapter;
 import geniusweb.issuevalue.Bid;
 import geniusweb.issuevalue.Value;
 import geniusweb.profile.utilityspace.LinearAdditive;
+import geniusweb.profile.utilityspace.SumOfGroupsUtilitySpace;
+import geniusweb.profile.utilityspace.UtilitySpace;
 import tudelft.utilities.immutablelist.ImmutableList;
+import tudelft.utilities.immutablelist.MapList;
 
 /**
- * Inner class for TimeDependentParty, made public for testing purposes. This
- * class may change in the future, use at your own risk.
+ * Inner class for TimeDependentParty, Handles mechanisms for searching the bid
+ * space, and using adapters to handle the nonlinear
+ * {@link SumOfGroupsUtilitySpace}.
+ * 
+ * This class is public for testing purposes. This class may change in the
+ * future, use at your own risk.
  *
  */
 public class ExtendedUtilSpace {
-        private LinearAdditive utilspace;
+        private UtilitySpace utilspace;
+        // linear approximation of utilspace (possibly utilspace itself)
+        // thsi may have different utilityes issues and values than utilspace.
+        private LinearAdditive linapprox;
+
+        // bidutils tolerance minUtil maxUtil all work on linapprox
+        private BidsWithUtility bidutils;
         /**
          * The tolerance for a utility. Generally utilities can be this amount
@@ -26 +40 @@
          */
         private BigDecimal tolerance;
-        private BidsWithUtility bidutils;
         // min and max achievable utility
         private BigDecimal minUtil;
         private BigDecimal maxUtil;
 
-        public ExtendedUtilSpace(LinearAdditive space) {
+        public ExtendedUtilSpace(UtilitySpace space) {
                 this.utilspace = space;
-                bidutils = new BidsWithUtility(utilspace);
+                if (space instanceof LinearAdditive)
+                        linapprox = (LinearAdditive) space;
+                else
+                        linapprox = SumOfGroupsLinAdditiveAdapter
+                                        .create((SumOfGroupsUtilitySpace) space);
+                bidutils = new BidsWithUtility(linapprox);
                 computeMinMax();
                 this.tolerance = computeTolerance();
-
         }
 
@@ -52 +69 @@
                 this.maxUtil = range.getMax();
 
-                Bid rvbid = utilspace.getReservationBid();
+                Bid rvbid = linapprox.getReservationBid();
                 if (rvbid != null) {
-                        BigDecimal rv = utilspace.getUtility(rvbid);
+                        BigDecimal rv = linapprox.getUtility(rvbid);
                         if (rv.compareTo(minUtil) > 0)
                                 minUtil = rv;
@@ -65 +82 @@
          * best and one-but-best utility.
          * 
-         * @return the minimum tolerance required, which is the minimum difference
-         *         between the weighted utility of the best and one-but-best issue
-         *         value.
+         * @return the minimum tolerance required in the {@link #linapprox} space,
+         *         which is the minimum difference between the weighted utility of
+         *         the best and one-but-best issue value.
          */
         protected BigDecimal computeTolerance() {
@@ -87 +104 @@
         }
 
+        /**
+         * @return the minimum utility in the {@link #linapprox} space
+         */
         public BigDecimal getMin() {
                 return minUtil;
         }
 
+        /**
+         * @return the maximum utility in the {@link #linapprox} space
+         */
         public BigDecimal getMax() {
                 return maxUtil;
@@ -96 +119 @@
 
         /**
-         * @param utilityGoal the requested utility
+         * @param utilityGoal the requested utility in the {@link #linapprox} space
          * @return bids with utility inside [utilitygoal-{@link #tolerance},
-         *         utilitygoal]
+         *         utilitygoal], converted back to bids in the utilspace
          */
         public ImmutableList<Bid> getBids(BigDecimal utilityGoal) {
-                return bidutils.getBids(
+                ImmutableList<Bid> bidslist = bidutils.getBids(
                                 new Interval(utilityGoal.subtract(tolerance), utilityGoal));
+                return new MapList<>((Bid b) -> realBid(b), bidslist);
+        }
+
+        /**
+         * @param b a bid in the linapprox space
+         * @return a bid in the original space
+         */
+        private Bid realBid(Bid b) {
+                if (linapprox instanceof SumOfGroupsLinAdditiveAdapter)
+                        return ((SumOfGroupsLinAdditiveAdapter) linapprox).toGroupBid(b);
+                return b;
         }
 

exampleparties/timedependentparty/src/main/java/geniusweb/exampleparties/timedependentparty/TimeDependentParty.java

@@ -74 +74 @@
  * </table>
  * <p>
- * TimeDependentParty requires a {@link UtilitySpace}
+ * TimeDependentParty requires a {@link LinearAdditive} utilityspace.
  */
 public class TimeDependentParty extends DefaultParty {
 
         private ProfileInterface profileint = null;
-        private LinearAdditive utilspace = null; // last received space
+        private UtilitySpace utilspace = null; // last received space
         private PartyId me;
         private Progress progress;
@@ -238 +238 @@
         }
 
-        private LinearAdditive updateUtilSpace() throws IOException {
+        private UtilitySpace updateUtilSpace() throws IOException {
                 Profile newutilspace = profileint.getProfile();
                 if (!newutilspace.equals(utilspace)) {
-                        utilspace = (LinearAdditive) newutilspace;
+                        utilspace = (UtilitySpace) newutilspace;
                         extendedspace = new ExtendedUtilSpace(utilspace);
                 }

exampleparties/timedependentparty/src/test/java/geniusweb/exampleparties/timedependentparty/ExtendedUtilSpaceTest.java

@@ -1 +1 @@
 package geniusweb.exampleparties.timedependentparty;
 
-import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.assertEquals;
 
 import java.io.IOException;
-import java.math.BigDecimal;
 import java.nio.file.Files;
 import java.nio.file.Paths;
@@ -19 +18 @@
 
 import geniusweb.profile.Profile;
-import geniusweb.profile.utilityspace.LinearAdditiveUtilitySpace;
+import geniusweb.profile.utilityspace.UtilitySpace;
 
 @RunWith(Parameterized.class)
 public class ExtendedUtilSpaceTest {
         private final static ObjectMapper jackson = new ObjectMapper();
-        private final static BigDecimal SMALL = new BigDecimal("0.0001");
+        private final static double SMALL = 0.0001;
 
         @Parameters
@@ -31 +30 @@
                                 { "src/test/resources/jobs/jobs1.json", 0.02 },
                                 { "src/test/resources/7issues/7issues1.json", 0.0055 },
-                                { "src/test/resources/9issues/9issues1.json", 0.0013 } });
+                                { "src/test/resources/9issues/9issues1.json", 0.0013 },
+                                // tolerance in computerbuy is quite small because approximation
+                                // scales the space
+                                { "src/test/resources/computer/computerbuy.json", 0.0016 } });
         }
 
         private String filename;
-        private BigDecimal expectedTolerance;
+        private double expectedTolerance;
         private ExtendedUtilSpace space;
 
         public ExtendedUtilSpaceTest(String filename, double expectedTolerance) {
                 this.filename = filename;
-                this.expectedTolerance = BigDecimal.valueOf(expectedTolerance);
+                this.expectedTolerance = expectedTolerance;
         }
 
@@ -46 +48 @@
         public void before() throws IOException {
                 String file = new String(Files.readAllBytes(Paths.get(filename)));
-                LinearAdditiveUtilitySpace profile = (LinearAdditiveUtilitySpace) jackson
-                                .readValue(file, Profile.class);
+                UtilitySpace profile = (UtilitySpace) jackson.readValue(file,
+                                Profile.class);
                 space = new ExtendedUtilSpace(profile);
         }
@@ -58 +60 @@
         @Test
         public void testTolerance() {
-                assertTrue(space.computeTolerance().subtract(expectedTolerance).abs()
-                                .compareTo(SMALL) < 0);
+                assertEquals(expectedTolerance, space.computeTolerance().doubleValue(),
+                                SMALL);
         }
 }