Changeset 53 for exampleparties/timedependentparty/src/main

Timestamp:

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

Author:

ruud

Message:

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

Location:

exampleparties/timedependentparty/src/main/java/geniusweb/exampleparties/timedependentparty

Files:

• ExtendedUtilSpace.java (modified) (6 diffs)
• TimeDependentParty.java (modified) (2 diffs)

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);
                 }