Struct tpntree::tpntree::TpnTree

pub struct TpnTree<T, const N: usize> { /* private fields */ }

Implementations

impl<T, const N: usize> TpnTree<T, N>

pub fn iter_breadth_first(&self) -> BreadthFirstIterator<'_, T, N>

Iterate the tree breadth first, starting with the root.

impl<T, const N: usize> TpnTree<T, N>

pub fn iter_depth_first(&self) -> DepthFirstIterator<'_, T, N>

Iterate the tree depth first, starting with the root.

impl<const N: usize> TpnTree<f64, N>

pub fn variance(&self) -> f64

Calculate the variance of TpnTrees with f64 data.

impl<T: Coordinates<N>, const N: usize> TpnTree<Vec<T, Global>, N>

pub fn spans(&self, data: &T) -> bool

Checks if the tree spans over the coordinates of the provided data.

 let tree = Tree3D::root(1.0);

 assert_eq!(tree.spans(&[0.5,0.5,0.5]), true);
 assert_eq!(tree.spans(&[1.5,0.5,0.5]), false);

pub fn insert_by_coordinates(
    &mut self,
    data: T,
    division_condition: &dyn Fn(&Self) -> bool
) -> Result<(), TpnTreeError>

Inserts data in the tree with its center closest to the data given the constrains of the division_condition.

The division condition determines when a tree divides and inserts its data into its children. Errors if the tree does not span the data.

 let mut tree = Tree3D::root(1.0);
  
assert!(tree.insert_by_coordinates([1.0, 0.0, -1.0], &|_| false).is_ok());

pub fn find_by_coordinates(&self, data: &T) -> Result<&Self, TpnTreeError>

Return the tree closest to the given data coordinates.

Errors if the tree does not span the data.

 let mut tree = Tree3D::root(1.0);
  
tree.insert_by_coordinates([1.0, 0.0, -1.0], &|_| false).expect("Couldn't insert.");
assert!(tree
  .find_by_coordinates(&[0.0, 0.0, 0.0])
  .ok()
  .and_then(|tree| tree.data().map(|vec| vec.contains(&[1.0, 0.0, -1.0])))
  .unwrap());

impl<T, const N: usize> TpnTree<T, N>

pub fn new(coordinates: [f64; N], span: [f64; N], level: usize) -> Self

Creates a new TpnTree.

Use this function if you need explicit control over the initial coordinates or a span with various length along different axis. Usually the TpnTree::root function should suffice and is simpler to use.

Examples

Here we create a one dimensional tree, i.e. with one axis sitting on the center [0.0] with a span of 1.0 in each direction [1.0]. This is equal to a line segment spanning from -1.0 to 1.0 with its midpoint at 0.0. The level of the root is usually zero.

let root = TpnTree::<(), 1>::new([0.0], [1.0], 0);

Now lets create a two dimensional tree. The tree root corresponds to a square with its center sitting at the coordinates (1.0/1.0) with edges one edge being 4.0 the other being 1.0 units long. The edges equate to twice the span as it originates from the midpoint.

let root = TpnTree::<(), 2>::new([1.0, 1.0], [2.0, 0.5], 0);

pub fn root(span: f64) -> Self

Creates a new TpnTree with equal span in all dimension at the center of the space at level zero.

Use this function if you want your TpnTree to represenst a centered N-dimensional hypercube.

Examples

Here we create a three dimensional TpnTree with a span of 1.0 in ervery dimension. That is equal to a cube with edges of length 2.0.

let root = TpnTree::<(), 3>::root(1.0);

pub fn divide(&mut self) -> Result<(), TpnTreeError>

Divides the TpnTree into subregions creating new TpnTrees as children.

Returns true if division happened, returns false when already divided.

Each created child has its center moved by half the parents span up or down along the axis. Every child is equal to one unique combination of such half span moves.

Examples

Dividing in the 2D case is creating four smaller squares.

// +---+    +-+-+
// |   | => +-+-+
// +---+    +-+-+
let mut root = TpnTree::<(), 2>::root(1.0);

assert!(root.divide().is_ok());
assert_eq!(root.child_count(), 4);

pub fn get_child(&self, index: usize) -> Option<&Self>

Get a reference to a child TpnTree if it exists.

pub fn get_child_mut(&mut self, index: usize) -> Option<&mut Self>

Get a mutable reference to a child TpnTree if it exists.

pub fn child_count(&self) -> usize

Returns the count of direct children.

pub fn iter_children(&self) -> impl Iterator<Item = &Self>

Iterates all direct children by reference.

pub fn iter_children_mut(&mut self) -> impl Iterator<Item = &mut Self>

Iterates all direct children by mutable reference.

pub fn coordinates(&self) -> [f64; N]

Returns the coordinates of the center of the TpnTree.

pub fn span(&self) -> [f64; N]

Returns the span of the TpnTree.

pub fn data(&self) -> Option<&T>

Returns the data by reference of the TpnTree.

pub fn data_mut(&mut self) -> &mut Option<T>

Returns the data by mutable reference of the TpnTree.

pub fn level(&self) -> usize

Returns the level of the TpnTree.

pub fn is_root(&self) -> bool

Returns wheter the tree is a root.

pub fn is_leaf(&self) -> bool

Returns wheter the tree is a leaf.

pub fn adjacent_trees(&self) -> Vec<Self>

Returns a list of adjacent trees along each dimension.

The trees appear in order of dimension and that first the tree above self, then the one below. Thereby there will be dimension times two TpnTrees returned.

Trait Implementations

impl<T: Clone, const N: usize> Clone for TpnTree<T, N>

fn clone(&self) -> TpnTree<T, N>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug, const N: usize> Debug for TpnTree<T, N>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.