org.lightvoting.simulation.rule.CMinimaxApproval Class Reference

Created by sophie on 10.01.17. More...

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

Public Member Functions
BitVector	applyRuleBV (final List< String > p_alternatives, final List< BitVector > p_votes, final int p_comSize)
Map< Integer, Integer >	sortMapASC (final Map< Integer, Integer > p_valuesMap)
	sort HashMap according to its values in ascending order More...

Private Member Functions
List< BitVector >	computeBitComittees (final int p_altNum, final int p_comSize)
	compute possible committees More...
int	determineMaxHDBV (final List< BitVector > p_votes, final BitVector p_comVect, final int p_altNum)

Detailed Description

re-used code from http://stackoverflow.com/questions/8119366/sorting-hashmap-by-values

Definition at line 42 of file CMinimaxApproval.java.

Member Function Documentation

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

Definition at line 54 of file CMinimaxApproval.java.

    {
        /* compute all possible committees, i.e. all {0,1}^m vectors with exactly k ones */

        final List<BitVector> l_bitCommittees = this.computeBitComittees( p_alternatives.size(), p_comSize );
        System.out.println( l_bitCommittees );

        /* Hashmap for storing the maximal hamming distance to any vote for all committees */

        Map<Integer, Integer> l_maxMap = new HashMap<Integer, Integer>();

        for ( int i = 0; i < l_bitCommittees.size(); i++ )
        {
            /* Key: Committee ID, Value: maximal Hamming distance to any voter */
            l_maxMap.put(  i, this.determineMaxHDBV( p_votes, l_bitCommittees.get( i ), p_alternatives.size() ) );
        }

        l_maxMap = this.sortMapASC( l_maxMap );

        return l_bitCommittees.get( l_maxMap.entrySet().iterator().next().getKey() );

    }

List<BitVector> org.lightvoting.simulation.rule.CMinimaxApproval.computeBitComittees ( final int  p_altNum, final int  p_comSize  )

private

Parameters

p_altNum	number of alternatives
p_comSize	committee size

Returns

possible committees

Definition at line 84 of file CMinimaxApproval.java.

    {
        final CCombination l_combination = new CCombination();
        final int[] l_arr = new int[p_altNum];

        for ( int i = 0; i < p_altNum; i++ )
            l_arr[i] = i;

        l_combination.combinations( l_arr, p_comSize, 0, new int[p_comSize] );

        final List<int[]> l_resultList = l_combination.getResultList();

        final List<BitVector> l_bitVectors = new LinkedList<>();

        for ( int i = 0; i < l_resultList.size(); i++ )
        {
            final BitVector l_bitVector = new BitVector( p_altNum );

            for ( int j = 0; j < p_comSize; j++ )
            {
                l_bitVector.put( l_resultList.get( i )[j], true );
            }
            l_bitVectors.add( l_bitVector );
        }

        return l_bitVectors;
    }

int org.lightvoting.simulation.rule.CMinimaxApproval.determineMaxHDBV ( final List< BitVector >  p_votes, final BitVector  p_comVect, final int  p_altNum  )

private

Definition at line 112 of file CMinimaxApproval.java.

    {
        /* compute Hamming distances to all votes and determine the maximum */

        int l_maxHD = -1;

        for ( int i = 0; i < p_votes.size(); i++ )
        {
            final BitVector l_curBitCom = p_comVect.copy();

            l_curBitCom.xor( p_votes.get( i ) );

            final int l_curHD = l_curBitCom.cardinality();

            if ( l_curHD > l_maxHD )
                l_maxHD = l_curHD;
        }
        System.out.println( " maximal HD for committee " + p_comVect + ": " + l_maxHD );
        return l_maxHD;
    }

Map<Integer, Integer> org.lightvoting.simulation.rule.CMinimaxApproval.sortMapASC

(

final Map< Integer, Integer >

p_valuesMap

)

Parameters

p_valuesMap

HashMap with Approval scores

Returns

sorted HashMap

Definition at line 141 of file CMinimaxApproval.java.

    {
        final List<Map.Entry<Integer, Integer>> l_list = new LinkedList<>( p_valuesMap.entrySet() );

        // Sorting the list based on values in ascending order
        Collections.sort( l_list, Comparator.comparing( Map.Entry::getValue ) );

        /* Maintaining insertion order with the help of LinkedList */
        final Map<Integer, Integer> l_sortedMap = new LinkedHashMap<Integer, Integer>();
        for ( final Map.Entry<Integer, Integer> l_entry : l_list )
        {
            l_sortedMap.put( l_entry.getKey(), l_entry.getValue() );
        }

        return l_sortedMap;
    }