FilterCells.hpp

Go to the documentation of this file.

#ifndef SCRAN_FILTER_CELLS_H
#define SCRAN_FILTER_CELLS_H
 
#include "../utils/macros.hpp"
 
#include "tatami/tatami.hpp"
#include <vector>
#include <numeric>
#include <algorithm>
 
namespace scran {
 
class FilterCells {
public:
    struct Defaults {
        static constexpr bool discard = true;
 
        static constexpr bool intersect = false;
    };
 
private:
    bool discard = Defaults::discard;
    bool intersect = Defaults::intersect;
 
public:
    FilterCells& set_retain() {
        discard = false;
        return *this;
    }
 
    FilterCells& set_discard(bool d = Defaults::discard) {
        discard = d;
        return *this;
    }
 
    FilterCells& set_intersect(bool i = Defaults::intersect) {
        intersect = i;
        return *this;
    }
 
public:
    template<class MAT, typename IDX = int, typename X = uint8_t>
    std::shared_ptr<MAT> run(std::shared_ptr<MAT> mat, const X* filter) {
        size_t NC = mat->ncol();
 
        // Don't use accumulate: we want to defend against non-0/1 values in 'filter'.
        IDX num = 0;
        for (size_t i = 0; i < NC; ++i) {
            num += (filter[i] != 0);
        }
 
        std::vector<IDX> retained;
        retained.reserve(discard ? (NC - num) : num);
 
        for (size_t i = 0; i < NC; ++i) {
            if (discard == (filter[i] == 0)) {
                retained.push_back(i);
            }
        }
 
        return tatami::make_DelayedSubset<1>(mat, retained);
    }
 
public:
    template<class MAT, typename IDX = int, typename X = uint8_t>
    std::shared_ptr<MAT> run(std::shared_ptr<MAT> mat, const std::vector<X*>& filters) {
        size_t NC = mat->ncol();
 
        std::vector<uint8_t> finalvec(NC, intersect);
        if (intersect) {
            for (auto filter : filters) {
                for (size_t i = 0; i < NC; ++i) {
                    finalvec[i] &= static_cast<uint8_t>(filter[i] != 0);
                }
            }
        } else {
            for (auto filter : filters) {
                for (size_t i = 0; i < NC; ++i) {
                    finalvec[i] |= static_cast<uint8_t>(filter[i] != 0);
                }
            }
        }
 
        IDX num = std::accumulate(finalvec.begin(), finalvec.end(), static_cast<IDX>(0));
        std::vector<IDX> retained;
        retained.reserve(discard ? (NC - num) : num);
 
        for (size_t i = 0; i < NC; ++i) {
            if (discard == (finalvec[i] == 0)) {
                retained.push_back(i);
            }
        }
 
        return tatami::make_DelayedSubset<1>(mat, retained);
    }
};
 
}
 
#endif