test_access.hpp

Go to the documentation of this file.

#ifndef TATAMI_TEST_TEST_ACCESS_HPP
#define TATAMI_TEST_TEST_ACCESS_HPP
 
#include <gtest/gtest.h>
 
#include "tatami/utils/new_extractor.hpp"
#include "tatami/utils/ConsecutiveOracle.hpp"
#include "tatami/utils/FixedOracle.hpp"
 
#include "fetch.hpp"
#include "create_indexed_subset.hpp"
 
#include <vector>
#include <limits>
#include <random>
#include <cmath>
#include <memory>
#include <cstdint>
#include <type_traits>
 
namespace tatami_test {
 
enum class TestAccessOrder : char { FORWARD, REVERSE, RANDOM };
 
struct TestAccessOptions {
    bool use_oracle = false;
 
    bool use_row = true;
 
    TestAccessOrder order = TestAccessOrder::FORWARD;
 
    int jump = 1;
 
    bool check_sparse = true;
};
 
typedef std::tuple<bool, bool, TestAccessOrder, int> StandardTestAccessOptions;
 
inline TestAccessOptions convert_test_access_options(const StandardTestAccessOptions& x) {
    TestAccessOptions output;
    output.use_row = std::get<0>(x);
    output.use_oracle = std::get<1>(x);
    output.order = std::get<2>(x);
    output.jump = std::get<3>(x);
    return output;
}
 
inline auto standard_test_access_options_combinations() {
    return ::testing::Combine(
        ::testing::Values(true, false), /* whether to access the rows. */
        ::testing::Values(true, false), /* whether to use an oracle. */
        ::testing::Values(TestAccessOrder::FORWARD, TestAccessOrder::REVERSE, TestAccessOrder::RANDOM), /* access order. */
        ::testing::Values(1, 3) /* jump between rows/columns. */
    );
}
 
namespace internal {
 
template<typename Value_>
void compare_vectors(const std::vector<Value_>& expected, const std::vector<Value_>& observed, const std::string& context) {
    size_t n_expected = expected.size();
    ASSERT_EQ(n_expected, observed.size()) << "mismatch in vector length (" << context << ")";
    for (size_t i = 0; i < n_expected; ++i) {
        auto expected_val = expected[i], observed_val = observed[i];
        if (std::isnan(expected_val)) {
            EXPECT_EQ(std::isnan(expected_val), std::isnan(observed_val)) << "mismatching NaNs at position " << i << " (" << context << ")";
        } else {
            EXPECT_EQ(expected_val, observed_val) << "different values at position " << i << " (" << context << ")";
        }
    }
}
 
template<typename Index_>
uint64_t create_seed(Index_ NR, Index_ NC, const TestAccessOptions& options) {
    uint64_t seed = static_cast<uint64_t>(NR) * static_cast<uint64_t>(NC);
    seed += 13 * static_cast<uint64_t>(options.use_row);
    seed += 57 * static_cast<uint64_t>(options.order);
    seed += 101 * static_cast<uint64_t>(options.jump);
    return seed;
}
 
template<typename Index_>
std::vector<Index_> simulate_test_access_sequence(Index_ NR, Index_ NC, const TestAccessOptions& options) {
    std::vector<Index_> sequence;
    auto limit = (options.use_row ? NR : NC);
 
    std::mt19937_64 rng(create_seed(NR, NC, options));
    Index_ start = rng() % options.jump;
    if (start < limit) {
        while (1) {
            sequence.push_back(start);
            Index_ remainder = limit - start;
            // Make sure this comparison involves two unsigned integers to avoid GCC warnings.
            if (static_cast<typename std::make_unsigned<Index_>::type>(remainder) <= static_cast<typename std::make_unsigned<int>::type>(options.jump)) {
                break;
            }
            start += options.jump;
        }
    }
 
    if (options.order == TestAccessOrder::REVERSE) {
        std::reverse(sequence.begin(), sequence.end());
    } else if (options.order == TestAccessOrder::RANDOM) {
        std::shuffle(sequence.begin(), sequence.end(), rng);
    }
 
    return sequence;
}
 
template<bool use_oracle_, typename Index_>
tatami::MaybeOracle<use_oracle_, Index_> create_oracle(const std::vector<Index_>& sequence, const TestAccessOptions& options) {
    if constexpr(use_oracle_) {
        std::shared_ptr<tatami::Oracle<Index_> > oracle;
        if (options.jump == 1 && options.order == TestAccessOrder::FORWARD) {
            oracle.reset(new tatami::ConsecutiveOracle<Index_>(0, sequence.size()));
        } else {
            oracle.reset(new tatami::FixedViewOracle<Index_>(sequence.data(), sequence.size()));
        }
        return oracle;
    } else {
        return false;
    }
}
 
template<bool use_oracle_, typename Value_, typename Index_, class SparseExpand_, typename ...Args_>
void test_access_base(
    const tatami::Matrix<Value_, Index_>& matrix, 
    const tatami::Matrix<Value_, Index_>& reference, 
    const TestAccessOptions& options, 
    Index_ extent,
    SparseExpand_ sparse_expand, 
    Args_... args) 
{
    auto NR = matrix.nrow();
    ASSERT_EQ(NR, reference.nrow());
    auto NC = matrix.ncol();
    ASSERT_EQ(NC, reference.ncol());
 
    auto refwork = (options.use_row ? reference.dense_row(args...) : reference.dense_column(args...));
 
    auto sequence = simulate_test_access_sequence(NR, NC, options);
    auto oracle = create_oracle<use_oracle_>(sequence, options);
 
    auto pwork = tatami::new_extractor<false, use_oracle_>(&matrix, options.use_row, oracle, args...);
    auto swork = tatami::new_extractor<true, use_oracle_>(&matrix, options.use_row, oracle, args...);
 
    tatami::Options opt;
    opt.sparse_extract_index = false;
    auto swork_v = tatami::new_extractor<true, use_oracle_>(&matrix, options.use_row, oracle, args..., opt);
 
    opt.sparse_extract_value = false;
    auto swork_n = tatami::new_extractor<true, use_oracle_>(&matrix, options.use_row, oracle, args..., opt);
 
    opt.sparse_extract_index = true;
    auto swork_i = tatami::new_extractor<true, use_oracle_>(&matrix, options.use_row, oracle, args..., opt);
 
    size_t sparse_counter = 0;
 
    // Looping over rows/columns and checking extraction against the reference.
    for (auto i : sequence) {
        auto expected = fetch(*refwork, i, extent);
 
        // Checking dense retrieval first.
        {
            auto observed = [&]() {
                if constexpr(use_oracle_) {
                    return fetch(*pwork, extent);
                } else {
                    return fetch(*pwork, i, extent);
                }
            }();
            compare_vectors(expected, observed, "dense retrieval");
        }
 
        // Various flavors of sparse retrieval.
        {
            auto observed = [&]() {
                if constexpr(use_oracle_) {
                    return fetch(*swork, extent);
                } else {
                    return fetch(*swork, i, extent);
                }
            }();
            compare_vectors(expected, sparse_expand(observed), "sparse retrieval");
 
            sparse_counter += observed.value.size();
            {
                bool is_increasing = true;
                for (size_t i = 1; i < observed.index.size(); ++i) {
                    if (observed.index[i] <= observed.index[i-1]) {
                        is_increasing = false;
                        break;
                    }
                }
                ASSERT_TRUE(is_increasing);
            }
 
            std::vector<Index_> indices(extent);
            auto observed_i = [&]() {
                if constexpr(use_oracle_) {
                    return swork_i->fetch(NULL, indices.data());
                } else {
                    return swork_i->fetch(i, NULL, indices.data());
                }
            }();
            ASSERT_TRUE(observed_i.value == NULL);
            tatami::copy_n(observed_i.index, observed_i.number, indices.data());
            indices.resize(observed_i.number);
            ASSERT_EQ(observed.index, indices);
 
            std::vector<Value_> values(extent);
            auto observed_v = [&]() {
                if constexpr(use_oracle_) {
                    return swork_v->fetch(values.data(), NULL);
                } else {
                    return swork_v->fetch(i, values.data(), NULL);
                }
            }();
            ASSERT_TRUE(observed_v.index == NULL);
            tatami::copy_n(observed_v.value, observed_v.number, values.data());
            values.resize(observed_v.number);
            compare_vectors(values, observed.value, "sparse retrieval with values only");
 
            auto observed_n = [&]() {
                if constexpr(use_oracle_) {
                    return swork_n->fetch(NULL, NULL);
                } else {
                    return swork_n->fetch(i, NULL, NULL);
                }
            }();
            ASSERT_TRUE(observed_n.value == NULL);
            ASSERT_TRUE(observed_n.index == NULL);
            ASSERT_EQ(observed.value.size(), observed_n.number);
        } 
    }
 
    if (options.check_sparse && matrix.is_sparse()) {
        EXPECT_TRUE(sparse_counter < static_cast<size_t>(NR) * static_cast<size_t>(NC));
    }
}
 
template<bool use_oracle_, typename Value_, typename Index_>
void test_full_access(
    const tatami::Matrix<Value_, Index_>& matrix, 
    const tatami::Matrix<Value_, Index_>& reference,
    const TestAccessOptions& options)
{
    Index_ nsecondary = (options.use_row ? reference.ncol() : reference.nrow());
    test_access_base<use_oracle_>(
        matrix,
        reference,
        options,
        nsecondary,
        [&](const auto& svec) -> auto {
            std::vector<Value_> output(nsecondary);
            size_t nnz = svec.index.size();
            for (size_t i = 0; i < nnz; ++i) {
                output[svec.index[i]] = svec.value[i];
            }
            return output;
        }
    );
}
 
template<bool use_oracle_, typename Value_, typename Index_>
void test_block_access(
    const tatami::Matrix<Value_, Index_>& matrix, 
    const tatami::Matrix<Value_, Index_>& reference,
    double relative_start,
    double relative_length,
    const TestAccessOptions& options)
{
    Index_ nsecondary = (options.use_row ? reference.ncol() : reference.nrow());
    Index_ start = nsecondary * relative_start;
    Index_ length = nsecondary * relative_length;
    test_access_base<use_oracle_>(
        matrix, 
        reference, 
        options,
        length,
        [&](const auto& svec) -> auto {
            std::vector<Value_> output(length);
            size_t nnz = svec.index.size();
            for (size_t i = 0; i < nnz; ++i) {
                output[svec.index[i] - start] = svec.value[i];
            }
            return output;
        },
        start,
        length
    );
}
 
template<bool use_oracle_, typename Value_, typename Index_>
void test_indexed_access(
    const tatami::Matrix<Value_, Index_>& matrix, 
    const tatami::Matrix<Value_, Index_>& reference,
    double relative_start,
    double probability,
    const TestAccessOptions& options)
{
    Index_ nsecondary = (options.use_row ? reference.ncol() : reference.nrow());
    auto index_ptr = create_indexed_subset(
        nsecondary,
        relative_start,
        probability,
        create_seed(matrix.nrow(), matrix.ncol(), options) + 999 * probability + 85 * relative_start
    );
 
    Index_ num_indices = index_ptr->size();
    std::vector<size_t> reposition(nsecondary, -1);
    {
        const auto& indices = *index_ptr;
        for (Index_ i = 0; i < num_indices; ++i) {
            reposition[indices[i]] = i;
        }
    }
 
    test_access_base<use_oracle_>(
        matrix,
        reference,
        options,
        num_indices,
        [&](const auto& svec) -> auto {
            std::vector<Value_> expected(num_indices);
            size_t nnz = svec.index.size();
            for (size_t i = 0; i < nnz; ++i) {
                expected[reposition[svec.index[i]]] = svec.value[i];
            }
            return expected;
        },
        std::move(index_ptr)
    );
}
 
}
template<typename Value_, typename Index_>
void test_full_access(
    const tatami::Matrix<Value_, Index_>& matrix,
    const tatami::Matrix<Value_, Index_>& reference,
    const TestAccessOptions& options)
{
    if (options.use_oracle) {
        internal::test_full_access<true>(matrix, reference, options);
    } else {
        internal::test_full_access<false>(matrix, reference, options);
    }
}
 
template<typename Value_, typename Index_>
void test_block_access(
    const tatami::Matrix<Value_, Index_>& matrix, 
    const tatami::Matrix<Value_, Index_>& reference,
    double relative_start,
    double relative_length,
    const TestAccessOptions& options)
{
    if (options.use_oracle) {
        internal::test_block_access<true>(matrix, reference, relative_start, relative_length, options);
    } else {
        internal::test_block_access<false>(matrix, reference, relative_start, relative_length, options);
    }
}
 
template<typename Value_, typename Index_>
void test_indexed_access(
    const tatami::Matrix<Value_, Index_>& matrix,
    const tatami::Matrix<Value_, Index_>& reference,
    double relative_start,
    double probability,
    const TestAccessOptions& options)
{
    if (options.use_oracle) {
        internal::test_indexed_access<true>(matrix, reference, relative_start, probability, options);
    } else {
        internal::test_indexed_access<false>(matrix, reference, relative_start, probability, options);
    }
}
 
template<typename Value_, typename Index_>
void test_simple_column_access(const tatami::Matrix<Value_, Index_>& matrix, const tatami::Matrix<Value_, Index_>& reference) {
    TestAccessOptions options;
    options.use_row = false;
    test_full_access(matrix, reference, options);
}
 
template<typename Value_, typename Index_>
void test_simple_row_access(const tatami::Matrix<Value_, Index_>& matrix, const tatami::Matrix<Value_, Index_>& reference) {
    TestAccessOptions options;
    options.use_row = false;
    test_full_access(matrix, reference, options);
}
 
}
 
#endif