void
Householder
( Matrix<F>& A,
Matrix<F>& phase,
Matrix<Base<F>>& signature )
{
DEBUG_CSE
const Int m = A.Height();
const Int n = A.Width();
const Int minDim = Min(m,n);
phase.Resize( minDim, 1 );
signature.Resize( minDim, 1 );
const Int bsize = Blocksize();
for( Int k=0; k<minDim; k+=bsize )
{
const Int nb = Min(bsize,minDim-k);
const Range<Int> ind1( k, k+nb ),
indB( k, END ),
ind2( k+nb, END );
auto AB1 = A( indB, ind1 );
auto AB2 = A( indB, ind2 );
auto phase1 = phase( ind1, ALL );
auto sig1 = signature( ind1, ALL );
PanelHouseholder( AB1, phase1, sig1 );
ApplyQ( LEFT, ADJOINT, AB1, phase1, sig1, AB2 );
}
}
inline void
Householder( Matrix<F>& A, Matrix<F>& t )
{
#ifndef RELEASE
CallStackEntry entry("rq::Householder");
#endif
t.ResizeTo( Min(A.Height(),A.Width()), 1 );
// Matrix views
Matrix<F>
ATL, ATR, A00, A01, A02, ATopPan,
ABL, ABR, A10, A11, A12, ABottomPan,
A20, A21, A22;
Matrix<F>
tT, t0,
tB, t1,
t2;
PartitionUpOffsetDiagonal
( A.Width()-A.Height(),
A, ATL, ATR,
ABL, ABR, 0 );
PartitionUp
( t, tT,
tB, 0 );
while( ABR.Height() < A.Height() && ABR.Width() < A.Width() )
{
RepartitionUpDiagonal
( ATL, /**/ ATR, A00, A01, /**/ A02,
/**/ A10, A11, /**/ A12,
/*************/ /******************/
ABL, /**/ ABR, A20, A21, /**/ A22 );
RepartitionUp
( tT, t0,
t1,
/**/ /**/
tB, t2 );
View1x2( ATopPan, A00, A01 );
View1x2( ABottomPan, A10, A11 );
//--------------------------------------------------------------------//
PanelHouseholder( ABottomPan, t1 );
ApplyQ( RIGHT, ADJOINT, ABottomPan, t1, ATopPan );
//--------------------------------------------------------------------//
SlidePartitionUp
( tT, t0,
/**/ /**/
t1,
tB, t2 );
SlidePartitionUpDiagonal
( ATL, /**/ ATR, A00, /**/ A01, A02,
/*************/ /******************/
/**/ A10, /**/ A11, A12,
ABL, /**/ ABR, A20, /**/ A21, A22 );
}
}
void FormQ
( UpperOrLower uplo,
const AbstractDistMatrix<F>& A,
const AbstractDistMatrix<F>& householderScalars,
AbstractDistMatrix<F>& Q )
{
DEBUG_CSE
// TODO: Make this smarter
const Int n = A.Height();
Identity( Q, n, n );
ApplyQ( LEFT, uplo, NORMAL, A, householderScalars, Q );
}
inline void
ApplyQ
( LeftOrRight side, Orientation orientation,
const DistMatrix<F>& A, const DistMatrix<F,STAR,STAR>& t, DistMatrix<F>& B )
{
#ifndef RELEASE
CallStackEntry cse("rq::ApplyQ");
#endif
const Int offset = A.Width()-A.Height();
DistMatrix<F,MD,STAR> tDiag(A.Grid());
tDiag.AlignWithDiagonal( A, offset );
tDiag = t;
ApplyQ( side, orientation, A, tDiag, B );
}
inline void
ApplyQ
( LeftOrRight side, UpperOrLower uplo, Orientation orientation,
const DistMatrix<F>& A, const DistMatrix<F,STAR,STAR>& t, DistMatrix<F>& B )
{
#ifndef RELEASE
CallStackEntry cse("hermitian_tridiag::ApplyQ");
#endif
const Int offset = ( uplo==UPPER ? 1 : -1 );
DistMatrix<F,MD,STAR> tDiag(A.Grid());
tDiag.AlignWithDiagonal( A, offset );
tDiag = t;
ApplyQ( side, uplo, orientation, A, tDiag, B );
}
void
Householder
( AbstractDistMatrix<F>& APre,
AbstractDistMatrix<F>& householderScalarsPre,
AbstractDistMatrix<Base<F>>& signaturePre )
{
DEBUG_CSE
DEBUG_ONLY(AssertSameGrids( APre, householderScalarsPre, signaturePre ))
const Int m = APre.Height();
const Int n = APre.Width();
const Int minDim = Min(m,n);
const Int iOff = m-minDim;
const Int jOff = n-minDim;
DistMatrixReadWriteProxy<F,F,MC,MR> AProx( APre );
DistMatrixWriteProxy<F,F,MD,STAR>
householderScalarsProx( householderScalarsPre );
DistMatrixWriteProxy<Base<F>,Base<F>,MD,STAR> signatureProx( signaturePre );
auto& A = AProx.Get();
auto& householderScalars = householderScalarsProx.Get();
auto& signature = signatureProx.Get();
householderScalars.Resize( minDim, 1 );
signature.Resize( minDim, 1 );
const Int bsize = Blocksize();
const Int kLast = LastOffset( minDim, bsize );
for( Int k=kLast; k>=0; k-=bsize )
{
const Int nb = Min(bsize,minDim-k);
const Int ki = k + iOff;
const Int kj = k + jOff;
const Range<Int> ind0Vert( 0, ki ),
ind1( k, k+nb ),
ind1Vert( ki, ki+nb ),
indL( 0, kj+nb );
auto A0L = A( ind0Vert, indL );
auto A1L = A( ind1Vert, indL );
auto householderScalars1 = householderScalars( ind1, ALL );
auto sig1 = signature( ind1, ALL );
PanelHouseholder( A1L, householderScalars1, sig1 );
ApplyQ( RIGHT, ADJOINT, A1L, householderScalars1, sig1, A0L );
}
}
void
Householder
( ElementalMatrix<F>& APre,
ElementalMatrix<F>& phasePre,
ElementalMatrix<Base<F>>& signaturePre )
{
DEBUG_CSE
DEBUG_ONLY(AssertSameGrids( APre, phasePre, signaturePre ))
const Int m = APre.Height();
const Int n = APre.Width();
const Int minDim = Min(m,n);
DistMatrixReadWriteProxy<F,F,MC,MR> AProx( APre );
DistMatrixWriteProxy<F,F,MD,STAR> phaseProx( phasePre );
DistMatrixWriteProxy<Base<F>,Base<F>,MD,STAR> signatureProx( signaturePre );
auto& A = AProx.Get();
auto& phase = phaseProx.Get();
auto& signature = signatureProx.Get();
phase.Resize( minDim, 1 );
signature.Resize( minDim, 1 );
const Int bsize = Blocksize();
for( Int k=0; k<minDim; k+=bsize )
{
const Int nb = Min(bsize,minDim-k);
const Range<Int> ind1( k, k+nb ),
indB( k, END ),
ind2( k+nb, END );
auto AB1 = A( indB, ind1 );
auto AB2 = A( indB, ind2 );
auto phase1 = phase( ind1, ALL );
auto sig1 = signature( ind1, ALL );
PanelHouseholder( AB1, phase1, sig1 );
ApplyQ( LEFT, ADJOINT, AB1, phase1, sig1, AB2 );
}
}
void
Householder
( Matrix<F>& A,
Matrix<F>& householderScalars,
Matrix<Base<F>>& signature )
{
DEBUG_CSE
const Int m = A.Height();
const Int n = A.Width();
const Int minDim = Min(m,n);
const Int iOff = m-minDim;
const Int jOff = n-minDim;
householderScalars.Resize( minDim, 1 );
signature.Resize( minDim, 1 );
const Int bsize = Blocksize();
const Int kLast = LastOffset( minDim, bsize );
for( Int k=kLast; k>=0; k-=bsize )
{
const Int nb = Min(bsize,minDim-k);
const Int ki = k + iOff;
const Int kj = k + jOff;
const Range<Int> ind0Vert( 0, ki ),
ind1( k, k+nb ),
ind1Vert( ki, ki+nb ),
indL( 0, kj+nb );
auto A0L = A( ind0Vert, indL );
auto A1L = A( ind1Vert, indL );
auto householderScalars1 = householderScalars( ind1, ALL );
auto sig1 = signature( ind1, ALL );
PanelHouseholder( A1L, householderScalars1, sig1 );
ApplyQ( RIGHT, ADJOINT, A1L, householderScalars1, sig1, A0L );
}
}
inline void
Householder( Matrix<F>& A, Matrix<F>& t )
{
#ifndef RELEASE
CallStackEntry entry("qr::Householder");
#endif
t.ResizeTo( Min(A.Height(),A.Width()), 1 );
// Matrix views
Matrix<F>
ATL, ATR, A00, A01, A02, ALeftPan, ARightPan,
ABL, ABR, A10, A11, A12,
A20, A21, A22;
Matrix<F>
tT, t0,
tB, t1,
t2;
PartitionDownDiagonal
( A, ATL, ATR,
ABL, ABR, 0 );
PartitionDown
( t, tT,
tB, 0 );
while( ATL.Height() < A.Height() && ATL.Width() < A.Width() )
{
RepartitionDownDiagonal
( ATL, /**/ ATR, A00, /**/ A01, A02,
/*************/ /******************/
/**/ A10, /**/ A11, A12,
ABL, /**/ ABR, A20, /**/ A21, A22 );
RepartitionDown
( tT, t0,
/**/ /**/
t1,
tB, t2 );
View2x1
( ALeftPan, A11,
A21 );
View2x1
( ARightPan, A12,
A22 );
//--------------------------------------------------------------------//
PanelHouseholder( ALeftPan, t1 );
ApplyQ( LEFT, ADJOINT, ALeftPan, t1, ARightPan );
//--------------------------------------------------------------------//
SlidePartitionDown
( tT, t0,
t1,
/**/ /**/
tB, t2 );
SlidePartitionDownDiagonal
( ATL, /**/ ATR, A00, A01, /**/ A02,
/**/ A10, A11, /**/ A12,
/*************/ /******************/
ABL, /**/ ABR, A20, A21, /**/ A22 );
}
}
inline void
Householder( DistMatrix<F>& A, DistMatrix<F,MD,STAR>& t )
{
#ifndef RELEASE
CallStackEntry entry("qr::Householder");
if( A.Grid() != t.Grid() )
LogicError("{A,s} must be distributed over the same grid");
#endif
const Grid& g = A.Grid();
if( t.Viewing() )
{
if( !t.AlignedWithDiagonal( A ) )
LogicError("t was not aligned with A");
}
else
{
t.AlignWithDiagonal( A );
}
t.ResizeTo( Min(A.Height(),A.Width()), 1 );
// Matrix views
DistMatrix<F>
ATL(g), ATR(g), A00(g), A01(g), A02(g), ALeftPan(g), ARightPan(g),
ABL(g), ABR(g), A10(g), A11(g), A12(g),
A20(g), A21(g), A22(g);
DistMatrix<F,MD,STAR>
tT(g), t0(g),
tB(g), t1(g),
t2(g);
PartitionDownDiagonal
( A, ATL, ATR,
ABL, ABR, 0 );
PartitionDown
( t, tT,
tB, 0 );
while( ATL.Height() < A.Height() && ATL.Width() < A.Width() )
{
RepartitionDownDiagonal
( ATL, /**/ ATR, A00, /**/ A01, A02,
/*************/ /******************/
/**/ A10, /**/ A11, A12,
ABL, /**/ ABR, A20, /**/ A21, A22 );
RepartitionDown
( tT, t0,
/**/ /**/
t1,
tB, t2 );
View2x1
( ALeftPan, A11,
A21 );
View2x1
( ARightPan, A12,
A22 );
//--------------------------------------------------------------------//
PanelHouseholder( ALeftPan, t1 );
ApplyQ( LEFT, ADJOINT, ALeftPan, t1, ARightPan );
//--------------------------------------------------------------------//
SlidePartitionDown
( tT, t0,
t1,
/**/ /**/
tB, t2 );
SlidePartitionDownDiagonal
( ATL, /**/ ATR, A00, A01, /**/ A02,
/**/ A10, A11, /**/ A12,
/*************/ /******************/
ABL, /**/ ABR, A20, A21, /**/ A22 );
}
}
