lhef::Matching< Delta > Class Template Reference

#include <Matching.h>

Classes
struct	AlwaysTrue
struct	Comparator
struct	Match

Public Types
typedef SimpleMatrix< Delta > ::size_type	index_type

Public Member Functions
Delta	delta (index_type index1, index_type index2) const
Delta	delta (Match match) const
bool	isMatched1st (index_type index)
bool	isMatched2nd (index_type index)
template<class SortComparator , class CutCriterion >
std::vector< Match >	match (SortComparator sortComparator=SortComparator(), CutCriterion cutCriterion=CutCriterion())
template<class SortComparator >
std::vector< Match >	match ()
std::vector< Match >	match ()
template<typename V1 , typename V2 , class Separation >
	Matching (const V1 &v1, const V2 &v2, Separation separation)

Private Attributes
std::vector< bool >	matched1
std::vector< bool >	matched2
SimpleMatrix< Delta >	matrix

Detailed Description

template<typename Delta>
class lhef::Matching< Delta >

Definition at line 14 of file Matching.h.

Member Typedef Documentation

template<typename Delta>

typedef SimpleMatrix<Delta>::size_type lhef::Matching< Delta >::index_type

Definition at line 16 of file Matching.h.

Constructor & Destructor Documentation

template<typename Delta>

template<typename V1 , typename V2 , class Separation >

lhef::Matching< Delta >::Matching ( const V1 &  v1, const V2 &  v2, Separation  separation  )

inline

Definition at line 19 of file Matching.h.

References i, j, and lhef::Matching< Delta >::matrix.

                                                                :
        matrix(v1.size(), v2.size()),
        matched1(v1.size(), false),
        matched2(v2.size(), false)
    {
        index_type i = 0;
        for(typename V1::const_iterator iter1 = v1.begin();
            iter1 != v1.end(); ++iter1, i++) {
            index_type j = 0;
            for(typename V2::const_iterator iter2 = v2.begin();
                iter2 != v2.end(); ++iter2, j++)
                matrix(i, j) = separation(*iter1, *iter2);
                    
        }
    }

Member Function Documentation

template<typename Delta>

Delta lhef::Matching< Delta >::delta ( index_type  index1, index_type  index2  ) const

inline

Definition at line 44 of file Matching.h.

References lhef::Matching< Delta >::matrix.

    { return matrix(index1, index2); }

template<typename Delta>

Delta lhef::Matching< Delta >::delta ( Match  match ) const

inline

Definition at line 47 of file Matching.h.

References lhef::Matching< Delta >::Match::index1, lhef::Matching< Delta >::Match::index2, and lhef::Matching< Delta >::matrix.

    { return matrix(match.index1, match.index2); }

template<typename Delta>

bool lhef::Matching< Delta >::isMatched1st ( index_type  index )

inline

Definition at line 111 of file Matching.h.

References getHLTprescales::index, and lhef::Matching< Delta >::matched1.

{ return matched1[index]; }

template<typename Delta>

bool lhef::Matching< Delta >::isMatched2nd ( index_type  index )

inline

Definition at line 112 of file Matching.h.

References getHLTprescales::index, and lhef::Matching< Delta >::matched2.

{ return matched2[index]; }

template<typename Delta>

template<class SortComparator , class CutCriterion >

std::vector<Match> lhef::Matching< Delta >::match ( SortComparator  sortComparator = SortComparator(), CutCriterion  cutCriterion = CutCriterion()  )

inline

Definition at line 72 of file Matching.h.

References i, MultipleCompare::Match(), lhef::Matching< Delta >::matched1, lhef::Matching< Delta >::matched2, lhef::Matching< Delta >::matrix, min, query::result, lhef::SimpleMatrix< T >::size(), and python.multivaluedict::sort().

    {
        std::vector<index_type> matches(matrix.size());
        for(index_type i = 0; i != matrix.size(); i++)
            matches[i] = i;

        std::sort(matches.begin(), matches.end(),
                  Comparator<SortComparator>(matrix, sortComparator));

        std::vector<Match> result;
        result.reserve(std::min(matrix.rows(), matrix.cols()));
        for(typename std::vector<index_type>::const_iterator iter =
            matches.begin(); iter != matches.end(); ++iter) {

            index_type row = matrix.row(*iter);
            index_type col = matrix.col(*iter);
            if (matched1[row] || matched2[col])
                continue;

            if (!cutCriterion(matrix[*iter]))
                continue;

            matched1[row] = true;
            matched2[col] = true;
            result.push_back(Match(row, col));
        }

        return result;
    }

template<typename Delta>

template<class SortComparator >

std::vector<Match> lhef::Matching< Delta >::match ( )

inline

Definition at line 105 of file Matching.h.

    { return match<SortComparator, AlwaysTrue>(); }

template<typename Delta>

std::vector<Match> lhef::Matching< Delta >::match ( )

inline

Definition at line 108 of file Matching.h.

    { return match<std::less<Delta>, AlwaysTrue>(); }

Member Data Documentation

template<typename Delta>

std::vector<bool> lhef::Matching< Delta >::matched1

private

Definition at line 116 of file Matching.h.

Referenced by lhef::Matching< Delta >::isMatched1st(), and lhef::Matching< Delta >::match().

template<typename Delta>

std::vector<bool> lhef::Matching< Delta >::matched2

private

Definition at line 116 of file Matching.h.

Referenced by lhef::Matching< Delta >::isMatched2nd(), and lhef::Matching< Delta >::match().

template<typename Delta>

SimpleMatrix<Delta> lhef::Matching< Delta >::matrix

private

Definition at line 115 of file Matching.h.

Referenced by lhef::Matching< Delta >::delta(), lhef::Matching< Delta >::match(), and lhef::Matching< Delta >::Matching().