inline void
TwoSidedTrmmUVar1
( UnitOrNonUnit diag, DistMatrix<F>& A, const DistMatrix<F>& U )
{
#ifndef RELEASE
PushCallStack("internal::TwoSidedTrmmUVar1");
if( A.Height() != A.Width() )
throw std::logic_error("A must be square");
if( U.Height() != U.Width() )
throw std::logic_error("Triangular matrices must be square");
if( A.Height() != U.Height() )
throw std::logic_error("A and U must be the same size");
#endif
const Grid& g = A.Grid();
// Matrix views
DistMatrix<F>
ATL(g), ATR(g), A00(g), A01(g), A02(g),
ABL(g), ABR(g), A10(g), A11(g), A12(g),
A20(g), A21(g), A22(g);
DistMatrix<F>
UTL(g), UTR(g), U00(g), U01(g), U02(g),
UBL(g), UBR(g), U10(g), U11(g), U12(g),
U20(g), U21(g), U22(g);
// Temporary distributions
DistMatrix<F,STAR,STAR> A11_STAR_STAR(g);
DistMatrix<F,STAR,VR > A12_STAR_VR(g);
DistMatrix<F,STAR,STAR> U11_STAR_STAR(g);
DistMatrix<F,STAR,MC > U12_STAR_MC(g);
DistMatrix<F,STAR,VR > U12_STAR_VR(g);
DistMatrix<F,MR, STAR> U12Adj_MR_STAR(g);
DistMatrix<F,VC, STAR> U12Adj_VC_STAR(g);
DistMatrix<F,STAR,STAR> X11_STAR_STAR(g);
DistMatrix<F,MR, MC > Z12Adj_MR_MC(g);
DistMatrix<F,MC, STAR> Z12Adj_MC_STAR(g);
DistMatrix<F,MR, STAR> Z12Adj_MR_STAR(g);
DistMatrix<F> Z12Adj(g);
DistMatrix<F> Y12(g);
PartitionDownDiagonal
( A, ATL, ATR,
ABL, ABR, 0 );
LockedPartitionDownDiagonal
( U, UTL, UTR,
UBL, UBR, 0 );
while( ATL.Height() < A.Height() )
{
RepartitionDownDiagonal
( ATL, /**/ ATR, A00, /**/ A01, A02,
/*************/ /******************/
/**/ A10, /**/ A11, A12,
ABL, /**/ ABR, A20, /**/ A21, A22 );
LockedRepartitionDownDiagonal
( UTL, /**/ UTR, U00, /**/ U01, U02,
/*************/ /******************/
/**/ U10, /**/ U11, U12,
UBL, /**/ UBR, U20, /**/ U21, U22 );
A12_STAR_VR.AlignWith( A12 );
U12_STAR_MC.AlignWith( A22 );
U12_STAR_VR.AlignWith( A12 );
U12Adj_MR_STAR.AlignWith( A22 );
U12Adj_VC_STAR.AlignWith( A22 );
X11_STAR_STAR.ResizeTo( A11.Height(), A11.Width() );
Y12.AlignWith( A12 );
Z12Adj.AlignWith( A12 );
Z12Adj_MR_MC.AlignWith( A12 );
Z12Adj_MC_STAR.AlignWith( A22 );
Z12Adj_MR_STAR.AlignWith( A22 );
//--------------------------------------------------------------------//
// Y12 := U12 A22
U12Adj_MR_STAR.AdjointFrom( U12 );
U12Adj_VC_STAR = U12Adj_MR_STAR;
U12_STAR_MC.AdjointFrom( U12Adj_VC_STAR );
Z12Adj_MC_STAR.ResizeTo( A12.Width(), A12.Height() );
Z12Adj_MR_STAR.ResizeTo( A12.Width(), A12.Height() );
Zero( Z12Adj_MC_STAR );
Zero( Z12Adj_MR_STAR );
LocalSymmetricAccumulateRU
( ADJOINT,
F(1), A22, U12_STAR_MC, U12Adj_MR_STAR,
Z12Adj_MC_STAR, Z12Adj_MR_STAR );
Z12Adj.SumScatterFrom( Z12Adj_MC_STAR );
Z12Adj_MR_MC = Z12Adj;
Z12Adj_MR_MC.SumScatterUpdate( F(1), Z12Adj_MR_STAR );
Y12.ResizeTo( A12.Height(), A12.Width() );
Adjoint( Z12Adj_MR_MC.LockedLocalMatrix(), Y12.LocalMatrix() );
// A12 := U11 A12
A12_STAR_VR = A12;
U11_STAR_STAR = U11;
LocalTrmm
( LEFT, UPPER, NORMAL, diag, F(1), U11_STAR_STAR, A12_STAR_VR );
A12 = A12_STAR_VR;
// A12 := A12 + 1/2 Y12
Axpy( F(1)/F(2), Y12, A12 );
// A11 := U11 A11 U11'
A11_STAR_STAR = A11;
LocalTwoSidedTrmm( UPPER, diag, A11_STAR_STAR, U11_STAR_STAR );
A11 = A11_STAR_STAR;
// A11 := A11 + (U12 A12' + A12 U12')
A12_STAR_VR = A12;
U12_STAR_VR = U12;
Her2k
( UPPER, NORMAL,
F(1), A12_STAR_VR.LocalMatrix(), U12_STAR_VR.LocalMatrix(),
F(0), X11_STAR_STAR.LocalMatrix() );
A11.SumScatterUpdate( F(1), X11_STAR_STAR );
// A12 := A12 + 1/2 Y12
Axpy( F(1)/F(2), Y12, A12 );
// A12 := A12 U22'
Trmm( RIGHT, UPPER, ADJOINT, diag, F(1), U22, A12 );
//--------------------------------------------------------------------//
A12_STAR_VR.FreeAlignments();
U12_STAR_MC.FreeAlignments();
U12_STAR_VR.FreeAlignments();
U12Adj_MR_STAR.FreeAlignments();
U12Adj_VC_STAR.FreeAlignments();
Y12.FreeAlignments();
Z12Adj.FreeAlignments();
Z12Adj_MR_MC.FreeAlignments();
Z12Adj_MC_STAR.FreeAlignments();
Z12Adj_MR_STAR.FreeAlignments();
SlidePartitionDownDiagonal
( ATL, /**/ ATR, A00, A01, /**/ A02,
/**/ A10, A11, /**/ A12,
/*************/ /******************/
ABL, /**/ ABR, A20, A21, /**/ A22 );
SlideLockedPartitionDownDiagonal
( UTL, /**/ UTR, U00, U01, /**/ U02,
/**/ U10, U11, /**/ U12,
/*************/ /******************/
UBL, /**/ UBR, U20, U21, /**/ U22 );
}
#ifndef RELEASE
PopCallStack();
#endif
}
inline void
HemmRUA
( T alpha, const DistMatrix<T>& A,
const DistMatrix<T>& B,
T beta, DistMatrix<T>& C )
{
#ifndef RELEASE
PushCallStack("internal::HemmRUA");
if( A.Grid() != B.Grid() || B.Grid() != C.Grid() )
throw std::logic_error
("{A,B,C} must be distributed over the same grid");
#endif
const Grid& g = A.Grid();
DistMatrix<T>
BT(g), B0(g),
BB(g), B1(g),
B2(g);
DistMatrix<T>
CT(g), C0(g),
CB(g), C1(g),
C2(g);
DistMatrix<T,MR, STAR> B1Adj_MR_STAR(g);
DistMatrix<T,VC, STAR> B1Adj_VC_STAR(g);
DistMatrix<T,STAR,MC > B1_STAR_MC(g);
DistMatrix<T,MC, STAR> Z1Adj_MC_STAR(g);
DistMatrix<T,MR, STAR> Z1Adj_MR_STAR(g);
DistMatrix<T,MR, MC > Z1Adj_MR_MC(g);
DistMatrix<T> Z1Adj(g);
B1Adj_MR_STAR.AlignWith( A );
B1Adj_VC_STAR.AlignWith( A );
B1_STAR_MC.AlignWith( A );
Z1Adj_MC_STAR.AlignWith( A );
Z1Adj_MR_STAR.AlignWith( A );
Matrix<T> Z1Local;
Scale( beta, C );
LockedPartitionDown
( B, BT,
BB, 0 );
PartitionDown
( C, CT,
CB, 0 );
while( CT.Height() < C.Height() )
{
LockedRepartitionDown
( BT, B0,
/**/ /**/
B1,
BB, B2 );
RepartitionDown
( CT, C0,
/**/ /**/
C1,
CB, C2 );
Z1Adj_MR_MC.AlignWith( C1 );
Zeros( C1.Width(), C1.Height(), Z1Adj_MC_STAR );
Zeros( C1.Width(), C1.Height(), Z1Adj_MR_STAR );
//--------------------------------------------------------------------//
B1Adj_MR_STAR.AdjointFrom( B1 );
B1Adj_VC_STAR = B1Adj_MR_STAR;
B1_STAR_MC.AdjointFrom( B1Adj_VC_STAR );
LocalSymmetricAccumulateRU
( ADJOINT, alpha, A, B1_STAR_MC, B1Adj_MR_STAR,
Z1Adj_MC_STAR, Z1Adj_MR_STAR );
Z1Adj.SumScatterFrom( Z1Adj_MC_STAR );
Z1Adj_MR_MC = Z1Adj;
Z1Adj_MR_MC.SumScatterUpdate( T(1), Z1Adj_MR_STAR );
Adjoint( Z1Adj_MR_MC.LockedLocalMatrix(), Z1Local );
Axpy( T(1), Z1Local, C1.LocalMatrix() );
//--------------------------------------------------------------------//
Z1Adj_MR_MC.FreeAlignments();
SlideLockedPartitionDown
( BT, B0,
B1,
/**/ /**/
BB, B2 );
SlidePartitionDown
( CT, C0,
C1,
/**/ /**/
CB, C2 );
}
#ifndef RELEASE
PopCallStack();
#endif
}
inline void
SymmRUA
( T alpha, const DistMatrix<T>& A, const DistMatrix<T>& B,
T beta, DistMatrix<T>& C,
bool conjugate=false )
{
#ifndef RELEASE
PushCallStack("internal::SymmRUA");
if( A.Grid() != B.Grid() || B.Grid() != C.Grid() )
throw std::logic_error
("{A,B,C} must be distributed over the same grid");
#endif
const Grid& g = A.Grid();
const Orientation orientation = ( conjugate ? ADJOINT : TRANSPOSE );
DistMatrix<T>
BT(g), B0(g),
BB(g), B1(g),
B2(g);
DistMatrix<T>
CT(g), C0(g),
CB(g), C1(g),
C2(g);
DistMatrix<T,MR, STAR> B1Trans_MR_STAR(g);
DistMatrix<T,VC, STAR> B1Trans_VC_STAR(g);
DistMatrix<T,STAR,MC > B1_STAR_MC(g);
DistMatrix<T,MC, STAR> Z1Trans_MC_STAR(g);
DistMatrix<T,MR, STAR> Z1Trans_MR_STAR(g);
DistMatrix<T,MC, MR > Z1Trans(g);
DistMatrix<T,MR, MC > Z1Trans_MR_MC(g);
B1Trans_MR_STAR.AlignWith( A );
B1Trans_VC_STAR.AlignWith( A );
B1_STAR_MC.AlignWith( A );
Z1Trans_MC_STAR.AlignWith( A );
Z1Trans_MR_STAR.AlignWith( A );
Matrix<T> Z1Local;
Scale( beta, C );
LockedPartitionDown
( B, BT,
BB, 0 );
PartitionDown
( C, CT,
CB, 0 );
while( CT.Height() < C.Height() )
{
LockedRepartitionDown
( BT, B0,
/**/ /**/
B1,
BB, B2 );
RepartitionDown
( CT, C0,
/**/ /**/
C1,
CB, C2 );
Z1Trans_MR_MC.AlignWith( C1 );
Zeros( C1.Width(), C1.Height(), Z1Trans_MC_STAR );
Zeros( C1.Width(), C1.Height(), Z1Trans_MR_STAR );
//--------------------------------------------------------------------//
B1Trans_MR_STAR.TransposeFrom( B1, conjugate );
B1Trans_VC_STAR = B1Trans_MR_STAR;
B1_STAR_MC.TransposeFrom( B1Trans_VC_STAR, conjugate );
LocalSymmetricAccumulateRU
( orientation, alpha, A, B1_STAR_MC, B1Trans_MR_STAR,
Z1Trans_MC_STAR, Z1Trans_MR_STAR );
Z1Trans.SumScatterFrom( Z1Trans_MC_STAR );
Z1Trans_MR_MC = Z1Trans;
Z1Trans_MR_MC.SumScatterUpdate( T(1), Z1Trans_MR_STAR );
Transpose( Z1Trans_MR_MC.LockedMatrix(), Z1Local, conjugate );
Axpy( T(1), Z1Local, C1.Matrix() );
//--------------------------------------------------------------------//
Z1Trans_MR_MC.FreeAlignments();
SlideLockedPartitionDown
( BT, B0,
B1,
/**/ /**/
BB, B2 );
SlidePartitionDown
( CT, C0,
C1,
/**/ /**/
CB, C2 );
}
#ifndef RELEASE
PopCallStack();
#endif
}
