ratio_cut_partition Class Reference

[Index] [Hierarchy] [Headers]

Heuristic graph bi-partitioning algorithm (Wei-Cheng). More...

#include <GTL/ratio_cut_partition.h>

Inherits: algorithm

Public Members

• enum side_type {A = 0, B = 1}
• enum fix_type {FIXA = 0, FIXB = 1, UNFIXED = 2}
• ratio_cut_partition()
• virtual ~ratio_cut_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 source_node, const node target_node)
• void set_vars(const graph& G, const node_map<int>& node_weight, const edge_map<int>& edge_weight, const node source_node, const node target_node, 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 source_node, const node target_node, 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 source_node, const node target_node, 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()
• double get_cutratio()
• 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
• typedef list<edge>::const_iterator cut_edges_iterator
• cut_edges_iterator cut_edges_begin() const
• cut_edges_iterator cut_edges_end() const
• typedef list<node>::const_iterator nodes_of_one_side_iterator
• 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()

Detailed Description

This class implements a heuristic graph bi-partitioning algorithm using the ratio cut method proposed by Y. C. Wei and C. K. Cheng in 1991.

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

See Also: fm_partition

enum side_type (A = 0, B = 1) [public]

Return type of ratio_cut_partition::get_side_of_node

enum fix_type (FIXA = 0, FIXB = 1, UNFIXED = 2) [public]

Fix type of each node. FIXA means fixed on side A, FIXB on side B and UNFIXED means not fixed on any side.

See Also:

ratio_cut_partition::set_vars

ratio_cut_partition() [public]

Default constructor.

See Also:

algorithm::algorithm

~ratio_cut_partition() [public virtual]

Destructor.

See Also:

algorithm::~algorithm

void set_vars(const graph& G, const node_map<int>& node_weight, const edge_map<int>& edge_weight) [public]

Sets variables. Must be executed before ratio_cut_partition::check source_node and target_node will be determined automatically.

Parameters:

G	undirected graph.
edge_weight	weight of each edge.
node_weight	weight of each node.

See Also:

ratio_cut_partition::check

void set_vars(const graph& G, const node_map<int>& node_weight, const edge_map<int>& edge_weight, const node source_node, const node target_node) [public]

Sets variables. Must be executed before ratio_cut_partition::check In order to get good results, you should take two graph theoretically far away nodes as source and target.

Parameters:

G	undirected graph.
target_node	end-node, remains on side B .
edge_weight	weight of each edge..
node_weight	weight of each node.
source_node	start-node, remains on side A.

See Also:

ratio_cut_partition::check

void set_vars(const graph& G, const node_map<int>& node_weight, const edge_map<int>& edge_weight, const node source_node, const node target_node, const node_map<side_type> init_side) [public]

Sets variables. Must be executed before ratio_cut_partition::check In order to get good results, you should take two graph theoretically far away nodes as source and target. Additionally init_side should nearly be in balance. source_node must be on side A in init_side and target_node on side B respectively.

Parameters:

G	undirected graph.
init_side	initial bi-partitioning.
target_node	end-node, remains on side B .
edge_weight	weight of each edge..
node_weight	weight of each node.
source_node	start-node, remains on side A.

See Also:

ratio_cut_partition::check

void set_vars(const graph& G, const node_map<int>& node_weight, const edge_map<int>& edge_weight, const node source_node, const node target_node, const node_map<fix_type> fixed) [public]

Sets variables. Must be executed before ratio_cut_partition::check In order to get good results, you should take two graph theoretically far away nodes as source and target. source_node must not be fixed on side B . target_node must not be fixed on side A .

Parameters:

G	undirected graph.
fixed	fixed nodes.
target_node	end-node, remains on side B .
edge_weight	weight of each edge..
node_weight	weight of each node.
source_node	start-node, remains on side A.

See Also:

ratio_cut_partition::check

void set_vars(const graph& G, const node_map<int>& node_weight, const edge_map<int>& edge_weight, const node source_node, const node target_node, const node_map<side_type> init_side, const node_map<fix_type> fixed) [public]

Sets variables. Must be executed before ratio_cut_partition::check In order to get good results, you should take two graph theoretically far away nodes as source and target. Additionally init_side should nearly be in balance. Fixed nodes are on their fix side, their initial side is overwritten then. source_node must be on side A in init_side and target_node on side B respectively. source_node must not be fixed on side B . target_node must not be fixed on side A .

Parameters:

G	undirected graph.
fixed	fixed nodes.
init_side	initial bi-partitioning.
target_node	end-node, remains on side B .
edge_weight	weight of each edge..
node_weight	weight of each node.
source_node	start-node, remains on side A.

See Also:

ratio_cut_partition::check

void store_cut_edges(const bool set) [public]

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

Parameters:

set	if true cut_edges will be stored.

See Also:

ratio_cut_partition::cut_edges_begin, ratio_cut_partition::cut_edges_end

void store_nodesAB(const bool set) [public]

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

Parameters:

set	if true nodes on their side will be stored.

See Also:

ratio_cut_partition::nodes_of_sideA_begin, ratio_cut_partition::nodes_of_sideA_end, ratio_cut_partition::nodes_of_sideB_begin, ratio_cut_partition::nodes_of_sideB_end

int check(graph& G) [public virtual]

Checks whether following preconditions are satisfied:

• One of the ratio_cut_partition::set_vars procedures has been executed before.
• graph G is undirected.
• if applied, source_node and target_node are 2 distinct nodes with node weights > 0.
• only node_weights >= 0 are applied.
• only edge_weights >= 0 are applied.
• if G has more than 2 nodes, then at least two of them have a weight > 0.
• if applied fixed source node, fixed[source_node] is FIXA.
• if applied fixed target node, fixed[target_node] is FIXB.

Parameters:

G

graph

Returns:

algorithm::GTL_OK on success, algorithm::GTL_ERROR otherwise.

See Also:

ratio_cut_partition::set_vars, algorithm::check

int run(graph& G) [public]

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

Parameters:

G

graph

Returns:

algorithm::GTL_OK on success, algorithm::GTL_ERROR otherwise.

See Also:

algorithm::run

int get_cutsize() [public]

Gets the size of the cut after bi-partitioning.

Returns:

cutsize

double get_cutratio() [public]

Gets the ratio of the cut after bi-partitioning as defined in [WeiChe91].

Returns:

cutratio

side_type get_side_of_node(const node& n) const [public]

Gets side of the node after bi-partitioning.

Parameters:

n	node of graph G.

Returns:

ratio_cut_partition::A if n lies on side A, ratio_cut_partition::B otherwise.

side_type operator [](const node& n) const [public]

Gets side of the node after bi-partitioning.

Parameters:

n	node of graph G.

Returns:

ratio_cut_partition::A if n lies on side A, ratio_cut_partition::B otherwise.

See Also:

ratio_cut_partition::get_side_of_node

int get_weight_on_sideA(const graph& G) const [public]

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

Parameters:

G

graph

Returns:

node_weight_on_sideA

int get_weight_on_sideB(const graph& G) const [public]

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

Parameters:

G

graph

Returns:

node_weight_on_sideB

typedef list<edge>::const_iterator cut_edges_iterator [public]

Iterator type for edges which belong to the cut.

cut_edges_iterator cut_edges_begin() const [public]

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 ratio_cut_partition:: store_cut_edges before.

Returns:

start for iteration through all cut edges.

cut_edges_iterator cut_edges_end() const [public]

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

Returns:

end for iteration through all cut-edges.

typedef list<node>::const_iterator nodes_of_one_side_iterator [public]

Iterator type for nodes of a side.

nodes_of_one_side_iterator nodes_of_sideA_begin() const [public]

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

Returns:

start for iteration through all nodes on A.

nodes_of_one_side_iterator nodes_of_sideA_end() const [public]

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

Returns:

end for iteration through all nodes on A.

nodes_of_one_side_iterator nodes_of_sideB_begin() const [public]

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

Returns:

start for iteration through all nodes on B.

nodes_of_one_side_iterator nodes_of_sideB_end() const [public]

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

Returns:

end for iteration through all nodes on B.

void reset() [public virtual]

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

See Also:

algorithm::reset