Implemented OPTICS algorithm

Author: mpraski

common.go

@@ -0,0 +1,65 @@
+package clusters
+
+import (
+	"container/heap"
+)
+
+// struct denoting start and end indices of database portion to be scanned for nearest neighbours by workers in DBSCAN and OPTICS
+type rangeJob struct {
+	a, b int
+}
+
+// priority queue
+type pItem struct {
+	v int
+	p float64
+	i int
+}
+
+type priorityQueue []*pItem
+
+func newPriorityQueue(size int) priorityQueue {
+	q := make(priorityQueue, 0, size)
+	heap.Init(&q)
+
+	return q
+}
+
+func (pq priorityQueue) Len() int { return len(pq) }
+
+func (pq priorityQueue) Less(i, j int) bool {
+	return pq[i].p > pq[j].p
+}
+
+func (pq priorityQueue) Swap(i, j int) {
+	pq[i], pq[j] = pq[j], pq[i]
+	pq[i].i = i
+	pq[j].i = j
+}
+
+func (pq *priorityQueue) Push(x interface{}) {
+	n := len(*pq)
+	item := x.(*pItem)
+	item.i = n
+	*pq = append(*pq, item)
+	heap.Fix(pq, item.i)
+}
+
+func (pq *priorityQueue) Pop() interface{} {
+	old := *pq
+	n := len(old)
+	item := old[n-1]
+	item.i = -1
+	*pq = old[0 : n-1]
+	return item
+}
+
+func (pq *priorityQueue) NotEmpty() bool {
+	return len(*pq) > 0
+}
+
+func (pq *priorityQueue) Update(item *pItem, value int, priority float64) {
+	item.v = value
+	item.p = priority
+	heap.Fix(pq, item.i)
+}

dbscan.go

@@ -9,34 +9,29 @@ type dbscanClusterer struct {
 	workers int
 	eps     float64
 
-	l, s, o, f int
-
 	distance DistanceFunc
 
+	// slices holding the cluster mapping and sizes
 	mu   sync.RWMutex
 	a, b []int
 
-	// channel for distributed searching for nearest neighbours
-	j chan *nearestJob
-
-	// variabes for calculating nearest neighbours concurrently
-	m *sync.Mutex
-	w *sync.WaitGroup
-	p *[]float64
-	r *[]int
+	// variables used for concurrent computation of nearest neighbours
+	l, s, o, f int
+	j          chan *rangeJob
+	m          *sync.Mutex
+	w          *sync.WaitGroup
+	p          *[]float64
+	r          *[]int
 
 	// visited points
 	v []bool
 
+	// dataset
 	d [][]float64
 }
 
-type nearestJob struct {
-	a, b int
-}
-
-/* Implementation of DBSCAN algorithm with concurrent moditication */
-func DbscanClusterer(minpts int, eps float64, workers int, distance DistanceFunc) (HardClusterer, error) {
+/* Implementation of DBSCAN algorithm with concurrent nearest neighbour computation */
+func DBSCAN(minpts int, eps float64, workers int, distance DistanceFunc) (HardClusterer, error) {
 	if minpts < 1 {
 		return nil, ErrZeroMinpts
 	}
@@ -159,7 +154,7 @@ func (c *dbscanClusterer) run() {
 
 		c.v[i] = true
 
-		c.nearest(&i, &l, &ns)
+		c.nearest(i, &l, &ns)
 
 		if l < c.minpts {
 			c.a[i] = -1
@@ -173,7 +168,7 @@ func (c *dbscanClusterer) run() {
 				if !c.v[ns[j]] {
 					c.v[ns[j]] = true
 
-					c.nearest(&ns[j], &k, &nss)
+					c.nearest(ns[j], &k, &nss)
 
 					if k >= c.minpts {
 						l += k
@@ -197,12 +192,12 @@ func (c *dbscanClusterer) run() {
  * by the size of the data. This is based on an assumption that neighbour points of p
  * are located in relatively small subsection of the input data, so the dataset can be scanned
  * concurrently without blocking a big number of goroutines trying to write to r */
-func (c *dbscanClusterer) nearest(p *int, l *int, r *[]int) {
+func (c *dbscanClusterer) nearest(p int, l *int, r *[]int) {
 	var b int
 
 	*r = (*r)[:0]
 
-	c.p = &c.d[*p]
+	c.p = &c.d[p]
 	c.r = r
 
 	c.w.Add(c.s)
@@ -214,7 +209,7 @@ func (c *dbscanClusterer) nearest(p *int, l *int, r *[]int) {
 			b = (i + 1) * c.f
 		}
 
-		c.j <- &nearestJob{
+		c.j <- &rangeJob{
 			a: i * c.f,
 			b: b,
 		}
@@ -226,7 +221,7 @@ func (c *dbscanClusterer) nearest(p *int, l *int, r *[]int) {
 }
 
 func (c *dbscanClusterer) startWorkers() {
-	c.j = make(chan *nearestJob, c.l)
+	c.j = make(chan *rangeJob, c.l)
 
 	c.m = &sync.Mutex{}
 	c.w = &sync.WaitGroup{}
@@ -255,18 +250,15 @@ func (c *dbscanClusterer) nearestWorker() {
 }
 
 func (c *dbscanClusterer) numWorkers() int {
-	var (
-		a int = c.l
-		b int
-	)
+	var b int
 
-	if a < 1000 {
+	if c.l < 1000 {
 		b = 1
-	} else if a < 10000 {
+	} else if c.l < 10000 {
 		b = 10
-	} else if a < 100000 {
+	} else if c.l < 100000 {
 		b = 100
-	} else if a < 1000000 {
+	} else if c.l < 1000000 {
 		b = 1000
 	} else {
 		b = 10000

kmeans.go

@@ -18,7 +18,7 @@ type kmeansClusterer struct {
 	iterations int
 	number     int
 
-	// Variables keeping count of changes of points' membership every iteration. User as a stopping condition.
+	// variables keeping count of changes of points' membership every iteration. User as a stopping condition.
 	changes, oldchanges, counter, threshold int
 
 	// For online learning only
@@ -27,17 +27,18 @@ type kmeansClusterer struct {
 
 	distance DistanceFunc
 
-	// a holds the mapping of data point indices to cluster numbers, b holds the sizes of each cluster
+	// slices holding the cluster mapping and sizes
 	mu   sync.RWMutex
 	a, b []int
 
-	// variables holding values of centroids of each clusters
+	// slices holding values of centroids of each clusters
 	m, n [][]float64
 
+	// dataset
 	d [][]float64
 }
 
-func KmeansClusterer(iterations, clusters int, distance DistanceFunc) (HardClusterer, error) {
+func KMeans(iterations, clusters int, distance DistanceFunc) (HardClusterer, error) {
 	if iterations < 1 {
 		return nil, ErrZeroIterations
 	}