matrix_reorder.hpp

Go to the documentation of this file.

#pragma once
 
#include "permutations.hpp"
#include "matroid_transposed.hpp"
#include "matrix.hpp"
 
namespace tu
{
 
  template <typename MatrixType>
  inline void matrix_apply_row_permutation(MatrixType& matrix, const permutation& perm)
  {
    permutation p = perm;
    for (size_t row = 0; row < matrix.size1(); ++row)
    {
      size_t target_row = p(row);
      matrix_permute1(matrix, row, target_row);
      p.rswap(row, target_row);
    }
  }
 
  template <typename MatrixType>
  inline void matrix_apply_column_permutation(MatrixType& matrix, const permutation& perm)
  {
    matroid_transposed <MatrixType> transposed(matrix);
    matrix_apply_row_permutation(transposed, perm);
  }
 
  template <typename MatrixType, typename Less>
  struct matrix_reorder_row_less
  {
    matrix_reorder_row_less(const MatrixType& matrix, size_t column_first, size_t column_beyond, Less less) :
      matrix_(matrix), column_first_(column_first), column_beyond_(column_beyond), less_(less)
    {
 
    }
 
    bool operator()(size_t a, size_t b)
    {
      for (size_t column = column_first_; column < column_beyond_; ++column)
      {
        typename MatrixType::value_type va = matrix_(a, column);
        typename MatrixType::value_type vb = matrix_(b, column);
 
        if (less_(va, vb))
          return true;
        else if (less_(vb, va))
          return false;
      }
 
      return false;
    }
 
    const MatrixType& matrix_;
    size_t column_first_;
    size_t column_beyond_;
    Less less_;
  };
 
  template <typename MatrixType, typename ElementLess>
  inline void matrix_reorder_rows(const MatrixType& matrix, size_t row_first, size_t row_beyond, size_t column_first, size_t column_beyond,
      ElementLess element_less, permutation& result_permutation)
  {
    result_permutation.reset(matrix.size1());
    matrix_reorder_row_less <MatrixType, ElementLess> less(matrix, column_first, column_beyond, element_less);
    sort(result_permutation, row_first, row_beyond, less);
  }
 
  template <typename MatrixType, typename ElementLess>
  inline void matrix_reorder_columns(const MatrixType& matrix, size_t row_first, size_t row_beyond, size_t column_first, size_t column_beyond,
      ElementLess element_less, permutation& result_permutation)
  {
    const matrix_transposed <MatrixType> transposed(matrix);
    matrix_reorder_rows(transposed, column_first, column_beyond, row_first, row_beyond, element_less, result_permutation);
  }
 
  template <typename MatrixType, typename ElementLess>
  inline void matrix_reorder_rows(MatrixType& matrix, size_t row_first, size_t row_beyond, size_t column_first, size_t column_beyond,
      ElementLess element_less)
  {
    permutation perm;
    matrix_reorder_rows(matrix, row_first, row_beyond, column_first, column_beyond, element_less, perm);
    matrix_apply_row_permutation(matrix, perm);
  }
 
  template <typename MatrixType, typename ElementLess>
  inline void matrix_reorder_columns(MatrixType& matrix, size_t row_first, size_t row_beyond, size_t column_first, size_t column_beyond,
      ElementLess element_less)
  {
    matrix_transposed <MatrixType> transposed(matrix);
    matrix_reorder_rows(matrix, column_first, column_beyond, row_first, row_beyond, element_less);
  }
 
} /* namespace tu */