Changeset 22 for voting/src/main

Timestamp:

09/22/20 16:26:36 (4 years ago)

Author:

bart

Message:

Minor fixes

File:

• voting/src/main/java/geniusweb/voting/CollectedVotes.java (modified) (7 diffs)

voting/src/main/java/geniusweb/voting/CollectedVotes.java

@@ -4 +4 @@
 import java.util.HashMap;
 import java.util.HashSet;
-import java.util.List;
 import java.util.Map;
 import java.util.Set;
-import java.util.stream.Collectors;
 
 import geniusweb.actions.PartyId;
@@ -31 +29 @@
          * 
          * @param votesMap the {@link Votes} done for each party
-         * @param power  the power of each party. The power is an integer number. In
-         *               the voting process, the party powers add up to form the
-         *               total voting power. This set may contain parties that are
-         *               not in newmap.
+         * @param power    the power of each party. The power is an integer number.
+         *                 In the voting process, the party powers add up to form
+         *                 the total voting power. This set may contain parties that
+         *                 are not in newmap.
          */
         public CollectedVotes(Map<PartyId, Votes> votesMap,
@@ -132 +130 @@
          * @param votes a list of all votes for a particular bid. The parties that
          *              placed the votes are called 'voters'
-         * @return a subset of the voters for which holds (1) the min-power
-         *         condition of all these voters is satisfied (2) the power of this
-         *         subset of voters is maximal (no other satisfied set of voters
-         *         with bigger power exists) maximum-power that placed votes with
-         *         holding conditions.This algorithm works in quadratic time.
+         * @return a consensusgroup with maximum power, so there is no other
+         *         consensus group that has more power (but there may be other
+         *         groups with same power).
          */
         protected Set<PartyId> getMaxPowerGroup(Set<Vote> votes) {
@@ -142 +138 @@
                 Integer maxpower = 0;
 
-                for (Vote vote : votes) {
-                        int target = vote.getMinPower();
-
-                        // find parties that would join if we reach that power
-                        Set<PartyId> group = votes.stream()
-                                        .filter(v -> target >= v.getMinPower())
-                                        .map(v -> v.getActor()).collect(Collectors.toSet());
-                        // check what the group's power is
-                        Integer groupPower = getTotalPower(group);
-                        if (groupPower >= target && groupPower > maxpower) {
-                                maxgroup = group;
-                                maxpower = groupPower;
+                for (Set<PartyId> parties : getConsensusGroups(votes)) {
+                        Integer power = getTotalPower(parties);
+                        if (power > maxpower) {
+                                maxgroup = parties;
+                                maxpower = power;
                         }
                 }
@@ -169 +158 @@
          *         input size.
          */
-        protected Set<Set<PartyId>> getConsensusGroups(List<Vote> votes) {
+        protected Set<Set<PartyId>> getConsensusGroups(Set<Vote> votes) {
                 Set<Set<PartyId>> groups = new HashSet<>();
 
@@ -177 +166 @@
                 for (ImmutableList<Vote> voteList : allVotePermutations) {
                         Set<PartyId> parties = getParties(voteList);
-                        if (parties.size() >= 2
-                                        && getTotalPower(parties) >= getMinPower(voteList)) {
+                        Integer totalpower = getTotalPower(parties);
+                        if (parties.size() >= 2 && totalpower >= getMinPower(voteList)
+                                        && totalpower <= getMaxPower(voteList)) {
                                 groups.add(parties);
                         }
@@ -210 +200 @@
                 }
                 return max;
+        }
+
+        /**
+         * 
+         * @param votes a list of {@link Vote}s on one Bid. All parties must be
+         *              known
+         * @return the maximum voting power needed for this group, so that all can
+         *         accept. This is equal to the min of the vote.getMaxPower
+         */
+        private Integer getMaxPower(ImmutableList<Vote> votes) {
+                int min = Integer.MAX_VALUE;
+                for (Vote vote : votes) {
+                        min = Math.min(min, vote.getMaxPower());
+                }
+                return min;
         }