kmeans.hpp

Go to the documentation of this file.

#ifndef KMEANS_KMEANS_HPP
#define KMEANS_KMEANS_HPP
 
#include <vector>
 
#include "sanisizer/sanisizer.hpp"
 
#include "Details.hpp"
#include "Refine.hpp"
#include "Initialize.hpp"
#include "Matrix.hpp"
#include "SimpleMatrix.hpp"
 
#include "InitializeKmeanspp.hpp"
#include "InitializeRandom.hpp"
#include "InitializeVariancePartition.hpp"
#include "InitializeNone.hpp"
 
#include "RefineHartiganWong.hpp"
#include "RefineLloyd.hpp"
#include "RefineMiniBatch.hpp"
 
#include "compute_wcss.hpp"
#include "remove_unused_centers.hpp"
 
namespace kmeans {
 
template<typename Index_, typename Data_, typename Cluster_, typename Float_, class Matrix_ = Matrix<Index_, Data_> >
Details<Index_> compute(
    const Matrix_& data, 
    const Initialize<Index_, Data_, Cluster_, Float_, Matrix_>& initialize, 
    const Refine<Index_, Data_, Cluster_, Float_, Matrix_>& refine,
    Cluster_ num_centers,
    Float_* centers,
    Cluster_* clusters)
{
    auto actual_centers = initialize.run(data, num_centers, centers);
    auto output = refine.run(data, actual_centers, centers, clusters);
    sanisizer::resize(output.sizes, num_centers); // restoring the full size.
    return output;
}
 
template<typename Index_, typename Data_, typename Cluster_, typename Float_>
Details<Index_> compute(
    const Matrix<Index_, Data_>& data,
    const Initialize<Index_, Data_, Cluster_, Float_, Matrix<Index_, Data_> >& initialize, 
    const Refine<Index_, Data_, Cluster_, Float_, Matrix<Index_, Data_> >& refine,
    const Cluster_ num_centers,
    Float_* const centers,
    Cluster_* const clusters)
{
    return compute<Index_, Data_, Cluster_, Float_, Matrix<Index_, Data_> >(data, initialize, refine, num_centers, centers, clusters);
}
 
template<typename Index_, typename Cluster_, typename Float_>
struct Results {
    Results(const std::size_t num_dimensions, const Index_ num_observations, const Cluster_ num_centers) : 
        centers(sanisizer::product<I<decltype(centers.size())> >(num_dimensions, num_centers)),
        clusters(num_observations)
    {}
 
    Results() = default;
    std::vector<Cluster_> clusters;
 
    std::vector<Float_> centers;
 
    Details<Index_> details;
};
 
template<typename Index_, typename Data_, typename Cluster_, typename Float_, class Matrix_ = Matrix<Index_, Data_> >
Results<Index_, Cluster_, Float_> compute(
    const Matrix_& data, 
    const Initialize<Index_, Data_, Cluster_, Float_, Matrix_>& initialize, 
    const Refine<Index_, Data_, Cluster_, Float_, Matrix_>& refine,
    const Cluster_ num_centers)
{
    Results<Index_, Cluster_, Float_> output;
    sanisizer::resize(output.clusters, data.num_observations());
    output.centers.resize(sanisizer::product<I<decltype(output.centers.size())> >(num_centers, data.num_dimensions()));
    output.details = compute(data, initialize, refine, num_centers, output.centers.data(), output.clusters.data());
    return output;
}
 
template<typename Index_, typename Data_, typename Cluster_, typename Float_>
Results<Index_, Cluster_, Float_> compute(
    const Matrix<Index_, Data_>& data,
    const Initialize<Index_, Data_, Cluster_, Float_, Matrix<Index_, Data_> >& initialize, 
    const Refine<Index_, Data_, Cluster_, Float_, Matrix<Index_, Data_> >& refine,
    const Cluster_ num_centers)
{
    return compute<Index_, Data_, Cluster_, Float_, Matrix<Index_, Data_> >(data, initialize, refine, num_centers);
}
 
}
 
#endif