rotgen/include/rotgen/extract.hpp

//==================================================================================================
/*
  ROTGEN - Runtime Overlay for Eigen
  Copyright : CODE RECKONS
  SPDX-License-Identifier: BSL-1.0
*/
//==================================================================================================
#pragma once

namespace rotgen
{
  template< typename S, int R   , int C
          , int Opts  , int MaxR, int MaxC
          >
  auto extract(matrix<S,R,C,Opts,MaxR,MaxC>& m, int i0, int j0,int ni, int nj)
  {
    using base = matrix<S,R,C,Opts,MaxR,MaxC>;
    return block<base>(m, i0,j0,ni,nj);
  }

  template< int NI, int NJ
          , typename S, int R   , int C
          , int Opts  , int MaxR, int MaxC
          >
  auto extract(matrix<S,R,C,Opts,MaxR,MaxC>& m, int i0, int j0)
  {
    using base = matrix<S,R,C,Opts,MaxR,MaxC>;
    return block<base,NI,NJ>(m,i0,j0);
  }

  template< typename S, int R   , int C
      , int Opts  , int MaxR, int MaxC
  >
  auto topLeftCorner(matrix<S,R,C,Opts,MaxR,MaxC>& m, int ni, int nj)
  {
    using base = matrix<S,R,C,Opts,MaxR,MaxC>;
    return block<base>(m,0,0,ni,nj);
  }

  template< typename S, int R   , int C
      , int Opts  , int MaxR, int MaxC
  >
  auto topRightCorner(matrix<S,R,C,Opts,MaxR,MaxC>& m, int ni, int nj)
  {
    using base = matrix<S,R,C,Opts,MaxR,MaxC>;
    return block<base>(m,0,m.cols()-nj,ni,nj);
  }

  template< typename S, int R   , int C
      , int Opts  , int MaxR, int MaxC
  >
  auto bottomLeftCorner(matrix<S,R,C,Opts,MaxR,MaxC>& m, int ni, int nj)
  {
    using base = matrix<S,R,C,Opts,MaxR,MaxC>;
    return block<base>(m,m.rows()-ni,0,ni,nj);
  }

  template< typename S, int R   , int C
      , int Opts  , int MaxR, int MaxC
  >
  auto bottomRightCorner(matrix<S,R,C,Opts,MaxR,MaxC>& m, int ni, int nj)
  {
    using base = matrix<S,R,C,Opts,MaxR,MaxC>;
    return block<base>(m,m.rows()-ni,m.cols()-nj,ni,nj);
  }

  template< typename S, int R   , int C
      , int Opts  , int MaxR, int MaxC
  >
  auto topRows(matrix<S,R,C,Opts,MaxR,MaxC>& m, int ni)
  {
    using base = matrix<S,R,C,Opts,MaxR,MaxC>;
    return block<base>(m,0,0,ni,m.cols());
  }

  template< typename S, int R   , int C,
      int Opts  , int MaxR, int MaxC
  >
  auto middleRows(matrix<S,R,C,Opts,MaxR,MaxC>& m, int i0, int ni)
  {
    using base = matrix<S,R,C,Opts,MaxR,MaxC>;
    return block<base>(m,i0,0,ni,m.cols());
  }

  template< typename S, int R   , int C
      , int Opts  , int MaxR, int MaxC
  >
  auto bottomRows(matrix<S,R,C,Opts,MaxR,MaxC>& m, int ni)
  {
    using base = matrix<S,R,C,Opts,MaxR,MaxC>;
    return block<base>(m,m.rows()-ni,0,ni,m.cols());
  }

  template< typename S, int R   , int C
      , int Opts  , int MaxR, int MaxC
  >
  auto leftCols(matrix<S,R,C,Opts,MaxR,MaxC>& m, int nj)
  {
    using base = matrix<S,R,C,Opts,MaxR,MaxC>;
    return block<base>(m,0,0,m.rows(),nj);
  }

  template< typename S, int R   , int C,
      int Opts  , int MaxR, int MaxC
  >
  auto middleCols(matrix<S,R,C,Opts,MaxR,MaxC>& m, int j0, int nj)
  {
    using base = matrix<S,R,C,Opts,MaxR,MaxC>;
    return block<base>(m,0,j0,m.rows(),nj);
  }

  template< typename S, int R   , int C
      , int Opts  , int MaxR, int MaxC
  >
  auto rightCols(matrix<S,R,C,Opts,MaxR,MaxC>& m, int nj)
  {
    using base = matrix<S,R,C,Opts,MaxR,MaxC>;
    return block<base>(m,0,m.cols()-nj,m.rows(),nj);
  }

  template< typename S, int R, int C
      , int Opts  , int MaxR, int MaxC
  >
  auto row(matrix<S,R,C,Opts,MaxR,MaxC>& m, int i0)
  {
    using base = matrix<S,R,C,Opts,MaxR,MaxC>;
    return block<base,1, -1, false, 1>(m,i0,0, 1, m.cols());
  }

  template< typename S, int R, int C
      , int Opts  , int MaxR, int MaxC
  >
  auto col(matrix<S,R,C,Opts,MaxR,MaxC>& m, int j0)
  {
    using base = matrix<S,R,C,Opts,MaxR,MaxC>;
    return block<base,-1,1, false, 0>(m,0,j0, m.rows(), 1);
  }

  template< int NI, typename S, int R, int C,
            int Opts, int MaxR, int MaxC
  >
  auto topRows(matrix<S,R,C,Opts,MaxR,MaxC>& m)
  {
    using base = matrix<S,R,C,Opts,MaxR,MaxC>;
    return block<base,NI,-1>(m,0,0, NI, m.cols());
  }

  template< int NI, typename S, int R, int C,
            int Opts, int MaxR, int MaxC
  >
  auto bottomRows(matrix<S,R,C,Opts,MaxR,MaxC>& m)
  {
    using base = matrix<S,R,C,Opts,MaxR,MaxC>;
    return block<base,NI,-1>(m,m.rows()-NI,0, NI, m.cols());
  }

  template< int NI, typename S, int R, int C,
            int Opts  , int MaxR, int MaxC
  >
  auto middleRows(matrix<S,R,C,Opts,MaxR,MaxC>& m, int i0)
  {
    using base = matrix<S,R,C,Opts,MaxR,MaxC>;
    return block<base,NI,-1>(m,i0,0, NI, m.cols());
  }

  template< int NJ, typename S, int R, int C,
      int Opts, int MaxR, int MaxC
  >
  auto leftCols(matrix<S,R,C,Opts,MaxR,MaxC>& m)
  {
    using base = matrix<S,R,C,Opts,MaxR,MaxC>;
    return block<base,-1,NJ>(m,0,0, m.rows(), NJ);
  }

  template< int NJ, typename S, int R, int C,
      int Opts, int MaxR, int MaxC
  >
  auto rightCols(matrix<S,R,C,Opts,MaxR,MaxC>& m)
  {
    using base = matrix<S,R,C,Opts,MaxR,MaxC>;
    return block<base,-1,NJ>(m,0,m.cols()-NJ, m.rows(), NJ);
  }

  template< int NJ, typename S, int R, int C,
      int Opts  , int MaxR, int MaxC
  >
  auto middleCols(matrix<S,R,C,Opts,MaxR,MaxC>& m, int j0)
  {
    using base = matrix<S,R,C,Opts,MaxR,MaxC>;
    return block<base,-1,NJ>(m,0,j0, m.rows(), NJ);
  }

  template< int NI, int NJ
      , typename S, int R   , int C
      , int Opts  , int MaxR, int MaxC
  >
  auto topLeftCorner(matrix<S,R,C,Opts,MaxR,MaxC>& m)
  {
    using base = matrix<S,R,C,Opts,MaxR,MaxC>;
    return block<base,NI,NJ>(m,0,0);
  }

  template< int NI, int NJ
      , typename S, int R   , int C
      , int Opts  , int MaxR, int MaxC
  >
  auto topRightCorner(matrix<S,R,C,Opts,MaxR,MaxC>& m)
  {
    using base = matrix<S,R,C,Opts,MaxR,MaxC>;
    return block<base,NI,NJ>(m,0,m.cols()-NJ);
  }

  template< int NI, int NJ
      , typename S, int R   , int C
      , int Opts  , int MaxR, int MaxC
  >
  auto bottomLeftCorner(matrix<S,R,C,Opts,MaxR,MaxC>& m)
  {
    using base = matrix<S,R,C,Opts,MaxR,MaxC>;
    return block<base,NI,NJ>(m,m.rows()-NI,0);
  }

  template< int NI, int NJ
      , typename S, int R   , int C
      , int Opts  , int MaxR, int MaxC
  >
  auto bottomRightCorner(matrix<S,R,C,Opts,MaxR,MaxC>& m)
  {
    using base = matrix<S,R,C,Opts,MaxR,MaxC>;
    return block<base,NI,NJ>(m,m.rows()-NI,m.cols()-NJ);
  }
}