void reindex(
const IterablePairs& pairs,
Hash_Map<PairValueType, PairValueType> & _reindexForward,
Hash_Map<PairValueType, PairValueType> & _reindexBackward)
{
typedef std::pair<PairValueType,PairValueType> PairT;
// get an unique set of Ids
std::set<size_t> _uniqueId;
for(typename IterablePairs::const_iterator iter = pairs.begin();
iter != pairs.end(); ++iter)
{
_uniqueId.insert(iter->first);
_uniqueId.insert(iter->second);
}
// Build the Forward and Backward mapping
for(typename IterablePairs::const_iterator iter = pairs.begin();
iter != pairs.end(); ++iter)
{
if (_reindexForward.find(iter->first) == _reindexForward.end())
{
const size_t dist = std::distance(_uniqueId.begin(), _uniqueId.find(iter->first));
_reindexForward[iter->first] = dist;
_reindexBackward[dist] = iter->first;
}
if (_reindexForward.find(iter->second) == _reindexForward.end())
{
const size_t dist = std::distance(_uniqueId.begin(), _uniqueId.find(iter->second));
_reindexForward[iter->second] = dist;
_reindexBackward[dist] = iter->second;
}
}
}
void reindex
(
const IterablePairs& pairs,
Hash_Map<PairValueType, PairValueType> & reindex_forward,
Hash_Map<PairValueType, PairValueType> & reindex_backward
)
{
// get a unique set of Ids
std::set<size_t> unique_id;
for (typename IterablePairs::const_iterator iter = pairs.begin();
iter != pairs.end(); ++iter)
{
unique_id.insert(iter->first);
unique_id.insert(iter->second);
}
// Build the Forward and Backward mapping
for (typename IterablePairs::const_iterator iter = pairs.begin();
iter != pairs.end(); ++iter)
{
if (reindex_forward.find(iter->first) == reindex_forward.end())
{
const size_t dist = std::distance(unique_id.begin(), unique_id.find(iter->first));
reindex_forward[iter->first] = dist;
reindex_backward[dist] = iter->first;
}
if (reindex_forward.find(iter->second) == reindex_forward.end())
{
const size_t dist = std::distance(unique_id.begin(), unique_id.find(iter->second));
reindex_forward[iter->second] = dist;
reindex_backward[dist] = iter->second;
}
}
}
indexedGraph(const IterablePairs & pairs)
{
map_nodeMapIndex.reset( new map_NodeMapIndex(g) );
//A-- Compute the number of node we need
std::set<IndexT> setNodes;
for (typename IterablePairs::const_iterator iter = pairs.begin();
iter != pairs.end();
++iter)
{
setNodes.insert(iter->first);
setNodes.insert(iter->second);
}
//B-- Create a node graph for each element of the set
for (std::set<IndexT>::const_iterator iter = setNodes.begin();
iter != setNodes.end();
++iter)
{
map_size_t_to_node[*iter] = g.addNode();
(*map_nodeMapIndex) [map_size_t_to_node[*iter]] = *iter;
}
//C-- Add weighted edges from the pairs object
for (typename IterablePairs::const_iterator iter = pairs.begin();
iter != pairs.end();
++iter)
{
const IndexT i = iter->first;
const IndexT j = iter->second;
g.addEdge(map_size_t_to_node[i], map_size_t_to_node[j]);
}
}
bool checkPairOrder(const IterablePairs & pairs)
{
for (typename IterablePairs::const_iterator iterP = pairs.begin(); iterP != pairs.end();
++iterP)
{
if (iterP->first >= iterP->second)
return false;
}
return true;
}
indexedGraph(const IterableNodes & nodes, const IterablePairs & pairs)
{
map_nodeMapIndex.reset( new map_NodeMapIndex(g) );
//A-- Create a node graph for each element of the set
for (typename IterableNodes::const_iterator iter = nodes.begin();
iter != nodes.end();
++iter)
{
map_size_t_to_node[*iter] = g.addNode();
(*map_nodeMapIndex) [map_size_t_to_node[*iter]] = *iter;
}
//B-- Add weighted edges from the pairs object
for (typename IterablePairs::const_iterator iter = pairs.begin();
iter != pairs.end();
++iter)
{
const IndexT i = iter->first;
const IndexT j = iter->second;
g.addEdge(map_size_t_to_node[i], map_size_t_to_node[j]);
}
}
