Struct petal_clustering::Dbscan

pub struct Dbscan<A, M> {
    pub eps: A,
    pub min_samples: usize,
    pub metric: M,
}

DBSCAN (density-based spatial clustering of applications with noise) clustering algorithm.

Examples

use ndarray::array;
use petal_neighbors::distance::Euclidean;
use petal_clustering::{Dbscan, Fit};

let points = array![[1.0, 2.0], [2.0, 2.0], [2.0, 2.3], [8.0, 7.0], [8.0, 8.0], [25.0, 80.0]];
let clustering = Dbscan::new(3.0, 2, Euclidean::default()).fit(&points);

assert_eq!(clustering.0.len(), 2);        // two clusters found
assert_eq!(clustering.0[&0], [0, 1, 2]);  // the first three points in Cluster 0
assert_eq!(clustering.0[&1], [3, 4]);     // [8.0, 7.0] and [8.0, 8.0] in Cluster 1
assert_eq!(clustering.1, [5]);            // [25.0, 80.0] doesn't belong to any cluster

Fields

eps: A

The radius of a neighborhood.

min_samples: usize

The minimum number of points required to form a dense region.

metric: M

Implementations

impl<A, M> Dbscan<A, M>

pub fn new(eps: A, min_samples: usize, metric: M) -> Self

Trait Implementations

impl<A: Debug, M: Debug> Debug for Dbscan<A, M>

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

Formats the value using the given formatter.

impl<A> Default for Dbscan<A, Euclidean> where
    A: Float, 

fn default() -> Self

Returns the “default value” for a type.

impl<'de, A, M> Deserialize<'de> for Dbscan<A, M> where
    A: Deserialize<'de>,
    M: Deserialize<'de>, 

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<S, A, M> Fit<ArrayBase<S, Dim<[usize; 2]>>, (HashMap<usize, Vec<usize, Global>, RandomState>, Vec<usize, Global>)> for Dbscan<A, M> where
    A: AddAssign + DivAssign + Float + FromPrimitive + Sync,
    S: Data<Elem = A>,
    M: Metric<A> + Clone + Sync, 

fn fit(
    &mut self,
    input: &ArrayBase<S, Ix2>
) -> (HashMap<usize, Vec<usize>>, Vec<usize>)

impl<A, M> Serialize for Dbscan<A, M> where
    A: Serialize,
    M: Serialize, 

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.