DmrgConglutinations.h

Go to the documentation of this file.

#ifndef STRAWBERRY_DMRGCONGLUTINATIONS
#define STRAWBERRY_DMRGCONGLUTINATIONS
 
template<typename MatrixType1, typename MatrixType2>
void addBottomRight (const MatrixType1 &Min, MatrixType2 &Mout)
{
    int r1 = Mout.rows();
    int c1 = Mout.cols();
    int r2 = Min.rows();
    int c2 = Min.cols();
    
    Mout.conservativeResize(r1+r2, c1+c2);
    
    Mout.bottomLeftCorner(r2,c1).setZero();
    Mout.topRightCorner(r1,c2).setZero();
    Mout.bottomRightCorner(r2,c2) = Min;
}
 
template<typename MatrixType1, typename MatrixType2>
void addRight (const MatrixType1 &Min, MatrixType2 &Mout)
{
    int r1 = Mout.rows();
    int c1 = Mout.cols();
    int c2 = Min.cols();
    
    if (r1 == 0 and c2 != 0)
    {
        Mout = Min;
    }
    else
    {
        if (c2 != 0)
        {
            assert(Min.rows() == Mout.rows());
            Mout.conservativeResize(r1, c1+c2);
            Mout.rightCols(c2) = Min;
        }
    }
}
 
template<typename MatrixType1, typename MatrixType2>
void addRight_makeSquare (const MatrixType1 &Min, MatrixType2 &Mout)
{
    int r  = Mout.rows();
    int c1 = Mout.cols();
    int c2 = Min.cols();
    
    if (r == 0 and c2 != 0)
    {
        Mout = Min;
    }
    else
    {
        if (c2 != 0)
        {
            assert(Min.rows() == Mout.rows());
            Mout.conservativeResize(c1+c2, c1+c2);
            Mout.block(0,c1, r,c2) = Min;
            Mout.bottomRows(c1+c2-r).setZero();
        }
    }
}
 
template<typename MatrixType1, typename MatrixType2>
void addBottom (const MatrixType1 &Min, MatrixType2 &Mout)
{
    int r1 = Mout.rows();
    int c1 = Mout.cols();
    int r2 = Min.rows();
    
    if (r1 == 0 and r2 != 0)
    {
        Mout = Min;
    }
    else
    {
        if (r2 != 0)
        {
            assert(Min.cols() == Mout.cols());
            Mout.conservativeResize(r1+r2, c1);
            Mout.bottomRows(r2) = Min;
        }
    }
}
 
template<typename MatrixType1, typename MatrixType2>
void addBottom_makeSquare (const MatrixType1 &Min, MatrixType2 &Mout)
{
    int r1 = Mout.rows();
    int c = Mout.cols();
    int r2 = Min.rows();
    
    if (r1 == 0 and r2 != 0)
    {
        Mout = Min;
    }
    else
    {
        if (r2 != 0)
        {
            assert(Min.cols() == Mout.cols());
            Mout.conservativeResize(r1+r2, r1+r2);
            Mout.block(r1,0, r2,c) = Min;
            Mout.rightCols(r1+r2-c).setZero();
        }
    }
}
 
enum BLOCK_POSITION {SAME_PLACE, BOTTOM_RIGHT, RIGHT, BOTTOM};
 
template<typename MatrixType1, typename MatrixType2>
void addPos (const MatrixType1 &Min, MatrixType2 &Mout, BLOCK_POSITION POS)
{
    assert(POS != SAME_PLACE);
    if      (POS == BOTTOM_RIGHT) {addBottomRight(Min,Mout);}
    else if (POS == RIGHT)        {addRight(Min,Mout);}
    else if (POS == BOTTOM)       {addBottom(Min,Mout);}
}
 
template<typename MatrixType>
void remove_col (size_t i, MatrixType &M)
{
    size_t Mrows = M.rows();
    size_t Mcols = M.cols()-1;
    
    if (i<Mcols)
    {
        M.block(0,i,Mrows,Mcols-i) = M.block(0,i+1,Mrows,Mcols-i);
    }
    M.conservativeResize(Mrows,Mcols);
}
 
template<typename MatrixType>
void remove_row (size_t i, MatrixType &M)
{
    size_t Mrows = M.rows()-1;
    size_t Mcols = M.cols();
    
    if (i<Mcols)
    {
        M.block(0,i,Mrows-i,Mcols) = M.block(i+1,0,Mrows-i,Mcols);
    }
    M.conservativeResize(Mrows,Mcols);
}
 
#endif