normalize_counts.hpp

Go to the documentation of this file.

#ifndef SCRAN_NORM_NORMALIZE_COUNTS_HPP
#define SCRAN_NORM_NORMALIZE_COUNTS_HPP
 
#include <type_traits>
#include <vector>
#include <memory>
 
#include "tatami/tatami.hpp"
 
namespace scran_norm {
 
struct NormalizeCountsOptions {
    double pseudo_count = 1;
 
    bool preserve_sparsity = false;
 
    bool log = true;
 
    double log_base = 2;
};
 
template<typename OutputValue_ = double, typename InputValue_, typename Index_, class SizeFactors_>
std::shared_ptr<tatami::Matrix<OutputValue_, Index_> > normalize_counts(
    std::shared_ptr<const tatami::Matrix<InputValue_, Index_> > counts, 
    SizeFactors_ size_factors, 
    const NormalizeCountsOptions& options) 
{
    auto current_pseudo = options.pseudo_count;
    if (options.preserve_sparsity && current_pseudo != 1 && options.log) {
        for (auto& x : size_factors) { 
            x *= current_pseudo;
        }
        current_pseudo = 1;
    }
 
    static_assert(std::is_floating_point<OutputValue_>::value);
    if (static_cast<size_t>(size_factors.size()) != static_cast<size_t>(counts->ncol())) {
        throw std::runtime_error("length of 'size_factors' should be equal to the number of columns of 'counts'");
    }
 
    auto div = tatami::make_DelayedUnaryIsometricOperation<OutputValue_>(
        std::move(counts), 
        tatami::make_DelayedUnaryIsometricDivideVector<true, InputValue_, SizeFactors_>(
            std::move(size_factors), 
            false
        )
    );
 
    if (!options.log) {
        return div;
    }
 
    if (current_pseudo == 1) {
        return tatami::make_DelayedUnaryIsometricOperation<OutputValue_>(
            std::move(div), 
            tatami::DelayedUnaryIsometricLog1p<OutputValue_, OutputValue_>(options.log_base)
        );
    } else {
        auto add = tatami::make_DelayedUnaryIsometricOperation<OutputValue_>(
            std::move(div), 
            tatami::make_DelayedUnaryIsometricAddScalar<OutputValue_>(current_pseudo)
        );
        return tatami::make_DelayedUnaryIsometricOperation<OutputValue_>(
            std::move(add), 
            tatami::DelayedUnaryIsometricLog<OutputValue_, OutputValue_>(options.log_base)
        );
    }
};
 
// Overload for template deduction.
template<typename OutputValue_ = double, typename InputValue_, typename Index_, class SizeFactors_>
std::shared_ptr<tatami::Matrix<OutputValue_, Index_> > normalize_counts(
    std::shared_ptr<tatami::Matrix<InputValue_, Index_> > counts,
    SizeFactors_ size_factors,
    const NormalizeCountsOptions& options)
{
    return normalize_counts(std::shared_ptr<const tatami::Matrix<InputValue_, Index_> >(std::move(counts)), std::move(size_factors), options);
}
}
 
#endif