Status.hpp

Go to the documentation of this file.

#ifndef UMAPPP_STATUS_HPP
#define UMAPPP_STATUS_HPP
 
#include <cstddef>
 
#include "sanisizer/sanisizer.hpp"
 
#include "Options.hpp"
#include "optimize_layout.hpp"
 
namespace umappp {
 
template<typename Index_, typename Float_>
class Status {
public:
    Status(internal::EpochData<Index_, Float_> epochs, Options options, const std::size_t num_dim) :
        my_epochs(std::move(epochs)),
        my_options(std::move(options)),
        my_engine(my_options.optimize_seed),
        my_num_dim(num_dim)
    {}
private:
    internal::EpochData<Index_, Float_> my_epochs;
    Options my_options;
    RngEngine my_engine;
    std::size_t my_num_dim;
 
public:
    // Only used for testing, specifically in comparison to uwot:::data2set.
    const auto& get_epoch_data() const {
        return my_epochs;
    }
public:
    std::size_t num_dimensions() const {
        return my_num_dim;
    }
 
    int epoch() const {
        return my_epochs.current_epoch;
    }
 
    int num_epochs() const {
        return my_epochs.total_epochs;
    }
 
    Index_ num_observations() const {
        return my_epochs.cumulative_num_edges.size() - 1;
    }
 
public:
    void run(Float_* const embedding, int epoch_limit) {
        if (my_options.num_threads == 1 || !my_options.parallel_optimization) {
            internal::optimize_layout<Index_, Float_>(
                my_num_dim,
                embedding,
                my_epochs,
                my_options.a,
                my_options.b,
                my_options.repulsion_strength,
                my_options.learning_rate,
                my_engine,
                epoch_limit
            );
        } else {
            internal::optimize_layout_parallel<Index_, Float_>(
                my_num_dim,
                embedding,
                my_epochs,
                my_options.a,
                my_options.b,
                my_options.repulsion_strength,
                my_options.learning_rate,
                my_engine,
                epoch_limit,
                my_options.num_threads
            );
        }
    }
 
    void run(Float_* const embedding) {
        run(embedding, my_epochs.total_epochs);
    }
};
 
}
 
#endif