utils.hpp

Go to the documentation of this file.

#ifndef QDTSNE_UTILS_HPP
#define QDTSNE_UTILS_HPP
 
#include <random>
#include <cmath>
#include <vector>
#include <cstddef>
#include <type_traits>
 
#include "aarand/aarand.hpp"
#include "knncolle/knncolle.hpp"
#include "sanisizer/sanisizer.hpp"
 
#ifndef QDTSNE_CUSTOM_PARALLEL
#include "subpar/subpar.hpp"
#endif
 
namespace qdtsne {
 
template<typename Index_, typename Float_>
using NeighborList = knncolle::NeighborList<Index_, Float_>;
 
template<typename Index_ = int>
Index_ perplexity_to_k(const double perplexity) {
    return sanisizer::from_float<Index_>(std::ceil(perplexity * 3));
}
 
template<std::size_t num_dim_, typename Float_ = double>
void initialize_random(Float_* const Y, const std::size_t num_points, const unsigned long long seed = 42) {
    // The constructor accepts an unsigned type, so any overflow should just wrap around harmlessly. 
    std::mt19937_64 rng(seed);
 
    // Presumably a size_t can store the product in order to allocate Y in the first place.
    std::size_t num_total = sanisizer::product_unsafe<std::size_t>(num_points, num_dim_);
    const bool odd = num_total % 2;
    if (odd) {
        --num_total;
    }
 
    // Box-Muller gives us two random values at a time.
    for (std::size_t i = 0; i < num_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[num_total] = paired.first;
    }
 
    return;
}
 
template<std::size_t num_dim_, typename Float_ = double>
std::vector<Float_> initialize_random(const std::size_t num_points, const unsigned long long seed = 42) {
    std::vector<Float_> Y(sanisizer::product<typename std::vector<Float_>::size_type>(num_points, num_dim_));
    initialize_random<num_dim_>(Y.data(), num_points, seed);
    return Y;
}
 
template<typename Task_, class Run_>
void parallelize(const int num_workers, const 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
}
 
template<typename Input_>
std::remove_cv_t<std::remove_reference_t<Input_> > I(const Input_ x) {
    return x;
}
}
 
#endif