kmeans.hpp

Go to the documentation of this file.

#ifndef KMEANS_KMEANS_HPP
#define KMEANS_KMEANS_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"
 
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);
    output.sizes.resize(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,
    Cluster_ num_centers,
    Float_* centers,
    Cluster_* 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 {
    template<typename Dim_>
    Results(Dim_ num_dimensions, Index_ num_observations, Cluster_ num_centers) : 
        centers(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,
    Cluster_ num_centers)
{
    Results<Index_, Cluster_, Float_> output;
    output.clusters.resize(data.num_observations());
    output.centers.resize(static_cast<size_t>(num_centers) * static_cast<size_t>(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,
    Cluster_ num_centers)
{
    return compute<Index_, Data_, Cluster_, Float_, Matrix<Index_, Data_> >(data, initialize, refine, num_centers);
}
 
}
 
#endif