Changeset 53 for bidspace/src/main

Timestamp:

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

Author:

ruud

Message:

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

Location:

bidspace/src/main/java/geniusweb/bidspace

Files:

• BidsWithUtility.java (modified) (4 diffs)
• PartialSpaceFromUtility.java (modified) (3 diffs)
• SumOfGroupsLinAdditiveAdapter.java (added)

bidspace/src/main/java/geniusweb/bidspace/BidsWithUtility.java

@@ -3 +3 @@
 import java.math.BigDecimal;
 import java.math.BigInteger;
+import java.util.Arrays;
 import java.util.Collections;
 import java.util.HashMap;
@@ -39 +40 @@
          */
         private final Map<Tuple<Integer, Interval>, ImmutableList<Bid>> cache = new HashMap<>();
-        private ImmutableList<Bid> emptylist = new FixedList<>();
+        private ImmutableList<Bid> emptylist = new FixedList<>(
+                        Collections.emptyList());
 
         /**
@@ -176 +178 @@
                 goal = goal.intersect(getRange(n));
                 if (goal.isEmpty()) {
-                        return new FixedList<>();
+                        return new FixedList<>(Collections.emptyList());
                 }
 
@@ -220 +222 @@
                                         pbid -> pbid.merge(new Bid(issue, val)), partialbids);
                         if (!fullbids.size().equals(BigInteger.ZERO))
-                                fulllist = new JoinedList<Bid>(fullbids, fulllist);
+                                fulllist = new JoinedList<Bid>(
+                                                Arrays.asList(fullbids, fulllist));
                 }
                 return fulllist;

bidspace/src/main/java/geniusweb/bidspace/PartialSpaceFromUtility.java

@@ -3 +3 @@
 import java.math.BigInteger;
 import java.security.SecureRandom;
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
@@ -24 +25 @@
 public class PartialSpaceFromUtility extends DefaultPartialOrdering {
         public PartialSpaceFromUtility(UtilitySpace space, int nRankings) {
-                super(space.getName() + "_" + nRankings, space.getDomain(), space.getReservationBid(),
-                                pickBetter(space, nRankings));
+                super(space.getName() + "_" + nRankings, space.getDomain(),
+                                space.getReservationBid(), pickBetter(space, nRankings));
         }
 
         /**
-         * Pick subset of static isbetter rankings. Notice, ShuffledList currently can't
-         * handle really large lists which also limits this. This has to be fixed.
+         * Pick subset of static isbetter rankings. Notice, ShuffledList currently
+         * can't handle really large lists which also limits this. This has to be
+         * fixed.
          * 
          * @param space     the space to sample from
-         * @param nRankings the number of rankings to be placed in the PartialOrdering.
+         * @param nRankings the number of rankings to be placed in the
+         *                  PartialOrdering.
          * @return a subset creating a partial profile of the geiven UtilitySpace
          */
-        private static Map<Bid, Set<Bid>> pickBetter(UtilitySpace space, int nRankings) {
+        private static Map<Bid, Set<Bid>> pickBetter(UtilitySpace space,
+                        int nRankings) {
                 Map<Bid, Set<Bid>> eqOrBetter = new HashMap<>();
 
                 AllBidsList allbids = new AllBidsList(space.getDomain());
-                ListWithRemove<Tuple<Bid, Bid>> available = new ListWithRemove<>(new Tuples<Bid, Bid>(allbids, allbids));
+                ListWithRemove<Tuple<Bid, Bid>> available = new ListWithRemove<>(
+                                new Tuples<Bid, Bid>(allbids, allbids), Collections.emptySet());
                 for (int n = 0; n < nRankings; n++) {
                         BigInteger sel = rnd(available.size());
@@ -79 +84 @@
 
         /**
-         * Bit simplistic way to generate random in [0,n>. Simplistic because the mod()
-         * operator that we use causes bias in the random numbers.
+         * Bit simplistic way to generate random in [0,n>. Simplistic because the
+         * mod() operator that we use causes bias in the random numbers.
          * 
          * @param n the maximum value for the random number