sanitize_size_factors.hpp

Go to the documentation of this file.

#ifndef SCRAN_SANITIZE_SIZE_FACTORS_HPP
#define SCRAN_SANITIZE_SIZE_FACTORS_HPP
 
#include <cmath>
#include <stdexcept>
#include <cstddef>
 
#include "utils.hpp"
 
namespace scran_norm {
 
struct SizeFactorDiagnostics {
    bool has_negative = false;
 
    bool has_zero = false;
 
    bool has_nan = false;
 
    bool has_infinite = false;
};
 
namespace internal {
 
template<typename SizeFactor_>
bool is_invalid(SizeFactor_ sf, SizeFactorDiagnostics& output) {
    if (sf < 0) {
        output.has_negative = true;
        return true;
    }
 
    if (sf == 0) {
        output.has_zero = true;
        return true;
    }
 
    if (std::isnan(sf)) {
        output.has_nan = true;
        return true;
    }
 
    if (std::isinf(sf)) {
        output.has_infinite = true;
        return true;
    }
 
    return false;
}
 
template<typename SizeFactor_>
SizeFactor_ find_smallest_valid_factor(const std::size_t num, const SizeFactor_* const size_factors) {
    SizeFactor_ smallest = 1;
    bool found = false;
 
    for (decltype(I(num)) i = 0; i < num; ++i) {
        const auto s = size_factors[i];
        if (std::isfinite(s) && s > 0) {
            if (!found || smallest > s) {
                smallest = s;
                found = true;
            }
        }
    }
 
    return smallest;
}
 
template<typename SizeFactor_>
SizeFactor_ find_largest_valid_factor(const std::size_t num, const SizeFactor_* const size_factors) {
    SizeFactor_ largest = 1;
    bool found = false;
 
    for (decltype(I(num)) i = 0; i < num; ++i) {
        const auto s = size_factors[i];
        if (std::isfinite(s) && s > 0) {
            if (!found || largest < s) {
                largest = s;
                found = true;
            }
        }
    }
 
    return largest;
}
 
}
template<typename SizeFactor_>
SizeFactorDiagnostics check_size_factor_sanity(const std::size_t num, const SizeFactor_* const size_factors) {
    SizeFactorDiagnostics output;
    for (decltype(I(num)) i = 0; i < num; ++i) {
        internal::is_invalid(size_factors[i], output);
    }
    return output;
}
 
enum class SanitizeAction : char { IGNORE, ERROR, SANITIZE };
 
struct SanitizeSizeFactorsOptions {
    SanitizeAction handle_zero = SanitizeAction::ERROR;
 
    SanitizeAction handle_negative = SanitizeAction::ERROR;
 
    SanitizeAction handle_nan = SanitizeAction::ERROR;
 
    SanitizeAction handle_infinite = SanitizeAction::ERROR;
};
 
template<typename SizeFactor_>
void sanitize_size_factors(const std::size_t num, SizeFactor_* const size_factors, const SizeFactorDiagnostics& status, const SanitizeSizeFactorsOptions& options) {
    SizeFactor_ smallest = -1;
 
    if (status.has_negative) {
        if (options.handle_negative == SanitizeAction::ERROR) {
            throw std::runtime_error("detected negative size factor");
        } else if (options.handle_negative == SanitizeAction::SANITIZE) {
            smallest = internal::find_smallest_valid_factor(num, size_factors);
            for (decltype(I(num)) i = 0; i < num; ++i) {
                auto& s = size_factors[i];
                if (s < 0) {
                    s = smallest;
                }
            }
        }
    }
 
    if (status.has_zero) {
        if (options.handle_zero == SanitizeAction::ERROR) {
            throw std::runtime_error("detected size factor of zero");
        } else if (options.handle_zero == SanitizeAction::SANITIZE) {
            if (smallest < 0) {
                smallest = internal::find_smallest_valid_factor(num, size_factors);
            }
            for (decltype(I(num)) i = 0; i < num; ++i) {
                auto& s = size_factors[i];
                if (s == 0) {
                    s = smallest;
                }
            }
        }
    }
 
    if (status.has_nan) {
        if (options.handle_nan == SanitizeAction::ERROR) {
            throw std::runtime_error("detected NaN size factor");
        } else if (options.handle_nan == SanitizeAction::SANITIZE) {
            for (decltype(I(num)) i = 0; i < num; ++i) {
                auto& s = size_factors[i];
                if (std::isnan(s)) {
                    s = 1;
                }
            }
        }
    }
 
    if (status.has_infinite) {
        if (options.handle_infinite == SanitizeAction::ERROR) {
            throw std::runtime_error("detected infinite size factor");
        } else if (options.handle_infinite == SanitizeAction::SANITIZE) {
            auto largest = internal::find_largest_valid_factor(num, size_factors);
            for (decltype(I(num)) i = 0; i < num; ++i) {
                auto& s = size_factors[i];
                if (std::isinf(s)) {
                    s = largest;
                }
            }
        }
    }
}
 
template<typename SizeFactor_>
SizeFactorDiagnostics sanitize_size_factors(const std::size_t num, SizeFactor_* const size_factors, const SanitizeSizeFactorsOptions& options) {
    const auto output = check_size_factor_sanity(num, size_factors);
    sanitize_size_factors(num, size_factors, output, options);
    return output;
}
 
}
 
#endif