utils.hpp

Go to the documentation of this file.

#ifndef TATAMI_STATS__UTILS_HPP
#define TATAMI_STATS__UTILS_HPP
 
#include <vector>
#include <algorithm>
#include <cstddef>
#include <type_traits>
 
#include "sanisizer/sanisizer.hpp"
#include "tatami/tatami.hpp"
 
namespace tatami_stats {
 
template<typename Input_>
using I = std::remove_cv_t<std::remove_reference_t<Input_> >;
 
template<typename Value_, typename Index_>
Index_ shift_nans(Value_* const ptr, const Index_ num) {
    Index_ pos = 0;
    for (Index_ i = 0; i < num; ++i) {
        if (std::isnan(ptr[i])) {
            std::swap(ptr[i], ptr[pos]);
            ++pos;
        }
    }
    return pos;
}
template<typename Number_ = std::size_t, typename Group_>
Number_ total_groups(const Group_* group, std::size_t n) {
    if (n) {
        return sanisizer::sum<Number_>(*std::max_element(group, group + n), 1);
    } else {
        return 0;
    }
}
 
template<typename Group_, typename Size_>
std::vector<Size_> tabulate_groups(const Group_* group, Size_ n) {
    const auto ngroups = total_groups<typename std::vector<Size_>::size_type>(group, n);
    auto group_sizes = sanisizer::create<std::vector<Size_> >(ngroups);
    for (Size_ r = 0; r < n; ++r) {
        ++(group_sizes[group[r]]);
    }
    return group_sizes;
}
 
template<typename Output_>
class LocalOutputBuffer {
public:
    template<typename Index_>
    LocalOutputBuffer(int thread, Index_ start, Index_ length, Output_* output, Output_ fill) : 
        my_output(output + sanisizer::cast<std::size_t>(start)),
        use_local(thread > 0),
        my_buffer(use_local ? sanisizer::cast<I<decltype(my_buffer.size())> >(length) : static_cast<I<decltype(my_buffer.size())> >(0), fill)
    {
        if (!use_local) {
            // Setting to zero to match the initial behavior of 'my_buffer' when 'use_local = true'.
            std::fill_n(my_output, length, fill);
        }
    }
 
    template<typename Index_>
    LocalOutputBuffer(int thread, Index_ start, Index_ length, Output_* output) : LocalOutputBuffer(thread, start, length, output, 0) {}
 
    LocalOutputBuffer() = default;
 
    Output_* data() {
        return (use_local ? my_buffer.data() : my_output);
    }
 
    const Output_* data() const {
        return (use_local ? my_buffer.data() : my_output);
    }
 
    void transfer() {
        if (use_local) {
            std::copy(my_buffer.begin(), my_buffer.end(), my_output);
        }
    }
 
private:
    Output_* my_output = NULL;
    bool use_local = false;
    std::vector<Output_> my_buffer;
};
 
template<typename Output_, class GetOutput_>
class LocalOutputBuffers {
public:
    template<typename Number_, typename Index_>
    LocalOutputBuffers(int thread, Number_ number, Index_ start, Index_ length, GetOutput_ outfun, Output_ fill) : 
        my_number(sanisizer::cast<I<decltype(my_number)> >(number)),
        my_start(sanisizer::cast<I<decltype(my_start)> >(start)),
        my_use_local(thread > 0),
        my_getter(std::move(outfun))
    {
        if (thread == 0) {
            for (I<decltype(my_number)> i = 0; i < my_number; ++i) {
                // Setting to the fill to match the initial behavior of 'my_buffer' when 'thread > 0'.
                std::fill_n(my_getter(i) + my_start, length, fill);
            }
        } else {
            my_buffers.reserve(my_number);
            for (I<decltype(my_number)> i = 0; i < my_number; ++i) {
                my_buffers.emplace_back(tatami::can_cast_Index_to_container_size<typename I<decltype(my_buffers)>::value_type>(length), fill);
            }
        }
    }
 
    template<typename Number_, typename Index_>
    LocalOutputBuffers(int thread, Number_ number, Index_ start, Index_ length, GetOutput_ outfun) :
        LocalOutputBuffers(thread, number, start, length, std::move(outfun), 0) {}
 
    LocalOutputBuffers() = default;
 
    std::size_t size() const {
        return my_number;
    }
 
    Output_* data(std::size_t i) {
        return (my_use_local ? my_buffers[i].data() : my_getter(i) + my_start);
    }
 
    const Output_* data(std::size_t i) const {
        return (my_use_local ? my_buffers[i].data() : my_getter(i) + my_start);
    }
 
    void transfer() {
        if (my_use_local) {
            for (I<decltype(my_number)> i = 0; i < my_number; ++i) {
                const auto& current = my_buffers[i];
                std::copy(current.begin(), current.end(), my_getter(i) + my_start);
            }
        }
    }
 
private:
    std::size_t my_number = 0;
    std::size_t my_start = 0;
    bool my_use_local = true;
    std::vector<std::vector<Output_> > my_buffers;
    GetOutput_ my_getter;
};
 
namespace internal {
 
template<typename Value_, class If_, class Else_>
void nanable_ifelse(bool skip_nan, If_ iffun, Else_ elsefun) {
    if constexpr(std::numeric_limits<Value_>::has_quiet_NaN) {
        if (skip_nan) {
            iffun();
            return;
        }
    }
    elsefun();
}
 
template<typename Value_, class If_, class Else_>
auto nanable_ifelse_with_value(bool skip_nan, If_ iffun, Else_ elsefun) {
    if constexpr(std::numeric_limits<Value_>::has_quiet_NaN) {
        if (skip_nan) {
            return iffun();
        }
    }
    return elsefun();
}
 
}
}
 
#endif