BOL::BalancedPartitioner< ClassToBeSorted > Class Template Reference

#include <BalancedPartitioner.hpp>

Detailed Description

template<typename ClassToBeSorted>
class BOL::BalancedPartitioner< ClassToBeSorted >

Definition at line 38 of file BalancedPartitioner.hpp.

Public Member Functions
	BalancedPartitioner (double(*weightGetter)(ClassToBeSorted const &))
double	getHigherWeight () const
std::vector< unsigned int > const &	getHigherWeightPartitionIndices () const
double	getLowerWeight () const
std::vector< unsigned int > const &	getLowerWeightPartitionIndices () const
void	makeMinimumDifferencePartition (std::vector< ClassToBeSorted > const &vectorToBeSorted)
	~BalancedPartitioner ()

Protected Types
typedef std::list< BalancedPartitionCandidate * >::iterator	CandidateListIterator
typedef std::vector< unsignedint >::const_iterator	CandidateVectorConstIterator
typedef std::vector< ClassToBeSorted >::iterator	ClassToBeSortedIterator
typedef std::pair< unsigned int, double >	IndexWithWeight
typedef std::list< IndexWithWeight >::const_iterator	IndexWithWeightListConstIterator
typedef std::list< IndexWithWeight >::iterator	IndexWithWeightListIterator

Protected Member Functions
void	clearSavedCandidates ()
void	fillVectorFromBestCandidate (std::vector< unsigned int > &partitionToBeMade)
void	makeOtherPartition (std::vector< unsigned int > &partitionToBeMade, std::vector< unsigned int > &partitionAlreadyMade)

Static Protected Member Functions
static bool	orderByDouble (IndexWithWeight const &firstPair, IndexWithWeight const &secondPair)

Protected Attributes
BalancedPartitionCandidate *	bestCandidateSoFar
std::list< BalancedPartitionCandidate * >	candidatesToBuildOn
BalancedPartitionCandidate *	currentCandidate
double	currentWeight
std::list< BalancedPartitionCandidate * >	extraCandidates
double	higherWeight
std::vector< unsigned int >	higherWeightPartition
double	lowerWeight
std::vector< unsigned int >	lowerWeightPartition
std::list< IndexWithWeight >	orderedList
double	positiveWeight
unsigned int	sizeOfVectorToSort
VectorlikeArray< BalancedPartitionCandidate >	vectorManagingCandidateMemory
double(*	weightGetter )(ClassToBeSorted const &)
double	weightSum

Member Typedef Documentation

CandidateListIterator

template<typename ClassToBeSorted >

typedef std::list<BalancedPartitionCandidate*>::iterator BOL::BalancedPartitioner< ClassToBeSorted >::CandidateListIterator

protected

Definition at line 92 of file BalancedPartitioner.hpp.

CandidateVectorConstIterator

template<typename ClassToBeSorted >

typedef std::vector<unsignedint>::const_iterator BOL::BalancedPartitioner< ClassToBeSorted >::CandidateVectorConstIterator

protected

Definition at line 95 of file BalancedPartitioner.hpp.

ClassToBeSortedIterator

template<typename ClassToBeSorted >

typedef std::vector<ClassToBeSorted>::iterator BOL::BalancedPartitioner< ClassToBeSorted >::ClassToBeSortedIterator

protected

Definition at line 90 of file BalancedPartitioner.hpp.

IndexWithWeight

template<typename ClassToBeSorted >

typedef std::pair< unsigned int, double > BOL::BalancedPartitioner< ClassToBeSorted >::IndexWithWeight

protected

Definition at line 83 of file BalancedPartitioner.hpp.

IndexWithWeightListConstIterator

template<typename ClassToBeSorted >

typedef std::list<IndexWithWeight>::const_iterator BOL::BalancedPartitioner< ClassToBeSorted >::IndexWithWeightListConstIterator

protected

Definition at line 88 of file BalancedPartitioner.hpp.

IndexWithWeightListIterator

template<typename ClassToBeSorted >

typedef std::list<IndexWithWeight>::iterator BOL::BalancedPartitioner< ClassToBeSorted >::IndexWithWeightListIterator

protected

Definition at line 85 of file BalancedPartitioner.hpp.

Constructor & Destructor Documentation

BalancedPartitioner()

template<typename ClassToBeSorted >

BOL::BalancedPartitioner< ClassToBeSorted >::BalancedPartitioner ( double(*)(ClassToBeSorted const &)  weightGetter )

inline

Definition at line 148 of file BalancedPartitioner.hpp.

                                                                              :
      sizeOfVectorToSort( 0 ),
      lowerWeightPartition(),
      lowerWeight( 0.0 ),
      higherWeightPartition(),
      higherWeight( 0.0 ),
      weightGetter( weightGetter ),
      weightSum( 0.0 ),
      positiveWeight( 0.0 ),
      orderedList(),
      currentCandidate( NULL ),
      bestCandidateSoFar( NULL ),
      currentWeight( 0.0 ),
      vectorManagingCandidateMemory(),
      candidatesToBuildOn(),
      extraCandidates()
  {
    // just an initialization list.
  }

~BalancedPartitioner()

template<typename ClassToBeSorted >

BOL::BalancedPartitioner< ClassToBeSorted >::~BalancedPartitioner ( )

inline

Definition at line 171 of file BalancedPartitioner.hpp.

  {
    // does nothing.
  }

Member Function Documentation

clearSavedCandidates()

template<typename ClassToBeSorted >

void BOL::BalancedPartitioner< ClassToBeSorted >::clearSavedCandidates ( )

inlineprotected

Definition at line 582 of file BalancedPartitioner.hpp.

  {
    lowerWeightPartition.clear();
    higherWeightPartition.clear();
    orderedList.clear();
    vectorManagingCandidateMemory.clearEntries();
    candidatesToBuildOn.clear();
  }

fillVectorFromBestCandidate()

template<typename ClassToBeSorted >

void BOL::BalancedPartitioner< ClassToBeSorted >::fillVectorFromBestCandidate ( std::vector< unsigned int > &  partitionToBeMade )

inlineprotected

Definition at line 611 of file BalancedPartitioner.hpp.

  {
    partitionToBeMade = bestCandidateSoFar->getVector();
  }

getHigherWeight()

template<typename ClassToBeSorted >

double BOL::BalancedPartitioner< ClassToBeSorted >::getHigherWeight ( ) const

inline

Definition at line 573 of file BalancedPartitioner.hpp.

  {
    return higherWeight;
  }

getHigherWeightPartitionIndices()

template<typename ClassToBeSorted >

std::vector< unsigned int > const & BOL::BalancedPartitioner< ClassToBeSorted >::getHigherWeightPartitionIndices ( ) const

inline

Definition at line 555 of file BalancedPartitioner.hpp.

  {
    return higherWeightPartition;
  }

getLowerWeight()

template<typename ClassToBeSorted >

double BOL::BalancedPartitioner< ClassToBeSorted >::getLowerWeight ( ) const

inline

Definition at line 546 of file BalancedPartitioner.hpp.

  {
    return lowerWeight;
  }

getLowerWeightPartitionIndices()

template<typename ClassToBeSorted >

std::vector< unsigned int > const & BOL::BalancedPartitioner< ClassToBeSorted >::getLowerWeightPartitionIndices ( ) const

inline

Definition at line 528 of file BalancedPartitioner.hpp.

  {
    return lowerWeightPartition;
  }

makeMinimumDifferencePartition()

template<typename ClassToBeSorted >

void BOL::BalancedPartitioner< ClassToBeSorted >::makeMinimumDifferencePartition ( std::vector< ClassToBeSorted > const &  vectorToBeSorted )

inline

Definition at line 178 of file BalancedPartitioner.hpp.

  {
    // 1st, we remove all the stuff that might have been hanging around since
    // the last partitioning:
    clearSavedCandidates();
    weightSum = 0.0;
 
    sizeOfVectorToSort = vectorToBeSorted.size();
    // next we make a list of the objects with the weights (absolute values, &
    // we also ignore any objects with zero weight) & find the total weight:
    for( unsigned int whichIndex( 0 );
         sizeOfVectorToSort > whichIndex;
         ++whichIndex )
    {
      positiveWeight = (*weightGetter)( vectorToBeSorted[ whichIndex ] );
      if( 0.0 > positiveWeight )
      {
        positiveWeight = -positiveWeight;
      }
      if( 0.0 < positiveWeight )
      {
        weightSum += positiveWeight;
        orderedList.push_back( IndexWithWeight( whichIndex,
                                                positiveWeight ) );
      }
    }
 
    double const halfTotalWeight( 0.5 * weightSum );
    if( orderedList.empty() )
      // if the given set didn't have enough objects to sort...
    {
      // the vectors that get returned have already been cleared.
      lowerWeight = 0.0;
      higherWeight = 0.0;
    }
    else
    {
      orderedList.sort( &orderByDouble );
      // now orderedList is all the objects with non-zero weight, ordered by
      // their absolute weights.
 
      if( halfTotalWeight <= orderedList.back().second )
      // if the object with greatest weight takes up half or more of the
      // total weight by itself...
      {
        // it alone becomes higherWeightPartition.
        higherWeightPartition.push_back( orderedList.back().first );
        higherWeight = orderedList.back().second;
        lowerWeight = ( weightSum - higherWeight );
        makeOtherPartition( lowerWeightPartition,
                            higherWeightPartition );
      }
      else if( orderedList.size() < 4 )
        // or if the given set was too small to have any non-trivial
        // partitions...
      {
        // the object with greatest weight alone becomes lowerWeightPartition
        // (if it should become higherWeightPartition, it'll have happened in
        // the previous if statement):
        lowerWeightPartition.push_back( orderedList.back().first );
        lowerWeight = orderedList.back().second;
        higherWeight = ( weightSum - lowerWeight );
        makeOtherPartition( higherWeightPartition,
                            lowerWeightPartition );
      }
      else
      // otherwise, we need to check all the required combinations (partitions
      // of sizes up to half the number of objects, with weights less than half
      // the total weight, *plus* cases where the weight is over half the total
      // weight, if removing a single element would bring it back under half
      // the total weight):
      {
        // 1st we note that the highest-weight element on its own is still the
        // leading candidate partition:
        bestCandidateSoFar = &(vectorManagingCandidateMemory.newEnd());
        bestCandidateSoFar->getVector().assign( 1,
                                                orderedList.back().first );
        lowerWeight = orderedList.back().second;
        higherWeight = ( weightSum - lowerWeight );
        bestCandidateSoFar->setWeight( lowerWeight );
        bestCandidateSoFar->setInverseWeight( higherWeight );
        // now bestCandidate so far is the highest-weight element on its own, &
        // vectorManagingCandidateMemory is holding a pointer to it in case the
        // bestCandidateSoFar pointer gets set to pointing at a different
        // partitionCandidate.
 
 
        // now we start going through candidate partitions which consist of 2
        // or more elements.
        IndexWithWeightListConstIterator listIterator( orderedList.begin() );
        ++listIterator;
        // listIterator is now at the pair with the 2nd object by weight.
        currentCandidate = &(vectorManagingCandidateMemory.newEnd());
        // note where the new partitionCandidate is in memory, so that we can
        // delete it later.
        candidatesToBuildOn.push_back( currentCandidate );
        currentCandidate->getVector().assign( 2,
                                              orderedList.front().first );
        // currentCandidate is now the set { [lowest weight element] }.
        currentCandidate->getVector()[ 1 ] = listIterator->first;
        // currentCandidate is now the set
        // { [lowest weight element], [2nd-lowest weight element] }.
        currentWeight
        = ( orderedList.front().second + listIterator->second );
        // the only way that this combination could have half the weight or
        // over is if there was only 3 elements or less, which should have
        // been caught by earlier if statements.
        currentCandidate->setWeight( currentWeight );
        currentCandidate->setInverseWeight( ( weightSum - currentWeight ) );
 
        if( lowerWeight < currentWeight )
        // if this is a better candidate than the single highest-weight
        // object...
        {
          // note the weights of this new current best candidate:
          lowerWeight = currentWeight;
          higherWeight = ( weightSum - currentWeight );
          // note the actual new best current candidate:
          bestCandidateSoFar = currentCandidate;
        }
 
        IndexWithWeightListConstIterator lowerWeightIterator;
        // this is used for making new candidates of 2 elements.
 
        // now we loop over the rest of the objects in orderedList (all but the
        // 2 lowest-weight objects) to build all partitions with 2 or more
        // objects.
        // we don't bother building with partition candidates which are already
        // over half the total weight; however, we do keep those which are over
        // half the weight after being built from a candidate with less than
        // half the weight, if its weight is less that the higherWeight of the
        // best candidate so far, in which case it becomes the new best
        // candidate.
        // we also don't bother building candidates with more than half the
        // total number of elements, because their partners should already have
        // been found.
 
        // move on to the 3rd object by weight to begin the loop:
        ++listIterator;
        while( orderedList.end() != listIterator )
        // until we reach the end of orderedList...
        {
          for( CandidateListIterator
               candidateIterator( candidatesToBuildOn.begin() );
               candidatesToBuildOn.end() != candidateIterator;
               ++candidateIterator )
          {
            if( ( 2 * ( (*candidateIterator)->getVector().size() + 1 ) )
               <= orderedList.size() )
              // if we're not building a candidate that consists of too many
              // objects...
            {
              currentWeight = ( (*candidateIterator)->getWeight()
                               + listIterator->second );
 
              if( halfTotalWeight < currentWeight )
                // if this candidate is already over half the weight, it cannot
                // be used to build upon, so we only keep it if it's a better
                // candidate than bestCandidateSoFar. in either case, we remove
                // *candidateIterator from candidatesToBuildOn because it's
                // not going to be a better candidate when paired with an
                // object of even higher weight.
              {
                if( higherWeight > currentWeight )
                  // if this *is* a better candidate (including not consisting
                  // of too many elements; if a candidate has half the elements
                  // but over half the weight, the its partner has half the
                  // elements & less than half the weight, so it'll be found
                  // anyway)...
                {
                  // note the weights of this new current best candidate:
                  higherWeight = currentWeight;
                  lowerWeight = ( weightSum - currentWeight );
                  // make the new best candidate & manage the memory:
                  bestCandidateSoFar
                  = &(vectorManagingCandidateMemory.newEnd());
                  // set the candidate's properties:
                  bestCandidateSoFar->buildFrom( *(*candidateIterator),
                                                 listIterator->first,
                                                 higherWeight,
                                                 lowerWeight );
                }
                // otherwise, we don't do anything with this combination of
                // *candidateIterator & *listIterator.
                // in either case we remove *candidateIterator from
                // candidatesToBuildOn because it's not going to be a better
                // candidate when paired with an object of even higher weight.
                candidateIterator
                = candidatesToBuildOn.erase( candidateIterator );
              }
              else
                // otherwise, currentWeight <= halfTotalWeight, so we check to
                // see if it's a better candidate than bestCandidateSoFar, &
                // also if we should keep it for building on, if it does not
                // consist of too many objects already...
              {
                if( lowerWeight < currentWeight )
                  // if this *is* a better candidate...
                {
                  // note the weights of this new current best candidate:
                  lowerWeight = currentWeight;
                  higherWeight = ( weightSum - currentWeight );
                  // make the new best candidate & manage the memory:
                  bestCandidateSoFar
                  = &(vectorManagingCandidateMemory.newEnd());
                  // set the candidate's properties:
                  bestCandidateSoFar->buildFrom( *(*candidateIterator),
                                                 listIterator->first,
                                                 lowerWeight,
                                                 higherWeight );
 
                  if( ( 2 * ( (*candidateIterator)->getVector().size() + 2 ) )
                      <= orderedList.size() )
                    // if building on this would make a candidate that still
                    // would not consist of too many objects...
                  {
                    extraCandidates.push_back( bestCandidateSoFar );
                  }
                }
                else if( ( 2 * ( (*candidateIterator)->getVector().size()
                                 + 2 ) )
                         <= orderedList.size() )
                 // otherwise if we're building a candidate which is not the
                 // best candidate so far, but building on it would make a
                 // candidate that still would not consist of too many
                 // objects...
                {
                  // make the new candidate & manage the memory:
                  currentCandidate
                  = &(vectorManagingCandidateMemory.newEnd());
                  extraCandidates.push_back( currentCandidate );
                  // set the candidate's properties:
                  currentCandidate->buildFrom( *(*candidateIterator),
                                               listIterator->first,
                                               currentWeight,
                            // we know that ( halfTotalWeight > currentWeight )
                                               ( weightSum - currentWeight ) );
                }
              }
              // end of checking if the weight of this combination of
              // *candidateIterator & *listIterator makes it worth keeping,
              // either as bestCandidateSoFar or just as a candidate to build
              // others from.
            }
            // end of if the candidate would not consist of too many objects.
          }
          // end of for loop over existing candidate partitions to build new
          // partitions from with (*listIterator)->first
 
          candidatesToBuildOn.splice( candidatesToBuildOn.begin(),
                                      extraCandidates );
          // all the new candidate partitions are moved from extraCandidates to
          // candidatesToBuildOn, at the start, though that isn't important.
 
          // now we need to build all the 2-object candidates with
          // *listIterator & all objects before it in orderedList:
          lowerWeightIterator = orderedList.begin();
          while( listIterator != lowerWeightIterator )
          {
            currentWeight
            = ( listIterator->second + lowerWeightIterator->second );
            if( halfTotalWeight < currentWeight )
              // if this candidate is already over half the weight, it cannot
              // be used to build upon, so we only keep it if it's a better
              // candidate than bestCandidateSoFar.
            {
              if( higherWeight > currentWeight )
                // if this *is* a better candidate...
              {
                // note the weights of this new current best candidate:
                higherWeight = currentWeight;
                lowerWeight = ( weightSum - currentWeight );
                // make the new best candidate & manage the memory:
                bestCandidateSoFar
                = &(vectorManagingCandidateMemory.newEnd());
                // set the candidate's properties:
                bestCandidateSoFar->getVector().assign( 2,
                                                  lowerWeightIterator->first );
                bestCandidateSoFar->getVector()[ 1 ] = listIterator->first;
                bestCandidateSoFar->setWeight( higherWeight );
                bestCandidateSoFar->setInverseWeight( lowerWeight );
              }
              // otherwise, we don't do anything with this combination of
              // *lowerWeightIterator & *listIterator, or any other
              // *lowerWeightIterator, because they'll all have even greater
              // weight, so we end the loop:
              lowerWeightIterator = listIterator;
            }
            else
              // otherwise, we have a new candidate to build upon, even if it's
              // not the best candidate so far...
            {
              // make the new candidate & manage the memory:
              currentCandidate = &(vectorManagingCandidateMemory.newEnd());
              candidatesToBuildOn.push_back( currentCandidate );
              // set the candidate's properties:
              currentCandidate->getVector().assign( 2,
                                                  lowerWeightIterator->first );
              currentCandidate->getVector()[ 1 ] = listIterator->first;
              currentCandidate->setWeight( currentWeight );
              currentCandidate->setInverseWeight( ( weightSum
                                                    - currentWeight ) );
              if( lowerWeight < currentWeight )
                // if this *is* a better candidate...
              {
                // note the weights of this new current best candidate:
                lowerWeight = currentWeight;
                higherWeight = ( weightSum - currentWeight );
                // note the actual new best current candidate:
                bestCandidateSoFar = currentCandidate;
              }
 
              // now we try the next-lowest weight pairing of *listIterator:
              ++lowerWeightIterator;
            }
            // end of if-else deciding whether to create a new candidate & move
            // on to the next pairing, or to break the loop (possibly after
            // updating bestCandidateSoFar).
          }
          // end of while loop over objects in orderedList before
          // *listIterator.
 
          // move on to the next object by weight:
          ++listIterator;
        }
        // end of while loop going over the higher-weighted objects, building
        // all the partition candidates which can involve them.
 
        // at this point, bestCandidateSoFar *is* the best candidate:
        if( halfTotalWeight > bestCandidateSoFar->getWeight() )
        {
          fillVectorFromBestCandidate( lowerWeightPartition );
          makeOtherPartition( higherWeightPartition,
                              lowerWeightPartition );
        }
        else
        {
          fillVectorFromBestCandidate( higherWeightPartition );
          makeOtherPartition( lowerWeightPartition,
                              higherWeightPartition );
        }
      }
    }
    // end of if-else about whether we needed to check all appropriate
    // combinations or not.
  }

makeOtherPartition()

template<typename ClassToBeSorted >

void BOL::BalancedPartitioner< ClassToBeSorted >::makeOtherPartition ( std::vector< unsigned int > &  partitionToBeMade, std::vector< unsigned int > &  partitionAlreadyMade  )

inlineprotected

Definition at line 619 of file BalancedPartitioner.hpp.

  {
    IndexWithWeightListIterator removingIterator( orderedList.begin() );
    for( CandidateVectorConstIterator
         alreadyUsedIterator( partitionAlreadyMade.begin() );
         partitionAlreadyMade.end() > alreadyUsedIterator;
         ++alreadyUsedIterator )
    {
    // now we look for *alreadyUsedIterator in orderedList:
      removingIterator = orderedList.begin();
      while( removingIterator->first != *alreadyUsedIterator )
      {
        ++removingIterator;
      }
      // now we've found *alreadyUsedIterator in orderedList.
      orderedList.erase( removingIterator );
      // we remove it from the list.
    }
    // now all the elements of partitionAlreadyMade should have been removed
    // from orderedList.
    for( IndexWithWeightListIterator fillingIterator( orderedList.begin() );
         orderedList.end() != fillingIterator;
         ++fillingIterator )
    {
      partitionToBeMade.push_back( fillingIterator->first );
    }
  }

orderByDouble()

template<typename ClassToBeSorted >

bool BOL::BalancedPartitioner< ClassToBeSorted >::orderByDouble ( IndexWithWeight const &  firstPair, IndexWithWeight const &  secondPair  )

inlinestaticprotected

Definition at line 593 of file BalancedPartitioner.hpp.

  {
    if( firstPair.second <= secondPair.second )
    {
      return true;
    }
    else
    {
      return false;
    }
  }

Member Data Documentation

bestCandidateSoFar

template<typename ClassToBeSorted >

BalancedPartitionCandidate* BOL::BalancedPartitioner< ClassToBeSorted >::bestCandidateSoFar

protected

Definition at line 110 of file BalancedPartitioner.hpp.

candidatesToBuildOn

template<typename ClassToBeSorted >

std::list< BalancedPartitionCandidate* > BOL::BalancedPartitioner< ClassToBeSorted >::candidatesToBuildOn

protected

Definition at line 117 of file BalancedPartitioner.hpp.

currentCandidate

template<typename ClassToBeSorted >

BalancedPartitionCandidate* BOL::BalancedPartitioner< ClassToBeSorted >::currentCandidate

protected

Definition at line 109 of file BalancedPartitioner.hpp.

currentWeight

template<typename ClassToBeSorted >

double BOL::BalancedPartitioner< ClassToBeSorted >::currentWeight

protected

Definition at line 111 of file BalancedPartitioner.hpp.

extraCandidates

template<typename ClassToBeSorted >

std::list< BalancedPartitionCandidate* > BOL::BalancedPartitioner< ClassToBeSorted >::extraCandidates

protected

Definition at line 118 of file BalancedPartitioner.hpp.

higherWeight

template<typename ClassToBeSorted >

double BOL::BalancedPartitioner< ClassToBeSorted >::higherWeight

protected

Definition at line 103 of file BalancedPartitioner.hpp.

higherWeightPartition

template<typename ClassToBeSorted >

std::vector< unsigned int > BOL::BalancedPartitioner< ClassToBeSorted >::higherWeightPartition

protected

Definition at line 102 of file BalancedPartitioner.hpp.

lowerWeight

template<typename ClassToBeSorted >

double BOL::BalancedPartitioner< ClassToBeSorted >::lowerWeight

protected

Definition at line 101 of file BalancedPartitioner.hpp.

lowerWeightPartition

template<typename ClassToBeSorted >

std::vector< unsigned int > BOL::BalancedPartitioner< ClassToBeSorted >::lowerWeightPartition

protected

Definition at line 100 of file BalancedPartitioner.hpp.

orderedList

template<typename ClassToBeSorted >

std::list< IndexWithWeight > BOL::BalancedPartitioner< ClassToBeSorted >::orderedList

protected

Definition at line 107 of file BalancedPartitioner.hpp.

positiveWeight

template<typename ClassToBeSorted >

double BOL::BalancedPartitioner< ClassToBeSorted >::positiveWeight

protected

Definition at line 106 of file BalancedPartitioner.hpp.

sizeOfVectorToSort

template<typename ClassToBeSorted >

unsigned int BOL::BalancedPartitioner< ClassToBeSorted >::sizeOfVectorToSort

protected

Definition at line 97 of file BalancedPartitioner.hpp.

vectorManagingCandidateMemory

template<typename ClassToBeSorted >

VectorlikeArray< BalancedPartitionCandidate > BOL::BalancedPartitioner< ClassToBeSorted >::vectorManagingCandidateMemory

protected

Definition at line 113 of file BalancedPartitioner.hpp.

weightGetter

template<typename ClassToBeSorted >

double(* BOL::BalancedPartitioner< ClassToBeSorted >::weightGetter) (ClassToBeSorted const &)

protected

Definition at line 104 of file BalancedPartitioner.hpp.

weightSum

template<typename ClassToBeSorted >

double BOL::BalancedPartitioner< ClassToBeSorted >::weightSum

protected

Definition at line 105 of file BalancedPartitioner.hpp.

---

The documentation for this class was generated from the following file:

• BalancedPartitioner.hpp