Created by sophie on 10.01.17. More...

Collaboration diagram for org.lightvoting.simulation.rule.CMinisumApproval:

Public Member Functions
BitVector	applyRuleBV (final List< String > p_alternatives, final List< BitVector > p_votes, final int p_comSize)
	compute the winning committee according to Minisum Approval More...

Map< Integer, Integer >	sortMapDESC (final Map< Integer, Integer > p_valuesMap)
	sort HashMap according to its values in descending order More...

Private Attributes
List< String >	m_alternatives

List< BitVector >	m_bitVotes

BitVector	m_comBV

int	m_comSize

Detailed Description

Computes result of election according to Minisum Approval voting rule. re-used code from http://stackoverflow.com/questions/8119366/sorting-hashmap-by-values

Definition at line 47 of file CMinisumApproval.java.

Member Function Documentation

BitVector org.lightvoting.simulation.rule.CMinisumApproval.applyRuleBV	(	final List< String >	p_alternatives,
		final List< BitVector >	p_votes,
		final int	p_comSize
	)

Parameters

p_alternatives	available alternatives
p_votes	submitted votes
p_comSize	size of committee to be elected

Returns: elected committee

Definition at line 68 of file CMinisumApproval.java.

References org.lightvoting.simulation.rule.CMinisumApproval.m_alternatives, org.lightvoting.simulation.rule.CMinisumApproval.m_bitVotes, org.lightvoting.simulation.rule.CMinisumApproval.m_comBV, and org.lightvoting.simulation.rule.CMinisumApproval.m_comSize.

     {
         m_alternatives = p_alternatives;
         m_comSize = p_comSize;
         m_bitVotes = p_votes;
         m_comBV = new BitVector( m_alternatives.size() );
 
         final int[] l_valuesVect = new int[m_alternatives.size()];
 
         Map<Integer, Integer> l_valuesMap = new HashMap<Integer, Integer>();
         for ( int i = 0; i < m_alternatives.size(); i++ )
         {
             for ( int j = 0; j < m_bitVotes.size(); j++ )
             {
                 if ( ( m_bitVotes.get( j ) ).get( i ) )
                 {
                     l_valuesVect[i]++;
                 }
             }
 
             /* create HashMap with index of alternative as key and score of alternative as value */
 
             l_valuesMap.put( i, l_valuesVect[i] );
         }
 
         /* sort the HashMap in descending order according to values */
 
         l_valuesMap = this.sortMapDESC( l_valuesMap );
 
         /* create committee vector according to sorted HashMap: For the first k entries, put a "1" in the position according to the index, i.e. the key.*/
 
         int l_occupied = 0;
 
         for ( final Entry<Integer, Integer> l_entry : l_valuesMap.entrySet() )
         {
             if ( l_occupied < m_comSize )
             {
                 m_comBV.put( l_entry.getKey(), true );
                 l_occupied++;
             }
             else
                 break;
         }
 
         return m_comBV;
     }

Map<Integer, Integer> org.lightvoting.simulation.rule.CMinisumApproval.sortMapDESC ( final Map< Integer, Integer > p_valuesMap )

Parameters

p_valuesMap HashMap with Approval scores

Returns: sorted HashMap

Definition at line 121 of file CMinisumApproval.java.

     {
         final List<Entry<Integer, Integer>> l_list = new LinkedList<>( p_valuesMap.entrySet() );
 
         /* Sorting the list based on values in descending order */
         Collections.sort( l_list, ( p_first, p_second ) ->
             p_second.getValue().compareTo( p_first.getValue() ) );
 
         /* Maintaining insertion order with the help of LinkedList */
         final Map<Integer, Integer> l_sortedMap = new LinkedHashMap<Integer, Integer>();
         for ( final Entry<Integer, Integer> l_entry : l_list )
         {
             l_sortedMap.put( l_entry.getKey(), l_entry.getValue() );
         }
 
         return l_sortedMap;
     }