transpose.hpp

Go to the documentation of this file.

#ifndef TATAMI_TRANSPOSE_HPP
#define TATAMI_TRANSPOSE_HPP
 
#include <algorithm>
 
namespace tatami {
 
template<typename Input_, typename Output_>
void transpose(const Input_* input, size_t nrow, size_t ncol, size_t input_stride, Output_* output, size_t output_stride) {
    if ((nrow == 1 && output_stride == 1) || (ncol == 1 && input_stride == 1)) {
        std::copy_n(input, nrow * ncol, output);
        return;
    }
 
    // Using a blockwise strategy to perform the transposition,
    // in order to be more input-friendly.
    constexpr size_t block = 16;
    size_t col_start = 0;
    while (col_start < ncol) {
        size_t col_end = col_start + std::min(block, ncol - col_start);
 
        size_t row_start = 0;
        while (row_start < nrow) {
            size_t row_end = row_start + std::min(block, nrow - row_start);
 
            // We use offsets instead of directly performing pointer
            // arithmetic, to avoid creating an invalid pointer address (which
            // is UB, even if unused) after the last inner loop iteration. 
            size_t input_offset = col_start + row_start * input_stride;
            size_t output_offset = col_start * output_stride + row_start;
 
            for (size_t c = col_start; c < col_end; ++c, ++input_offset, output_offset += output_stride) {
                auto input_offset_copy = input_offset;
                auto output_offset_copy = output_offset;
 
                for (size_t r = row_start; r < row_end; ++r, input_offset_copy += input_stride, ++output_offset_copy) {
                    output[output_offset_copy] = input[input_offset_copy];
                }
            }
 
            row_start = row_end;
        }
        col_start = col_end;
    }
}
 
template<typename Input_, typename Output_>
void transpose(const Input_* input, size_t nrow, size_t ncol, Output_* output) {
    transpose(input, nrow, ncol, ncol, output, nrow);
}
 
}
 
#endif