utils.hpp

Go to the documentation of this file.

#ifndef QDTSNE_UTILS_HPP
#define QDTSNE_UTILS_HPP
 
#include <random>
#include <cmath>
#include <vector>
 
#include "aarand/aarand.hpp"
#include "knncolle/knncolle.hpp"
 
#ifndef QDTSNE_CUSTOM_PARALLEL
#include "subpar/subpar.hpp"
#endif
 
namespace qdtsne {
 
template<typename Index_, typename Float_>
using NeighborList = knncolle::NeighborList<Index_, Float_>;
 
inline int perplexity_to_k(double perplexity) {
    return std::ceil(perplexity * 3);
}
 
template<int num_dim_, typename Float_ = double>
void initialize_random(Float_* Y, size_t num_points, int seed = 42) {
    std::mt19937_64 rng(seed);
 
    size_t total = num_points * num_dim_;
    bool odd = total % 2;
    if (odd) {
        --total;
    }
 
    // Box-Muller gives us two random values at a time.
    for (size_t i = 0; i < total; i += 2) {
        auto paired = aarand::standard_normal<Float_>(rng);
        Y[i] = paired.first;
        Y[i + 1] = paired.second;
    }
 
    if (odd) {
        // Adding the poor extra for odd total lengths.
        auto paired = aarand::standard_normal<Float_>(rng);
        Y[total] = paired.first;
    }
 
    return;
}
 
template<int num_dim_, typename Float_ = double>
std::vector<Float_> initialize_random(size_t num_points, int seed = 42) {
    std::vector<Float_> Y(num_dim_ * num_points);
    initialize_random<num_dim_>(Y.data(), num_points, seed);
    return Y;
}
 
template<typename Task_, class Run_>
void parallelize(int num_workers, Task_ num_tasks, Run_ run_task_range) {
#ifndef QDTSNE_CUSTOM_PARALLEL
    // Don't make this nothrow_ = true, there's too many allocations and the
    // derived methods for the nearest neighbors search could do anything...
    subpar::parallelize(num_workers, num_tasks, std::move(run_task_range));
#else
    QDTSNE_CUSTOM_PARALLEL(num_workers, num_tasks, run_task_range);
#endif
}
 
}
 
#endif