compare_helpers.hpp

Go to the documentation of this file.

#ifndef TATAMI_ISOMETRIC_UNARY_COMPARE_HELPERS_H
#define TATAMI_ISOMETRIC_UNARY_COMPARE_HELPERS_H
 
#include "../compare_utils.hpp"
#include <vector>
#include <type_traits>
 
namespace tatami {
 
template<CompareOperation op_, typename InputValue_, typename Index_, typename OutputValue_>
void delayed_compare_run_simple(const InputValue_* input, Index_ length, InputValue_ scalar, OutputValue_* output) {
    for (Index_ i = 0; i < length; ++i) {
        if constexpr(std::is_same<InputValue_, OutputValue_>::value) {
            auto& val = output[i];
            val = delayed_compare<op_>(val, scalar);
        } else {
            output[i] = delayed_compare<op_>(input[i], scalar);
        }
    }
}
 
template<CompareOperation op_, typename InputValue_>
bool delayed_compare_actual_sparse(InputValue_ scalar) {
    return !delayed_compare<op_, InputValue_>(0, scalar);
}
template<CompareOperation op_, typename InputValue_>
class DelayedUnaryIsometricCompareScalar {
public:
    DelayedUnaryIsometricCompareScalar(InputValue_ scalar) : my_scalar(scalar) {
        my_sparse = delayed_compare_actual_sparse<op_>(my_scalar);
    }
 
private:
    InputValue_ my_scalar;
    bool my_sparse;
 
public:
    static constexpr bool is_basic = false;
 
    bool is_sparse() const {
        return my_sparse;
    }
public:
    template<typename Index_, typename OutputValue_>
    void dense(bool, Index_, Index_, Index_ length, const InputValue_* input, OutputValue_* output) const {
        delayed_compare_run_simple<op_>(input, length, my_scalar, output);
    }
 
    template<typename Index_, typename OutputValue_>
    void dense(bool, Index_, const std::vector<Index_>& indices, const InputValue_* input, OutputValue_* output) const {
        delayed_compare_run_simple<op_>(input, static_cast<Index_>(indices.size()), my_scalar, output);
    }
 
    template<typename Index_, typename OutputValue_>
    void sparse(bool, Index_, Index_ number, const InputValue_* input_value, const Index_*, OutputValue_* output_value) const {
        delayed_compare_run_simple<op_>(input_value, number, my_scalar, output_value);
    }
 
    template<typename OutputValue_, typename, typename Index_>
    OutputValue_ fill(bool, Index_) const {
        return delayed_compare<op_, InputValue_>(0, my_scalar);
    }
};
 
template<CompareOperation op_, typename InputValue_, typename Vector_>
class DelayedUnaryIsometricCompareVector {
public:
    DelayedUnaryIsometricCompareVector(Vector_ vector, bool by_row) : my_vector(std::move(vector)), my_by_row(by_row) {
        for (auto x : my_vector) {
             if (!delayed_compare_actual_sparse<op_, InputValue_>(x)) {
                 my_sparse = false;
                 break;
             }
        }
    }
 
private:
    Vector_ my_vector;
    bool my_by_row;
    bool my_sparse = true;
 
public:
    static constexpr bool is_basic = false;
 
    bool zero_depends_on_row() const {
        return my_by_row;
    }
 
    bool zero_depends_on_column() const {
        return !my_by_row;
    }
 
    bool non_zero_depends_on_row() const {
        return my_by_row;
    }
 
    bool non_zero_depends_on_column() const {
        return !my_by_row;
    }
 
    bool is_sparse() const {
        return my_sparse;
    }
public:
    template<typename Index_, typename OutputValue_>
    void dense(bool row, Index_ idx, Index_ start, Index_ length, const InputValue_* input, OutputValue_* output) const {
        if (row == my_by_row) {
            delayed_compare_run_simple<op_, InputValue_>(input, length, my_vector[idx], output);
        } else {
            for (Index_ i = 0; i < length; ++i) {
                if constexpr(std::is_same<InputValue_, OutputValue_>::value) {
                    auto& val = output[i];
                    val = delayed_compare<op_, InputValue_>(val, my_vector[i + start]);
                } else {
                    output[i] = delayed_compare<op_, InputValue_>(input[i], my_vector[i + start]);
                }
            }
        }
    }
 
    template<typename Index_, typename OutputValue_>
    void dense(bool row, Index_ idx, const std::vector<Index_>& indices, const InputValue_* input, OutputValue_* output) const {
        if (row == my_by_row) {
            delayed_compare_run_simple<op_, InputValue_>(input, static_cast<Index_>(indices.size()), my_vector[idx], output);
        } else {
            Index_ length = indices.size();
            for (Index_ i = 0; i < length; ++i) {
                if constexpr(std::is_same<InputValue_, OutputValue_>::value) {
                    auto& val = output[i];
                    val = delayed_compare<op_, InputValue_>(val, my_vector[indices[i]]);
                } else {
                    output[i] = delayed_compare<op_, InputValue_>(input[i], my_vector[indices[i]]);
                }
            }
        }
    }
 
    template<typename Index_, typename OutputValue_>
    void sparse(bool row, Index_ idx, Index_ number, const InputValue_* input, const Index_* indices, OutputValue_* output) const {
        if (row == my_by_row) {
            delayed_compare_run_simple<op_, InputValue_>(input, number, my_vector[idx], output);
        } else {
            for (Index_ i = 0; i < number; ++i) {
                if constexpr(std::is_same<InputValue_, OutputValue_>::value) {
                    auto& val = output[i];
                    val = delayed_compare<op_, InputValue_>(val, my_vector[indices[i]]);
                } else {
                    output[i] = delayed_compare<op_, InputValue_>(input[i], my_vector[indices[i]]);
                }
            }
        }
    }
 
    template<typename OutputValue_, typename, typename Index_>
    OutputValue_ fill(bool row, Index_ idx) const {
        if (row == my_by_row) {
            return delayed_compare<op_, InputValue_>(0, my_vector[idx]);
        } else {
            // We should only get to this point if it's sparse, otherwise no
            // single fill value would work across the length of my_vector.
            return 0;
        }
    }
};
 
template<typename InputValue_ = double>
DelayedUnaryIsometricCompareScalar<CompareOperation::EQUAL, InputValue_> make_DelayedUnaryIsometricEqualScalar(InputValue_ scalar) {
    return DelayedUnaryIsometricCompareScalar<CompareOperation::EQUAL, InputValue_>(std::move(scalar));
}
 
template<typename InputValue_ = double>
DelayedUnaryIsometricCompareScalar<CompareOperation::GREATER_THAN, InputValue_> make_DelayedUnaryIsometricGreaterThanScalar(InputValue_ scalar) {
    return DelayedUnaryIsometricCompareScalar<CompareOperation::GREATER_THAN, InputValue_>(std::move(scalar));
}
 
template<typename InputValue_ = double>
DelayedUnaryIsometricCompareScalar<CompareOperation::LESS_THAN, InputValue_> make_DelayedUnaryIsometricLessThanScalar(InputValue_ scalar) {
    return DelayedUnaryIsometricCompareScalar<CompareOperation::LESS_THAN, InputValue_>(std::move(scalar));
}
 
template<typename InputValue_ = double>
DelayedUnaryIsometricCompareScalar<CompareOperation::GREATER_THAN_OR_EQUAL, InputValue_> make_DelayedUnaryIsometricGreaterThanOrEqualScalar(InputValue_ scalar) {
    return DelayedUnaryIsometricCompareScalar<CompareOperation::GREATER_THAN_OR_EQUAL, InputValue_>(std::move(scalar));
}
 
template<typename InputValue_ = double>
DelayedUnaryIsometricCompareScalar<CompareOperation::LESS_THAN_OR_EQUAL, InputValue_> make_DelayedUnaryIsometricLessThanOrEqualScalar(InputValue_ scalar) {
    return DelayedUnaryIsometricCompareScalar<CompareOperation::LESS_THAN_OR_EQUAL, InputValue_>(std::move(scalar));
}
 
template<typename InputValue_ = double>
DelayedUnaryIsometricCompareScalar<CompareOperation::NOT_EQUAL, InputValue_> make_DelayedUnaryIsometricNotEqualScalar(InputValue_ scalar) {
    return DelayedUnaryIsometricCompareScalar<CompareOperation::NOT_EQUAL, InputValue_>(std::move(scalar));
}
 
template<typename InputValue_ = double, typename Vector_>
DelayedUnaryIsometricCompareVector<CompareOperation::EQUAL, InputValue_, Vector_> make_DelayedUnaryIsometricEqualVector(Vector_ vector, bool by_row) {
    return DelayedUnaryIsometricCompareVector<CompareOperation::EQUAL, InputValue_, Vector_>(std::move(vector), by_row);
}
 
template<typename InputValue_ = double, typename Vector_>
DelayedUnaryIsometricCompareVector<CompareOperation::GREATER_THAN, InputValue_, Vector_> make_DelayedUnaryIsometricGreaterThanVector(Vector_ vector, bool by_row) {
    return DelayedUnaryIsometricCompareVector<CompareOperation::GREATER_THAN, InputValue_, Vector_>(std::move(vector), by_row);
}
 
template<typename InputValue_ = double, typename Vector_>
DelayedUnaryIsometricCompareVector<CompareOperation::LESS_THAN, InputValue_, Vector_> make_DelayedUnaryIsometricLessThanVector(Vector_ vector, bool by_row) {
    return DelayedUnaryIsometricCompareVector<CompareOperation::LESS_THAN, InputValue_, Vector_>(std::move(vector), by_row);
}
 
template<typename InputValue_ = double, typename Vector_>
DelayedUnaryIsometricCompareVector<CompareOperation::GREATER_THAN_OR_EQUAL, InputValue_, Vector_> make_DelayedUnaryIsometricGreaterThanOrEqualVector(Vector_ vector, bool by_row) {
    return DelayedUnaryIsometricCompareVector<CompareOperation::GREATER_THAN_OR_EQUAL, InputValue_, Vector_>(std::move(vector), by_row);
}
 
template<typename InputValue_ = double, typename Vector_>
DelayedUnaryIsometricCompareVector<CompareOperation::LESS_THAN_OR_EQUAL, InputValue_, Vector_> make_DelayedUnaryIsometricLessThanOrEqualVector(Vector_ vector, bool by_row) {
    return DelayedUnaryIsometricCompareVector<CompareOperation::LESS_THAN_OR_EQUAL, InputValue_, Vector_>(std::move(vector), by_row);
}
 
template<typename InputValue_ = double, typename Vector_>
DelayedUnaryIsometricCompareVector<CompareOperation::NOT_EQUAL, InputValue_, Vector_> make_DelayedUnaryIsometricNotEqualVector(Vector_ vector, bool by_row) {
    return DelayedUnaryIsometricCompareVector<CompareOperation::NOT_EQUAL, InputValue_, Vector_>(std::move(vector), by_row);
}
 
template<SpecialCompareOperation op_, bool pass_, typename InputValue_, typename Index_>
void delayed_special_compare_run_simple(InputValue_* buffer, Index_ length) {
    for (Index_ i = 0; i < length; ++i) {
        auto& val = buffer[i];
        val = delayed_special_compare<op_, pass_, InputValue_>(val);
    }
}
 
template<SpecialCompareOperation op_, bool pass_, typename InputValue_, typename Index_, typename OutputValue_>
void delayed_special_compare_run_simple(const InputValue_* input, Index_ length, OutputValue_* output) {
    for (Index_ i = 0; i < length; ++i) {
        output[i] = delayed_special_compare<op_, pass_, InputValue_>(input[i]);
    }
}
 
template<SpecialCompareOperation op_, bool pass_, typename InputValue_>
bool delayed_special_compare_actual_sparse() {
    return !delayed_special_compare<op_, pass_, InputValue_>(0);
}
template<SpecialCompareOperation op_, bool pass_, typename InputValue_>
class DelayedUnaryIsometricSpecialCompare {
public:
    DelayedUnaryIsometricSpecialCompare() {
        my_sparse = !delayed_special_compare<op_, pass_, InputValue_>(0);
    }
 
private:
    bool my_sparse;
 
public:
    static constexpr bool is_basic = false;
 
    bool is_sparse() const {
        return my_sparse;
    }
public:
    template<typename Index_>
    void dense(bool, Index_, Index_, Index_ length, InputValue_* buffer) const {
        delayed_special_compare_run_simple<op_, pass_>(buffer, length);
    }
 
    template<typename Index_, typename OutputValue_>
    void dense(bool, Index_, Index_, Index_ length, const InputValue_* input, OutputValue_* output) const {
        delayed_special_compare_run_simple<op_, pass_>(input, length, output);
    }
 
    template<typename Index_>
    void dense(bool, Index_, const std::vector<Index_>& indices, InputValue_* buffer) const {
        delayed_special_compare_run_simple<op_, pass_>(buffer, static_cast<Index_>(indices.size()));
    }
 
    template<typename Index_, typename OutputValue_>
    void dense(bool, Index_, const std::vector<Index_>& indices, const InputValue_* input, OutputValue_* output) const {
        delayed_special_compare_run_simple<op_, pass_>(input, static_cast<Index_>(indices.size()), output);
    }
 
    template<typename Index_>
    void sparse(bool, Index_, Index_ number, InputValue_* buffer, const Index_*) const {
        delayed_special_compare_run_simple<op_, pass_>(buffer, number);
    }
 
    template<typename Index_, typename OutputValue_>
    void sparse(bool, Index_, Index_ number, const InputValue_* input, const Index_*, OutputValue_* output) const {
        delayed_special_compare_run_simple<op_, pass_>(input, number, output);
    }
 
    template<typename OutputValue_, typename, typename Index_>
    OutputValue_ fill(bool, Index_) const {
        return !my_sparse;
    }
};
 
template<bool pass_ = true, typename InputValue_ = double>
DelayedUnaryIsometricSpecialCompare<SpecialCompareOperation::ISNAN, pass_, InputValue_> make_DelayedUnaryIsometricIsnan() {
    return DelayedUnaryIsometricSpecialCompare<SpecialCompareOperation::ISNAN, pass_, InputValue_>();
}
 
template<bool pass_ = true, typename InputValue_ = double>
DelayedUnaryIsometricSpecialCompare<SpecialCompareOperation::ISINF, pass_, InputValue_> make_DelayedUnaryIsometricIsinf() {
    return DelayedUnaryIsometricSpecialCompare<SpecialCompareOperation::ISINF, pass_, InputValue_>();
}
 
template<bool pass_ = true, typename InputValue_ = double>
DelayedUnaryIsometricSpecialCompare<SpecialCompareOperation::ISFINITE, pass_, InputValue_> make_DelayedUnaryIsometricIsfinite() {
    return DelayedUnaryIsometricSpecialCompare<SpecialCompareOperation::ISFINITE, pass_, InputValue_>();
}
 
}
 
#endif