fm_partition Class Reference

Heuristic graph bi-partitioning algorithm (Fiduccia-Mattheyses). More...

Inheritance diagram for fm_partition:

Inheritance graph
[legend]
Collaboration diagram for fm_partition:

Collaboration graph
[legend]

List of all members.

Public Types

typedef int side_type
typedef short int fix_type
typedef list< edge >
::const_iterator 
cut_edges_iterator
typedef list< node >
::const_iterator 
nodes_of_one_side_iterator

Public Member Functions

 fm_partition ()
virtual ~fm_partition ()
void set_vars (const graph &G, const node_map< int > &node_weight, const edge_map< int > &edge_weight)
void set_vars (const graph &G, const node_map< int > &node_weight, const edge_map< int > &edge_weight, const node_map< side_type > &init_side)
void set_vars (const graph &G, const node_map< int > &node_weight, const edge_map< int > &edge_weight, const node_map< fix_type > &fixed)
void set_vars (const graph &G, const node_map< int > &node_weight, const edge_map< int > &edge_weight, const node_map< side_type > &init_side, const node_map< fix_type > &fixed)
void store_cut_edges (const bool set)
void store_nodesAB (const bool set)
virtual int check (graph &G)
int run (graph &G)
int get_cutsize ()
int get_needed_passes ()
side_type get_side_of_node (const node &n) const
side_type operator[] (const node &n) const
int get_weight_on_sideA (const graph &G) const
int get_weight_on_sideB (const graph &G) const
cut_edges_iterator cut_edges_begin () const
cut_edges_iterator cut_edges_end () const
nodes_of_one_side_iterator nodes_of_sideA_begin () const
nodes_of_one_side_iterator nodes_of_sideA_end () const
nodes_of_one_side_iterator nodes_of_sideB_begin () const
nodes_of_one_side_iterator nodes_of_sideB_end () const
virtual void reset ()

Static Public Attributes

static const side_type A
static const side_type B
static const fix_type FIXA
static const fix_type FIXB
static const fix_type UNFIXED


Detailed Description

Heuristic graph bi-partitioning algorithm (Fiduccia-Mattheyses).

This class implements a heuristic graph bi-partitioning algorithm, based on iterative movement, proposed by C. M. Fiduccia and R. M. Mattheyses in 1982.

In the case E is the set of edges of the graph, the algorithm needs O(|E|) time to proceed.

See also:
ratio_cut_partition

Member Typedef Documentation

typedef int fm_partition::side_type

Return type of fm_partition::get_side_of_node.

See also:
fm_partition::A

fm_partition::B

typedef short int fm_partition::fix_type

Fix type of each node (needed with fm_partition::set_vars).

See also:
fm_partition::FIXA

fm_partition::FIXB

fm_partition::UNFIXED

typedef list<edge>::const_iterator fm_partition::cut_edges_iterator

Iterator type for edges which belong to the cut.

typedef list<node>::const_iterator fm_partition::nodes_of_one_side_iterator

Iterator type of nodes of a side.


Constructor & Destructor Documentation

fm_partition::fm_partition (  ) 

Default constructor.

See also:
fm_partition::fixe_type

virtual fm_partition::~fm_partition (  )  [virtual]

Destructor.

See also:
algorithm::~algorithm


Member Function Documentation

void fm_partition::set_vars ( const graph G,
const node_map< int > &  node_weight,
const edge_map< int > &  edge_weight 
)

Sets variables. Must be executed before fm_partition::check!

Parameters:
G undirected graph
node_weight weight of each node
edge_weight weight of each edge
See also:
fm_partition::check

void fm_partition::set_vars ( const graph G,
const node_map< int > &  node_weight,
const edge_map< int > &  edge_weight,
const node_map< side_type > &  init_side 
)

Sets variables. Must be executed before fm_partition::check! In order to get good results, init_side should almost be in balance.

Parameters:
G undirected graph
node_weight weight of each node
edge_weight weight of each edge
init_side initial bi-partitioning
See also:
fm_partition::check

void fm_partition::set_vars ( const graph G,
const node_map< int > &  node_weight,
const edge_map< int > &  edge_weight,
const node_map< fix_type > &  fixed 
)

Sets variables. Must be executed before fm_partition::check!

Parameters:
G undirected graph
node_weight weight of each node
edge_weight weight of each edge
fixed fixed nodes
See also:
fm_partition::check

void fm_partition::set_vars ( const graph G,
const node_map< int > &  node_weight,
const edge_map< int > &  edge_weight,
const node_map< side_type > &  init_side,
const node_map< fix_type > &  fixed 
)

Sets variables. Must be executed before fm_partition::check! In order to get good results, init_side should almost be in balance. Fixed nodes are on their fix side, their initial side is overwritten then.

Parameters:
G undirected graph
node_weight weight of each node
edge_weight weight of each edge
init_side initial bi-partitioning
fixed fixed nodes
See also:
fm_partition::check

void fm_partition::store_cut_edges ( const bool  set  ) 

Enables the storing of cut-edges. If enabled the list of cut-edges can be traversed using fm_partition::cut_edges_iterator.

Parameters:
set if true cut_edges will be stored
See also:
fm_partition::cut_edges_begin

fm_partition::cut_edges_end

void fm_partition::store_nodesAB ( const bool  set  ) 

Enables the storing of nodes on their side. If enabled the nodes of each side can be traversed using fm_partition::nodes_on_one_side_iterator.

Parameters:
set if true nodes will be stored on their sides
See also:
fm_partition::nodes_of_sideA_begin

fm_partition::nodes_of_sideA_end

fm_partition::nodes_of_sideB_begin

fm_partition::nodes_of_sideB_end

virtual int fm_partition::check ( graph G  )  [virtual]

Checks whether following preconditions are satisfied:

Parameters:
G graph
Returns:
algorithm::GTL_OK on success, algorithm::GTL_ERROR otherwise
See also:
fm_partition::set_vars

algorithm::check

Implements algorithm.

int fm_partition::run ( graph G  )  [virtual]

Computes a partitioning with G, that means a division of its vertices in two sides fm_partition::A and fm_partition::B.

Parameters:
G graph
Returns:
algorithm::GTL_OK on success, algorithm::GTL_ERROR otherwise
See also:
algorithm::run

Implements algorithm.

int fm_partition::get_cutsize (  ) 

Gets the size of the cut after bi-partitioning.

Returns:
cutsize

int fm_partition::get_needed_passes (  ) 

Gets the number of passes needed to create a bi-partition with this heuristic.

Returns:
number of passes

side_type fm_partition::get_side_of_node ( const node n  )  const

Gets side of the node after bi-partitioning.

Parameters:
n node of graph G
Returns:
fm_partition::A if n lies on side A, fm_partition::B otherwise

side_type fm_partition::operator[] ( const node n  )  const

Gets side of the node after bi-partitioning.

Parameters:
n node of graph G
Returns:
fm_partition::A if n lies on side A, fm_partition::B otherwise
See also:
fm_partition::get_side_of_node

int fm_partition::get_weight_on_sideA ( const graph G  )  const

Gets the sum of all node weights from nodes on side A.

Parameters:
G graph
Returns:
node_weight_on_sideA

int fm_partition::get_weight_on_sideB ( const graph G  )  const

Gets the sum of all node weights from nodes on side B.

Parameters:
G graph
Returns:
node_weight_on_sideB

cut_edges_iterator fm_partition::cut_edges_begin (  )  const

Iterate through all edges which belong to the cut, that means all edges with end-nodes on different sides. It is only valid if enabled with fm_partition::store_cut_edges before.

Returns:
start for iteration through all cut edges

cut_edges_iterator fm_partition::cut_edges_end (  )  const

End-Iterator for iteration through all edges which belong to the cut. It is only valid if enabled with fm_partition::store_cut_edges before.

Returns:
end for iteration through all cut-edges

nodes_of_one_side_iterator fm_partition::nodes_of_sideA_begin (  )  const

Iterate through all nodes which belong to side A. It is only valid if enabled with fm_partition::store_nodesAB before.

Returns:
start for iteration through all nodes on A

nodes_of_one_side_iterator fm_partition::nodes_of_sideA_end (  )  const

End-Iterator for iteration through all nodes which belong to side A. It is only valid if enabled with fm_partition::store_nodesAB before.

Returns:
end for iteration through all nodes on A

nodes_of_one_side_iterator fm_partition::nodes_of_sideB_begin (  )  const

Iterate through all nodes which belong to side B, It is only valid if enabled with fm_partition::store_nodesAB before.

Returns:
start for iteration through all nodes on B

nodes_of_one_side_iterator fm_partition::nodes_of_sideB_end (  )  const

End-Iterator for iteration through all nodes which belong to side B, It is only valid if enabled with fm_partition::store_nodesAB before.

Returns:
end for iteration through all nodes on B

virtual void fm_partition::reset (  )  [virtual]

Resets fm_partition, i.e. prepares the algorithm to be applied to another graph.

See also:
algorithm::reset

Implements algorithm.


Member Data Documentation

const side_type fm_partition::A [static]

A means the node is on side A.

See also:
fm_partition::side_type

const side_type fm_partition::B [static]

B means the node is on side B.

See also:
fm_partition::side_type

const fix_type fm_partition::FIXA [static]

FIXA means fix node on side A.

See also:
fm_partition::set_vars

const fix_type fm_partition::FIXB [static]

FIXB means fix node on side B.

See also:
fm_partition::fixe_type

const fix_type fm_partition::UNFIXED [static]

UNFIXED means node is free.

See also:
fm_partition::fixe_type