SanitizeSizeFactors.hpp

#ifndef SCRAN_NORMALIZATION_SANITIZE_SIZE_FACTORS_HPP
#define SCRAN_NORMALIZATION_SANITIZE_SIZE_FACTORS_HPP
 
#include <limits>
#include <cmath>
 
namespace scran {
 
struct SizeFactorValidity {
    bool has_negative = false;
 
    bool has_zero = false;
 
    bool has_nan = false;
 
    bool has_infinite = false;
};
 
template<typename T>
SizeFactorValidity validate_size_factors(size_t n, const T* size_factors) {
    SizeFactorValidity output;
 
    for (size_t i = 0; i < n; ++i) {
        auto sf = size_factors[i];
        if (sf < 0) {
            output.has_negative = true;
        } else if (sf == 0) {
            output.has_zero = true;
        } else if (std::isnan(sf)) {
            output.has_nan = true;
        } else if (std::isinf(sf)) {
            output.has_infinite = true;
        }
    }
 
    return output;
}
 
class SanitizeSizeFactors {
public:
    enum class HandlerAction : char { IGNORE, ERROR, SANITIZE };
 
    struct Defaults {
        static constexpr HandlerAction handle_zero = HandlerAction::ERROR;
 
        static constexpr HandlerAction handle_negative = HandlerAction::ERROR;
 
        static constexpr HandlerAction handle_nan = HandlerAction::ERROR;
 
        static constexpr HandlerAction handle_infinite = HandlerAction::ERROR;
    };
 
private:
    HandlerAction handle_zero = Defaults::handle_zero;
    HandlerAction handle_negative = Defaults::handle_negative;
    HandlerAction handle_nan = Defaults::handle_nan;
    HandlerAction handle_infinite = Defaults::handle_infinite;
 
public:
    SanitizeSizeFactors& set_handle_zero(HandlerAction h = Defaults::handle_zero) {
        handle_zero = h;
        return *this;
    }
 
    SanitizeSizeFactors& set_handle_negative(HandlerAction h = Defaults::handle_negative) {
        handle_negative = h;
        return *this;
    }
 
    SanitizeSizeFactors& set_handle_nan(HandlerAction h = Defaults::handle_nan) {
        handle_nan = h;
        return *this;
    }
 
    SanitizeSizeFactors& set_handle_infinite(HandlerAction h = Defaults::handle_infinite) {
        handle_infinite = h;
        return *this;
    }
 
public:
    SanitizeSizeFactors& set_handle_non_positive(HandlerAction h) {
        set_handle_negative(h);
        set_handle_zero(h);
        return *this;
    }
 
    SanitizeSizeFactors& set_handle_non_finite(HandlerAction h) {
        set_handle_infinite(h);
        set_handle_nan(h);
        return *this;
    }
 
private:
    template<typename T>
    static double find_smallest_valid_factor(size_t n, T* size_factors) {
        auto smallest = std::numeric_limits<double>::infinity();
        for (size_t i = 0; i < n; ++i) {
            auto s = size_factors[i];
            if (smallest > s && s > 0) { // NaN returns false here, and Inf won't be less than the starting 'smallest', so no need to handle these separately.
                smallest = s;
            }
        }
 
        if (std::isinf(smallest)) {
            smallest = 1;
        }
        return smallest;
    }
 
    template<typename T>
    static double find_largest_valid_factor(size_t n, T* size_factors) {
        // Replacing them with the largest non-zero size factor, or 1.
        double largest = 0;
        for (size_t i = 0; i < n; ++i) {
            auto s = size_factors[i];
            if (std::isfinite(s) && largest < s) {
                largest = s;
            }
        }
 
        if (largest == 0) {
            largest = 1;
        }
        return largest;
    }
 
public:
    template<typename T>
    void run(size_t n, T* size_factors, const SizeFactorValidity& status) const {
        T smallest = -1;
 
        if (status.has_negative) {
            if (handle_negative == HandlerAction::ERROR) {
                throw std::runtime_error("detected negative size factor");
            } else if (handle_negative == HandlerAction::SANITIZE) {
                smallest = find_smallest_valid_factor(n, size_factors);
                for (size_t i = 0; i < n; ++i) {
                    auto& s = size_factors[i];
                    if (s < 0) {
                        s = smallest;
                    }
                }
            }
        }
 
        if (status.has_zero) {
            if (handle_zero == HandlerAction::ERROR) {
                throw std::runtime_error("detected size factor of zero");
            } else if (handle_zero == HandlerAction::SANITIZE) {
                if (smallest < 0) {
                    smallest = find_smallest_valid_factor(n, size_factors);
                }
                for (size_t i = 0; i < n; ++i) {
                    auto& s = size_factors[i];
                    if (s == 0) {
                        s = smallest;
                    }
                }
            }
        }
 
        if (status.has_nan) {
            if (handle_nan == HandlerAction::ERROR) {
                throw std::runtime_error("detected NaN size factor");
            } else if (handle_nan == HandlerAction::SANITIZE) {
                for (size_t i = 0; i < n; ++i) {
                    auto& s = size_factors[i];
                    if (std::isnan(s)) {
                        s = 1;
                    }
                }
            }
        }
 
        if (status.has_infinite) {
            if (handle_infinite == HandlerAction::ERROR) {
                throw std::runtime_error("detected infinite size factor");
            } else if (handle_infinite == HandlerAction::SANITIZE) {
                auto largest = find_largest_valid_factor(n, size_factors);
                for (size_t i = 0; i < n; ++i) {
                    auto& s = size_factors[i];
                    if (std::isinf(s)) {
                        s = largest;
                    }
                }
            }
        }
    }
 
public:
    template<typename T>
    void run(size_t n, T* size_factors) const {
        auto status = validate_size_factors(n, size_factors);
        run(n, size_factors, status);
    }
};
 
}
 
#endif