abd-clam 0.11.1

Clustered Learning of Approximate Manifolds
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90

use crate::dataset::Dataset;
use crate::number::Number;

use super::{Cluster, PartitionCriteria};

/// A `Tree` represents a hierarchy of "similar" instances from a
/// metric-`Space`.
///
/// Typically one will chain calls to `new`, `build`, and finally
/// `partition` to construct a fully realized `Tree`.
#[derive(Debug)]
pub struct Tree<T: Number, U: Number, D: Dataset<T, U>> {
    data: D,
    root: Cluster<T, U, D>,
    _t: std::marker::PhantomData<T>,
}

impl<T: Number, U: Number, D: Dataset<T, U>> Tree<T, U, D> {
    /// Constructs a new `Tree` for a given dataset. Importantly,
    /// this does not build nor partition the tree.
    ///
    /// # Arguments
    /// dataset: The dataset from which the tree will be built
    pub fn new(data: D, seed: Option<u64>) -> Self {
        Tree {
            root: Cluster::new_root(&data, data.indices(), seed),
            data,
            _t: Default::default(),
        }
    }

    /// # Returns
    /// A reference to the root `Cluster` of the tree
    pub(crate) fn root(&self) -> &Cluster<T, U, D> {
        &self.root
    }

    /// Returns a reference to dataset associated with the tree
    pub fn data(&self) -> &D {
        &self.data
    }

    /// # Returns
    /// The cardinality of the `Tree`
    pub fn cardinality(&self) -> usize {
        self.root.cardinality()
    }

    /// # Returns
    /// The radius of the `Tree`
    pub fn radius(&self) -> U {
        self.root.radius()
    }

    /// # Arguments
    /// criteria: A `PartitionCriteria` through which the `Tree`'s root will be partitioned.
    ///
    /// # Returns
    /// A new `Tree` with a partitioned root.
    pub fn par_partition(mut self, criteria: &PartitionCriteria<T, U, D>, recursive: bool) -> Self {
        self.root = self.root.par_partition(&self.data, criteria, recursive);
        self
    }

    /// Partitions the `Tree` based off of a given criteria
    ///
    /// # Arguments
    /// criteria: A `PartitionCriteria` through which the `Tree`'s root will be partitioned.
    ///
    /// # Returns
    /// A new `Tree` with a partitioned root.
    pub fn partition(mut self, criteria: &PartitionCriteria<T, U, D>, recursive: bool) -> Self {
        self.root = self.root.partition(&self.data, criteria, recursive);
        self
    }

    /// Returns the indices contained in the root of the `Tree`.
    pub fn indices(&self) -> &[usize] {
        self.root.indices(&self.data)
    }

    /// Reorders the `Tree`'s underlying dataset based off of a depth first traversal of a
    /// tree and reformats the tree to reflect the reordering.
    pub fn depth_first_reorder(mut self) -> Self {
        let leaf_indices = self.root.leaf_indices();
        self.data.reorder(&leaf_indices);
        self.root.dfr(&self.data, 0);
        self
    }
}