Struct Rcb 

pub struct Rcb {
    pub iter_count: usize,
    pub tolerance: f64,
    pub fast: bool,
}

Recursive Coordinate Bisection algorithm

Partitions a mesh based on the nodes coordinates and coresponding weights.

This is the most simple and straightforward geometric algorithm. It operates as follows for a N-dimensional set of points:

At each iteration, select a vector n of the canonical basis (e_0, ..., e_{n-1}). Then, split the set of points with an hyperplane orthogonal to n, such that the two parts of the splits are evenly weighted. Finally, recurse by reapplying the algorithm to the two parts with an other normal vector selection.

Example

use coupe::Partition as _;
use coupe::Point2D;

let points = [
    Point2D::new(1., 1.),
    Point2D::new(-1., 1.),
    Point2D::new(1., -1.),
    Point2D::new(-1., -1.),
];
let weights = [1; 4];
let mut partition = [0; 4];

// Generate a partition of 4 parts (2 splits).
coupe::Rcb { iter_count: 2, ..Default::default() }
    .partition(&mut partition, (points, weights))
    .unwrap();

// All points are in different parts.
for i in 0..4 {
    for j in 0..4 {
        if j == i {
            continue
        }
        assert_ne!(partition[i], partition[j])
    }
}

Reference

Berger, M. J. and Bokhari, S. H., 1987. A partitioning strategy for nonuniform problems on multiprocessors. IEEE Transactions on Computers, C-36(5):570–580. doi:10.1109/TC.1987.1676942.

Fields

iter_count: usize

The number of iterations of the algorithm. This will yield a partition of at most 2^num_iter parts.

If this equals zero, RCB will not do anything.

tolerance: f64

Tolerance on the normalized imbalance, for each split. Please note that the overall imbalance might end up above this threshold.

Negative values are interpreted as zeroes.

fast: bool

Use a faster, experimental implementation of the algorithm.

Trait Implementations

impl Default for Rcb

fn default() -> Rcb

Returns the “default value” for a type.

impl<const D: usize, P, W> Partition<(P, W)> for Rcb

where P: IntoParallelIterator<Item = PointND<D>>, P::Iter: IndexedParallelIterator, W: IntoParallelIterator, W::Item: RcbWeight, W::Iter: IndexedParallelIterator,

type Metadata = ()

Diagnostic data returned for a specific run of the algorithm.

type Error = Error

Error details, should the algorithm fail to run.

fn partition( &mut self, part_ids: &mut [usize], (points, weights): (P, W), ) -> Result<Self::Metadata, Self::Error>

Partition the given data and output the part ID of each element in part_ids.