typo fixed

Author: Andrey Oskin

docs/src/index.md

@@ -106,7 +106,7 @@ r.converged             # whether the procedure converged
 - [Lloyd()](https://cs.nyu.edu/~roweis/csc2515-2006/readings/lloyd57.pdf)
 - [Hamerly()](https://www.researchgate.net/publication/220906984_Making_k-means_Even_Faster)
 - [Elkan()](https://www.aaai.org/Papers/ICML/2003/ICML03-022.pdf)
-- [YingYang()](https://www.microsoft.com/en-us/research/wp-content/uploads/2016/02/ding15.pdf)
+- [Yinyang()](https://www.microsoft.com/en-us/research/wp-content/uploads/2016/02/ding15.pdf)
 - [Geometric()](http://cs.baylor.edu/~hamerly/papers/sdm2016_rysavy_hamerly.pdf) - (Coming soon)
 - [MiniBatch()](https://www.eecs.tufts.edu/~dsculley/papers/fastkmeans.pdf) - (Coming soon)
 
@@ -181,7 +181,7 @@ ________________________________________________________________________________
 - 0.1.2 Added `Elkan` algorithm.
 - 0.1.3 Faster & optimized execution.
 - 0.1.4 Bug fixes
-- 0.1.5 Added `YingYang` algorithm.
+- 0.1.5 Added `Yinyang` algorithm.
 
 ## Contributing
 

src/ParallelKMeans.jl

@@ -12,10 +12,10 @@ include("kmeans.jl")
 include("lloyd.jl")
 include("hamerly.jl")
 include("elkan.jl")
-include("yingyang.jl")
+include("yinyang.jl")
 include("mlj_interface.jl")
 
 export kmeans
-export Lloyd, Hamerly, Elkan, YingYang
+export Lloyd, Hamerly, Elkan, Yinyang
 
 end # module

src/yingyang.jl renamed to src/yinyang.jl

@@ -1,7 +1,7 @@
 """
-    YingYang()
+    Yinyang()
 
-YingYang algorithm implementation, based on "Yufei Ding et al. 2015. Yinyang K-Means: A Drop-In
+Yinyang algorithm implementation, based on "Yufei Ding et al. 2015. Yinyang K-Means: A Drop-In
 Replacement of the Classic K-Means with Consistent Speedup. Proceedings of the 32nd International
 Conference on Machine Learning, ICML 2015, Lille, France, 6-11 July 2015"
 
@@ -13,24 +13,24 @@ It can be used directly in `kmeans` function
 ```julia
 X = rand(30, 100_000)   # 100_000 random points in 30 dimensions
 
-kmeans(YingYang(), X, 3) # 3 clusters, YingYang algorithm
+kmeans(Yinyang(), X, 3) # 3 clusters, Yinyang algorithm
 ```
 
-`YingYang` supports following arguments:
+`Yinyang` supports following arguments:
 `auto`: `Bool`, indicates whether to perform automated or manual grouping
 `group_size`: `Int`, estimation of average number of clusters per group. Lower numbers
 corresponds to higher calculation speed and higher memory consumption and vice versa.
 """
-struct YingYang <: AbstractKMeansAlg
+struct Yinyang <: AbstractKMeansAlg
     auto::Bool
     group_size::Int
 end
 
-YingYang() = YingYang(true, 7)
-YingYang(auto::Bool) = YingYang(auto, 7)
-YingYang(group_size::Int) = YingYang(true, group_size)
+Yinyang() = Yinyang(true, 7)
+Yinyang(auto::Bool) = Yinyang(auto, 7)
+Yinyang(group_size::Int) = Yinyang(true, group_size)
 
-function kmeans!(alg::YingYang, containers, X, k;
+function kmeans!(alg::Yinyang, containers, X, k;
                 n_threads = Threads.nthreads(),
                 k_init = "k-means++", max_iters = 300,
                 tol = 1e-6, verbose = false, init = nothing)
@@ -67,7 +67,7 @@ function kmeans!(alg::YingYang, containers, X, k;
         J_previous = J
 
         # push!(containers.debug, [0, 0, 0])
-        # Core calculation of the YingYang, 3.2-3.3 steps of the original paper
+        # Core calculation of the Yinyang, 3.2-3.3 steps of the original paper
         @parallelize n_threads ncol chunk_update_centroids(alg, containers, centroids, X)
         collect_containers(alg, containers, n_threads)
 
@@ -90,7 +90,7 @@ function kmeans!(alg::YingYang, containers, X, k;
     return KmeansResult(centroids, containers.labels, Float64[], Int[], Float64[], totalcost, niters, converged)
 end
 
-function create_containers(alg::YingYang, k, nrow, ncol, n_threads)
+function create_containers(alg::Yinyang, k, nrow, ncol, n_threads)
     lng = n_threads + 1
     centroids_new = Vector{Array{Float64,2}}(undef, lng)
     centroids_cnt = Vector{Vector{Int}}(undef, lng)
@@ -151,7 +151,7 @@ function create_containers(alg::YingYang, k, nrow, ncol, n_threads)
     )
 end
 
-function initialize(alg::YingYang, containers, centroids, n_threads)
+function initialize(alg::Yinyang, containers, centroids, n_threads)
     groups = containers.groups
     indices = containers.indices
     if length(groups) == 1
@@ -165,7 +165,7 @@ function initialize(alg::YingYang, containers, centroids, n_threads)
     end
 end
 
-function chunk_initialize(alg::YingYang, containers, centroids, X, r, idx)
+function chunk_initialize(alg::Yinyang, containers, centroids, X, r, idx)
     centroids_cnt = containers.centroids_cnt[idx]
     centroids_new = containers.centroids_new[idx]
 
@@ -178,7 +178,7 @@ function chunk_initialize(alg::YingYang, containers, centroids, X, r, idx)
     end
 end
 
-function calculate_centroids_movement(alg::YingYang, containers, centroids)
+function calculate_centroids_movement(alg::Yinyang, containers, centroids)
     p = containers.p
     groups = containers.groups
     gd = containers.gd
@@ -341,7 +341,7 @@ end
 
 Calculates new labels and upper and lower bounds for all points.
 """
-function point_all_centers!(alg::YingYang, containers, centroids, X, i)
+function point_all_centers!(alg::Yinyang, containers, centroids, X, i)
     ub = containers.ub
     lb = containers.lb
     labels = containers.labels

test/test06_yingyang.jl renamed to test/test06_yinyang.jl

@@ -1,108 +1,108 @@
-module TestYingYang
+module TestYinyang
 
 using ParallelKMeans
 using Test
 using Random
 
-@testset "basic kmeans yingyang" begin
+@testset "basic kmeans Yinyang" begin
     X = [1. 2. 4.;]
-    res = kmeans(YingYang(false), X, 1; n_threads = 1, tol = 1e-6, verbose = false)
+    res = kmeans(Yinyang(false), X, 1; n_threads = 1, tol = 1e-6, verbose = false)
     @test res.assignments == [1, 1, 1]
     @test res.centers[1] ≈ 2.3333333333333335
     @test res.totalcost ≈ 4.666666666666666
     @test res.converged
 
-    res = kmeans(YingYang(false), X, 2; n_threads = 1, init = [1.0 4.0], tol = 1e-6, verbose = false)
+    res = kmeans(Yinyang(false), X, 2; n_threads = 1, init = [1.0 4.0], tol = 1e-6, verbose = false)
     @test res.assignments == [1, 1, 2]
     @test res.centers ≈ [1.5 4.0]
     @test res.totalcost ≈ 0.5
     @test res.converged
 end
 
-@testset "yingyang no convergence yield last result" begin
+@testset "Yinyang no convergence yield last result" begin
     X = [1. 2. 4.;]
-    res = kmeans(YingYang(false), X, 2; n_threads = 1, init = [1.0 4.0], tol = 1e-6, max_iters = 1, verbose = false)
+    res = kmeans(Yinyang(false), X, 2; n_threads = 1, init = [1.0 4.0], tol = 1e-6, max_iters = 1, verbose = false)
     @test !res.converged
     @test res.totalcost ≈ 0.5
 end
 
-@testset "yingyang singlethread linear separation" begin
+@testset "Yinyang singlethread linear separation" begin
     Random.seed!(2020)
 
     X = rand(3, 100)
-    res = kmeans(YingYang(false), X, 3; n_threads = 1, tol = 1e-10, max_iters = 10, verbose = false)
+    res = kmeans(Yinyang(false), X, 3; n_threads = 1, tol = 1e-10, max_iters = 10, verbose = false)
 
     @test res.totalcost ≈ 14.16198704459199
     @test !res.converged
     @test res.iterations == 10
 end
 
-@testset "yingyang multithread linear separation quasi two threads" begin
+@testset "Yinyang multithread linear separation quasi two threads" begin
     Random.seed!(2020)
 
     X = rand(3, 100)
-    res = kmeans(YingYang(false), X, 3; n_threads = 2, tol = 1e-6, verbose = false)
+    res = kmeans(Yinyang(false), X, 3; n_threads = 2, tol = 1e-6, verbose = false)
 
     @test res.totalcost ≈ 14.16198704459199
     @test res.converged
 end
 
-@testset "yingyang different modes" begin
+@testset "Yinyang different modes" begin
     Random.seed!(2020)
     X = rand(3, 100)
     init = ParallelKMeans.smart_init(X, 20).centroids
     baseline = kmeans(Lloyd(), X, 20, init = init, tol = 1e-10, n_threads = 1, verbose = false, max_iters = 1000)
 
-    res = kmeans(YingYang(false), X, 20, init = init, tol = 1e-10, n_threads = 1, verbose = false, max_iters = 1000)
+    res = kmeans(Yinyang(false), X, 20, init = init, tol = 1e-10, n_threads = 1, verbose = false, max_iters = 1000)
     @test res.converged
     @test res.totalcost ≈ baseline.totalcost
     @test res.assignments == baseline.assignments
     @test res.centers ≈ baseline.centers
     @test res.iterations == baseline.iterations
 
-    res = kmeans(YingYang(), X, 20, init = init, tol = 1e-10, n_threads = 1, verbose = false, max_iters = 1000)
+    res = kmeans(Yinyang(), X, 20, init = init, tol = 1e-10, n_threads = 1, verbose = false, max_iters = 1000)
     @test res.converged
     @test res.totalcost ≈ baseline.totalcost
     @test res.assignments == baseline.assignments
     @test res.centers ≈ baseline.centers
     @test res.iterations == baseline.iterations
 
-    res = kmeans(YingYang(10), X, 20, init = init, tol = 1e-10, n_threads = 1, verbose = false, max_iters = 1000)
+    res = kmeans(Yinyang(10), X, 20, init = init, tol = 1e-10, n_threads = 1, verbose = false, max_iters = 1000)
     @test res.converged
     @test res.totalcost ≈ baseline.totalcost
     @test res.assignments == baseline.assignments
     @test res.centers ≈ baseline.centers
     @test res.iterations == baseline.iterations
 
-    res = kmeans(YingYang(7), X, 20, init = init, tol = 1e-10, n_threads = 1, verbose = false, max_iters = 1000)
+    res = kmeans(Yinyang(7), X, 20, init = init, tol = 1e-10, n_threads = 1, verbose = false, max_iters = 1000)
     @test res.converged
     @test res.totalcost ≈ baseline.totalcost
     @test res.assignments == baseline.assignments
     @test res.centers ≈ baseline.centers
     @test res.iterations == baseline.iterations
 
-    res = kmeans(YingYang(false), X, 20, init = init, tol = 1e-10, n_threads = 2, verbose = false, max_iters = 1000)
+    res = kmeans(Yinyang(false), X, 20, init = init, tol = 1e-10, n_threads = 2, verbose = false, max_iters = 1000)
     @test res.converged
     @test res.totalcost ≈ baseline.totalcost
     @test res.assignments == baseline.assignments
     @test res.centers ≈ baseline.centers
     @test res.iterations == baseline.iterations
 
-    res = kmeans(YingYang(), X, 20, init = init, tol = 1e-10, n_threads = 2, verbose = false, max_iters = 1000)
+    res = kmeans(Yinyang(), X, 20, init = init, tol = 1e-10, n_threads = 2, verbose = false, max_iters = 1000)
     @test res.converged
     @test res.totalcost ≈ baseline.totalcost
     @test res.assignments == baseline.assignments
     @test res.centers ≈ baseline.centers
     @test res.iterations == baseline.iterations
 
-    res = kmeans(YingYang(10), X, 20, init = init, tol = 1e-10, n_threads = 2, verbose = false, max_iters = 1000)
+    res = kmeans(Yinyang(10), X, 20, init = init, tol = 1e-10, n_threads = 2, verbose = false, max_iters = 1000)
     @test res.converged
     @test res.totalcost ≈ baseline.totalcost
     @test res.assignments == baseline.assignments
     @test res.centers ≈ baseline.centers
     @test res.iterations == baseline.iterations
 
-    res = kmeans(YingYang(7), X, 20, init = init, tol = 1e-10, n_threads = 2, verbose = false, max_iters = 1000)
+    res = kmeans(Yinyang(7), X, 20, init = init, tol = 1e-10, n_threads = 2, verbose = false, max_iters = 1000)
     @test res.converged
     @test res.totalcost ≈ baseline.totalcost
     @test res.assignments == baseline.assignments