void HermitianFromEVD
( UpperOrLower uplo,
Matrix<F>& A,
const Matrix<Base<F>>& w,
const Matrix<F>& Z )
{
DEBUG_CSE
Matrix<F> Z1Copy, Y1;
const Int m = Z.Height();
const Int n = Z.Width();
A.Resize( m, m );
if( uplo == LOWER )
MakeTrapezoidal( UPPER, A, 1 );
else
MakeTrapezoidal( LOWER, A, -1 );
const Int bsize = Blocksize();
for( Int k=0; k<n; k+=bsize )
{
const Int nb = Min(bsize,n-k);
auto Z1 = Z( ALL, IR(k,k+nb) );
auto w1 = w( IR(k,k+nb), ALL );
Y1 = Z1Copy = Z1;
DiagonalScale( RIGHT, NORMAL, w1, Y1 );
Trrk( uplo, NORMAL, ADJOINT, F(1), Z1Copy, Y1, F(1), A );
}
}
void LUNMedium
( const AbstractDistMatrix<F>& UPre, AbstractDistMatrix<F>& XPre,
bool checkIfSingular )
{
DEBUG_CSE
const Int m = XPre.Height();
const Int bsize = Blocksize();
const Grid& g = UPre.Grid();
DistMatrixReadProxy<F,F,MC,MR> UProx( UPre );
DistMatrixReadWriteProxy<F,F,MC,MR> XProx( XPre );
auto& U = UProx.GetLocked();
auto& X = XProx.Get();
DistMatrix<F,MC, STAR> U01_MC_STAR(g);
DistMatrix<F,STAR,STAR> U11_STAR_STAR(g);
DistMatrix<F,MR, STAR> X1Trans_MR_STAR(g);
const Int kLast = LastOffset( m, bsize );
Int k=kLast, kOld=m;
while( true )
{
const bool in2x2 = ( k>0 && U.Get(k,k-1) != F(0) );
if( in2x2 )
--k;
const Int nb = kOld-k;
const Range<Int> ind0( 0, k ),
ind1( k, k+nb );
auto U01 = U( ind0, ind1 );
auto U11 = U( ind1, ind1 );
auto X0 = X( ind0, ALL );
auto X1 = X( ind1, ALL );
U11_STAR_STAR = U11; // U11[* ,* ] <- U11[MC,MR]
X1Trans_MR_STAR.AlignWith( X0 );
Transpose( X1, X1Trans_MR_STAR );
// X1^T[MR,* ] := X1^T[MR,* ] U11^-T[* ,* ]
// = (U11^-1[* ,* ] X1[* ,MR])^T
LocalQuasiTrsm
( RIGHT, UPPER, TRANSPOSE,
F(1), U11_STAR_STAR, X1Trans_MR_STAR, checkIfSingular );
Transpose( X1Trans_MR_STAR, X1 );
U01_MC_STAR.AlignWith( X0 );
U01_MC_STAR = U01; // U01[MC,* ] <- U01[MC,MR]
// X0[MC,MR] -= U01[MC,* ] X1[* ,MR]
LocalGemm
( NORMAL, TRANSPOSE, F(-1), U01_MC_STAR, X1Trans_MR_STAR, F(1), X0 );
if( k == 0 )
break;
kOld = k;
k -= Min(bsize,k);
}
}
void UN_C
( T alpha,
const AbstractDistMatrix<T>& APre,
AbstractDistMatrix<T>& CPre,
bool conjugate=false )
{
EL_DEBUG_CSE
const Int r = APre.Width();
const Int bsize = Blocksize();
const Grid& g = APre.Grid();
DistMatrixReadProxy<T,T,MC,MR> AProx( APre );
DistMatrixReadWriteProxy<T,T,MC,MR> CProx( CPre );
auto& A = AProx.GetLocked();
auto& C = CProx.Get();
// Temporary distributions
DistMatrix<T,MC, STAR> A1_MC_STAR(g);
DistMatrix<T,VR, STAR> A1_VR_STAR(g);
DistMatrix<T,STAR,MR > A1Trans_STAR_MR(g);
A1_MC_STAR.AlignWith( C );
A1_VR_STAR.AlignWith( C );
A1Trans_STAR_MR.AlignWith( C );
for( Int k=0; k<r; k+=bsize )
{
const Int nb = Min(bsize,r-k);
auto A1 = A( ALL, IR(k,k+nb) );
A1_VR_STAR = A1_MC_STAR = A1;
Transpose( A1_VR_STAR, A1Trans_STAR_MR, conjugate );
LocalTrrk( UPPER, alpha, A1_MC_STAR, A1Trans_STAR_MR, T(1), C );
}
}
void LUN( const Matrix<F>& U, Matrix<F>& X, bool checkIfSingular )
{
DEBUG_CSE
const Int m = X.Height();
const Int bsize = Blocksize();
const Int kLast = LastOffset( m, bsize );
Int k=kLast, kOld=m;
while( true )
{
const bool in2x2 = ( k>0 && U.Get(k,k-1) != F(0) );
if( in2x2 )
--k;
const Int nb = kOld-k;
const Range<Int> ind0( 0, k ),
ind1( k, k+nb );
auto U01 = U( ind0, ind1 );
auto U11 = U( ind1, ind1 );
auto X0 = X( ind0, ALL );
auto X1 = X( ind1, ALL );
LUNUnb( U11, X1, checkIfSingular );
Gemm( NORMAL, NORMAL, F(-1), U01, X1, F(1), X0 );
if( k == 0 )
break;
kOld = k;
k -= Min(bsize,k);
}
}
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
HermitianFromEVD
( UpperOrLower uplo,
Matrix<F>& A,
const Matrix<Base<F>>& w,
const Matrix<F>& Z )
{
DEBUG_ONLY(CallStackEntry cse("HermitianFromEVD"))
Matrix<F> Z1Copy, Y1;
const Int m = Z.Height();
const Int n = Z.Width();
A.Resize( m, m );
if( uplo == LOWER )
MakeTrapezoidal( UPPER, A, 1 );
else
MakeTrapezoidal( LOWER, A, -1 );
const Int bsize = Blocksize();
for( Int k=0; k<n; k+=bsize )
{
const Int nb = Min(bsize,n-k);
auto Z1 = LockedView( Z, 0, k, m, nb );
auto w1 = LockedView( w, k, 0, nb, 1 );
Y1 = Z1Copy = Z1;
DiagonalScale( RIGHT, NORMAL, w1, Y1 );
Trrk( uplo, NORMAL, ADJOINT, F(1), Z1Copy, Y1, F(1), A );
}
}
void LLN( const Matrix<F>& L, Matrix<F>& X, bool checkIfSingular )
{
DEBUG_CSE
const Int m = X.Height();
const Int bsize = Blocksize();
for( Int k=0; k<m; k+=bsize )
{
const Int nbProp = Min(bsize,m-k);
const bool in2x2 = ( k+nbProp<m && L.Get(k+nbProp-1,k+nbProp) != F(0) );
const Int nb = ( in2x2 ? nbProp+1 : nbProp );
const Range<Int> ind1( k, k+nb ),
ind2( k+nb, m );
auto L11 = L( ind1, ind1 );
auto L21 = L( ind2, ind1 );
auto X1 = X( ind1, ALL );
auto X2 = X( ind2, ALL );
LLNUnb( L11, X1, checkIfSingular );
Gemm( NORMAL, NORMAL, F(-1), L21, X1, F(1), X2 );
}
}
inline void
LUT
( Orientation orientation, F alpha,
Matrix<F>& U, const Matrix<F>& shifts, Matrix<F>& X )
{
DEBUG_ONLY(CSE cse("mstrsm::LUT"))
Scale( alpha, X );
const Int m = X.Height();
const Int bsize = Blocksize();
for( Int k=0; k<m; k+=bsize )
{
const Int nb = Min(bsize,m-k);
const Range<Int> ind1( k, k+nb ),
ind2( k+nb, m );
auto U11 = U( ind1, ind1 );
auto U12 = U( ind1, ind2 );
auto X1 = X( ind1, ALL );
auto X2 = X( ind2, ALL );
LeftUnb( UPPER, orientation, F(1), U11, shifts, X1 );
Gemm( orientation, NORMAL, F(-1), U12, X1, F(1), X2 );
}
}
inline void
LockedRepartitionRight
( const DM& AL, const DM& AR,
DM& A0, DM& A1, DM& A2, Int A1Width=Blocksize() )
{
DEBUG_ONLY(CallStackEntry cse("LockedRepartitionRight"))
LockedView( A0, AL );
LockedPartitionRight( AR, A1, A2, A1Width );
}
inline void
RepartitionRight
( DM& AL, DM& AR,
DM& A0, DM& A1, DM& A2, Int A1Width=Blocksize() )
{
DEBUG_ONLY(CallStackEntry cse("RepartitionRight"))
View( A0, AL );
PartitionRight( AR, A1, A2, A1Width );
}
inline void
LockedRepartitionLeft
( const M& AL, const M& AR,
M& A0, M& A1, M& A2, Int A1Width=Blocksize() )
{
DEBUG_ONLY(CallStackEntry cse("LockedRepartitionLeft"))
LockedPartitionLeft( AL, A0, A1, A1Width );
LockedView( A2, AR );
}
inline void
RepartitionLeft
( DM& AL, DM& AR,
DM& A0, DM& A1, DM& A2, Int A1Width=Blocksize() )
{
DEBUG_ONLY(CallStackEntry cse("RepartitionLeft"))
PartitionLeft( AL, A0, A1, A1Width );
View( A2, AR );
}
virtual void CbSignal()
{
int c = CntOutSig(),rc;
if(stream) {
int sc = stream->getChannels();
rc = c < sc?c:sc;
if(rc)
stream->doGet(rc,OutSig(),Blocksize(),Samplerate());
else
stream->doWakeup();
}
else
rc = 0;
// clear remaining channels
while(rc < c) ZeroSamples(OutSig(rc++),Blocksize());
}
inline void
RepartitionDown
( DM& AT, DM& A0,
DM& A1,
DM& AB, DM& A2, Int A1Height=Blocksize() )
{
DEBUG_ONLY(CallStackEntry cse("RepartitionDown"))
View( A0, AT );
PartitionDown( AB, A1, A2, A1Height );
}
inline void
LockedRepartitionUp
( const DM& AT, DM& A0,
DM& A1,
const DM& AB, DM& A2, Int A1Height=Blocksize() )
{
DEBUG_ONLY(CallStackEntry cse("LockedRepartitionUp"))
LockedPartitionUp( AT, A0, A1, A1Height );
LockedView( A2, AB );
}
inline void
LockedRepartitionDown
( const M& AT, M& A0,
M& A1,
const M& AB, M& A2, Int A1Height=Blocksize() )
{
DEBUG_ONLY(CallStackEntry cse("LockedRepartitionDown"))
LockedView( A0, AT );
LockedPartitionDown( AB, A1, A2, A1Height );
}
inline void
RepartitionUp
( DM& AT, DM& A0,
DM& A1,
DM& AB, DM& A2, Int A1Height=Blocksize() )
{
DEBUG_ONLY(CallStackEntry cse("RepartitionUp"))
PartitionUp( AT, A0, A1, A1Height );
View( A2, AB );
}
void LUNLarge
( UnitOrNonUnit diag,
const AbstractDistMatrix<F>& UPre,
AbstractDistMatrix<F>& XPre,
bool checkIfSingular )
{
EL_DEBUG_CSE
const Int m = XPre.Height();
const Int bsize = Blocksize();
const Grid& g = UPre.Grid();
DistMatrixReadProxy<F,F,MC,MR> UProx( UPre );
DistMatrixReadWriteProxy<F,F,MC,MR> XProx( XPre );
auto& U = UProx.GetLocked();
auto& X = XProx.Get();
DistMatrix<F,MC, STAR> U01_MC_STAR(g);
DistMatrix<F,STAR,STAR> U11_STAR_STAR(g);
DistMatrix<F,STAR,MR > X1_STAR_MR(g);
DistMatrix<F,STAR,VR > X1_STAR_VR(g);
const Int kLast = LastOffset( m, bsize );
for( Int k=kLast; k>=0; k-=bsize )
{
const Int nb = Min(bsize,m-k);
const Range<Int> ind0( 0, k ),
ind1( k, k+nb );
auto U01 = U( ind0, ind1 );
auto U11 = U( ind1, ind1 );
auto X0 = X( ind0, ALL );
auto X1 = X( ind1, ALL );
U11_STAR_STAR = U11; // U11[* ,* ] <- U11[MC,MR]
X1_STAR_VR = X1; // X1[* ,VR] <- X1[MC,MR]
// X1[* ,VR] := U11^-1[* ,* ] X1[* ,VR]
LocalTrsm
( LEFT, UPPER, NORMAL, diag, F(1), U11_STAR_STAR, X1_STAR_VR,
checkIfSingular );
X1_STAR_MR.AlignWith( X0 );
X1_STAR_MR = X1_STAR_VR; // X1[* ,MR] <- X1[* ,VR]
X1 = X1_STAR_MR; // X1[MC,MR] <- X1[* ,MR]
U01_MC_STAR.AlignWith( X0 );
U01_MC_STAR = U01; // U01[MC,* ] <- U01[MC,MR]
// X0[MC,MR] -= U01[MC,* ] X1[* ,MR]
LocalGemm( NORMAL, NORMAL, F(-1), U01_MC_STAR, X1_STAR_MR, F(1), X0 );
}
}
void LLNMedium
( const AbstractDistMatrix<F>& LPre,
AbstractDistMatrix<F>& XPre,
bool checkIfSingular )
{
DEBUG_CSE
const Int m = XPre.Height();
const Int bsize = Blocksize();
const Grid& g = LPre.Grid();
DistMatrixReadProxy<F,F,MC,MR> LProx( LPre );
DistMatrixReadWriteProxy<F,F,MC,MR> XProx( XPre );
auto& L = LProx.GetLocked();
auto& X = XProx.Get();
DistMatrix<F,STAR,STAR> L11_STAR_STAR(g);
DistMatrix<F,MC, STAR> L21_MC_STAR(g);
DistMatrix<F,MR, STAR> X1Trans_MR_STAR(g);
for( Int k=0; k<m; k+=bsize )
{
const Int nbProp = Min(bsize,m-k);
const bool in2x2 = ( k+nbProp<m && L.Get(k+nbProp-1,k+nbProp) != F(0) );
const Int nb = ( in2x2 ? nbProp+1 : nbProp );
const Range<Int> ind1( k, k+nb ),
ind2( k+nb, m );
auto L11 = L( ind1, ind1 );
auto L21 = L( ind2, ind1 );
auto X1 = X( ind1, ALL );
auto X2 = X( ind2, ALL );
L11_STAR_STAR = L11; // L11[* ,* ] <- L11[MC,MR]
X1Trans_MR_STAR.AlignWith( X2 );
Transpose( X1, X1Trans_MR_STAR );
// X1^T[MR,* ] := X1^T[MR,* ] L11^-T[* ,* ]
// = (L11^-1[* ,* ] X1[* ,MR])^T
LocalQuasiTrsm
( RIGHT, LOWER, TRANSPOSE,
F(1), L11_STAR_STAR, X1Trans_MR_STAR, checkIfSingular );
Transpose( X1Trans_MR_STAR, X1 );
L21_MC_STAR.AlignWith( X2 );
L21_MC_STAR = L21; // L21[MC,* ] <- L21[MC,MR]
// X2[MC,MR] -= L21[MC,* ] X1[* ,MR]
LocalGemm
( NORMAL, TRANSPOSE, F(-1), L21_MC_STAR, X1Trans_MR_STAR, F(1), X2 );
}
}
void LUNMedium
( UnitOrNonUnit diag,
const AbstractDistMatrix<F>& UPre,
AbstractDistMatrix<F>& XPre,
bool checkIfSingular )
{
EL_DEBUG_CSE
const Int m = XPre.Height();
const Int bsize = Blocksize();
const Grid& g = UPre.Grid();
DistMatrixReadProxy<F,F,MC,MR> UProx( UPre );
DistMatrixReadWriteProxy<F,F,MC,MR> XProx( XPre );
auto& U = UProx.GetLocked();
auto& X = XProx.Get();
DistMatrix<F,MC, STAR> U01_MC_STAR(g);
DistMatrix<F,STAR,STAR> U11_STAR_STAR(g);
DistMatrix<F,MR, STAR> X1Trans_MR_STAR(g);
const Int kLast = LastOffset( m, bsize );
for( Int k=kLast; k>=0; k-=bsize )
{
const Int nb = Min(bsize,m-k);
const Range<Int> ind0( 0, k ),
ind1( k, k+nb );
auto U01 = U( ind0, ind1 );
auto U11 = U( ind1, ind1 );
auto X0 = X( ind0, ALL );
auto X1 = X( ind1, ALL );
U11_STAR_STAR = U11; // U11[* ,* ] <- U11[MC,MR]
X1Trans_MR_STAR.AlignWith( X0 );
Transpose( X1, X1Trans_MR_STAR );
// X1^T[MR,* ] := X1^T[MR,* ] U11^-T[* ,* ]
// = (U11^-1[* ,* ] X1[* ,MR])^T
LocalTrsm
( RIGHT, UPPER, TRANSPOSE, diag,
F(1), U11_STAR_STAR, X1Trans_MR_STAR, checkIfSingular );
Transpose( X1Trans_MR_STAR, X1 );
U01_MC_STAR.AlignWith( X0 );
U01_MC_STAR = U01; // U01[MC,* ] <- U01[MC,MR]
// X0[MC,MR] -= U01[MC,* ] X1[* ,MR]
LocalGemm
( NORMAL, TRANSPOSE, F(-1), U01_MC_STAR, X1Trans_MR_STAR, F(1), X0 );
}
}
void LLNLarge
( const AbstractDistMatrix<F>& LPre,
AbstractDistMatrix<F>& XPre,
bool checkIfSingular )
{
DEBUG_CSE
const Int m = XPre.Height();
const Int bsize = Blocksize();
const Grid& g = LPre.Grid();
DistMatrixReadProxy<F,F,MC,MR> LProx( LPre );
DistMatrixReadWriteProxy<F,F,MC,MR> XProx( XPre );
auto& L = LProx.GetLocked();
auto& X = XProx.Get();
DistMatrix<F,STAR,STAR> L11_STAR_STAR(g);
DistMatrix<F,MC, STAR> L21_MC_STAR(g);
DistMatrix<F,STAR,MR > X1_STAR_MR(g);
DistMatrix<F,STAR,VR > X1_STAR_VR(g);
for( Int k=0; k<m; k+=bsize )
{
const Int nbProp = Min(bsize,m-k);
const bool in2x2 = ( k+nbProp<m && L.Get(k+nbProp-1,k+nbProp) != F(0) );
const Int nb = ( in2x2 ? nbProp+1 : nbProp );
const Range<Int> ind1( k, k+nb ),
ind2( k+nb, m );
auto L11 = L( ind1, ind1 );
auto L21 = L( ind2, ind1 );
auto X1 = X( ind1, ALL );
auto X2 = X( ind2, ALL );
// X1[* ,VR] := L11^-1[* ,* ] X1[* ,VR]
L11_STAR_STAR = L11;
X1_STAR_VR = X1;
LocalQuasiTrsm
( LEFT, LOWER, NORMAL, F(1), L11_STAR_STAR, X1_STAR_VR,
checkIfSingular );
X1_STAR_MR.AlignWith( X2 );
X1_STAR_MR = X1_STAR_VR; // X1[* ,MR] <- X1[* ,VR]
X1 = X1_STAR_MR; // X1[MC,MR] <- X1[* ,MR]
L21_MC_STAR.AlignWith( X2 );
L21_MC_STAR = L21; // L21[MC,* ] <- L21[MC,MR]
// X2[MC,MR] -= L21[MC,* ] X1[* ,MR]
LocalGemm( NORMAL, NORMAL, F(-1), L21_MC_STAR, X1_STAR_MR, F(1), X2 );
}
}
inline void
RepartitionDownDiagonal
( DM& ATL, DM& ATR, DM& A00, DM& A01, DM& A02,
DM& A10, DM& A11, DM& A12,
DM& ABL, DM& ABR, DM& A20, DM& A21, DM& A22, Int bsize=Blocksize() )
{
DEBUG_ONLY(CallStackEntry cse("RepartitionDownDiagonal"))
View( A00, ATL );
PartitionDownDiagonal( ABR, A11, A12,
A21, A22, bsize );
PartitionDown( ABL, A10, A20, A11.Height() );
PartitionRight( ATR, A01, A02, A11.Width() );
}
inline void
LockedRepartitionDownDiagonal
( const M& ATL, const M& ATR, M& A00, M& A01, M& A02,
M& A10, M& A11, M& A12,
const M& ABL, const M& ABR, M& A20, M& A21, M& A22, Int bsize=Blocksize() )
{
DEBUG_ONLY(CallStackEntry cse("LockedRepartitionDownDiagonal"))
LockedView( A00, ATL );
LockedPartitionDownDiagonal( ABR, A11, A12,
A21, A22, bsize );
LockedPartitionDown( ABL, A10, A20, A11.Height() );
LockedPartitionRight( ATR, A01, A02, A11.Width() );
}
void LowerBlocked( Matrix<F>& A, Matrix<F>& householderScalars )
{
DEBUG_CSE
const Int n = A.Height();
householderScalars.Resize( Max(n-1,0), 1 );
Matrix<F> UB1, V01, VB1, G11;
const Int bsize = Blocksize();
for( Int k=0; k<n-1; k+=bsize )
{
const Int nb = Min(bsize,n-1-k);
const Range<Int> ind0( 0, k ),
ind1( k, k+nb ),
indB( k, n ), indR( k, n ),
ind2( k+nb, n );
auto ABR = A( indB, indR );
auto A22 = A( ind2, ind2 );
auto householderScalars1 = householderScalars( ind1, ALL );
UB1.Resize( n-k, nb );
VB1.Resize( n-k, nb );
G11.Resize( nb, nb );
hessenberg::LowerPanel( ABR, householderScalars1, UB1, VB1, G11 );
auto AB0 = A( indB, ind0 );
auto A2R = A( ind2, indR );
auto U21 = UB1( IR(nb,END), ALL );
auto V21 = VB1( IR(nb,END), ALL );
// AB0 := AB0 - (UB1 inv(G11)^H UB1^H AB0)
// = AB0 - (UB1 ((AB0^H UB1) inv(G11))^H)
// -------------------------------------------
Gemm( ADJOINT, NORMAL, F(1), AB0, UB1, V01 );
Trsm( RIGHT, UPPER, NORMAL, NON_UNIT, F(1), G11, V01 );
Gemm( NORMAL, ADJOINT, F(-1), UB1, V01, F(1), AB0 );
// A2R := (A2R - U21 inv(G11)^H VB1^H)(I - UB1 inv(G11) UB1^H)
// -----------------------------------------------------------
// A2R := A2R - U21 inv(G11)^H VB1^H
// (note: VB1 is overwritten)
Trsm( RIGHT, UPPER, NORMAL, NON_UNIT, F(1), G11, VB1 );
Gemm( NORMAL, ADJOINT, F(-1), U21, VB1, F(1), A2R );
// A2R := A2R - ((A2R UB1) inv(G11)) UB1^H
Gemm( NORMAL, NORMAL, F(1), A2R, UB1, F(0), V21 );
Trsm( RIGHT, UPPER, NORMAL, NON_UNIT, F(1), G11, V21 );
Gemm( NORMAL, ADJOINT, F(-1), V21, UB1, F(1), A2R );
}
}
inline void
RepartitionUpDiagonal
( DM& ATL, DM& ATR, DM& A00, DM& A01, DM& A02,
DM& A10, DM& A11, DM& A12,
DM& ABL, DM& ABR, DM& A20, DM& A21, DM& A22, Int bsize=Blocksize() )
{
DEBUG_ONLY(CallStackEntry cse("RepartitionUpDiagonal"))
PartitionUpOffsetDiagonal
( ATL.Width()-ATL.Height(),
ATL, A00, A01,
A10, A11, bsize );
PartitionUp( ATR, A02, A12, A11.Height() );
PartitionLeft( ABL, A20, A21, A11.Width() );
View( A22, ABR );
}
inline void
LockedRepartitionUpDiagonal
( const M& ATL, const M& ATR, M& A00, M& A01, M& A02,
M& A10, M& A11, M& A12,
const M& ABL, const M& ABR, M& A20, M& A21, M& A22, Int bsize=Blocksize() )
{
DEBUG_ONLY(CallStackEntry cse("LockedRepartitionUpDiagonal"))
LockedPartitionUpOffsetDiagonal
( ATL.Width()-ATL.Height(),
ATL, A00, A01,
A10, A11, bsize );
LockedPartitionUp( ATR, A02, A12, A11.Height() );
LockedPartitionLeft( ABL, A20, A21, A11.Width() );
LockedView( A22, ABR );
}
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 HermitianFromEVD
( UpperOrLower uplo,
AbstractDistMatrix<F>& APre,
const AbstractDistMatrix<Base<F>>& wPre,
const AbstractDistMatrix<F>& ZPre )
{
DEBUG_CSE
typedef Base<F> Real;
DistMatrixWriteProxy<F,F,MC,MR> AProx( APre );
DistMatrixReadProxy<Real,Real,VR,STAR> wProx( wPre );
DistMatrixReadProxy<F,F,MC,MR> ZProx( ZPre );
auto& A = AProx.Get();
auto& w = wProx.GetLocked();
auto& Z = ZProx.GetLocked();
const Grid& g = A.Grid();
DistMatrix<F,MC, STAR> Z1_MC_STAR(g);
DistMatrix<F,VR, STAR> Z1_VR_STAR(g);
DistMatrix<F,STAR,MR > Z1Adj_STAR_MR(g);
const Int m = Z.Height();
const Int n = Z.Width();
A.Resize( m, m );
if( uplo == LOWER )
MakeTrapezoidal( UPPER, A, 1 );
else
MakeTrapezoidal( LOWER, A, -1 );
const Int bsize = Blocksize();
for( Int k=0; k<n; k+=bsize )
{
const Int nb = Min(bsize,n-k);
auto Z1 = Z( ALL, IR(k,k+nb) );
auto w1 = w( IR(k,k+nb), ALL );
Z1_MC_STAR.AlignWith( A );
Z1_MC_STAR = Z1;
Z1_VR_STAR.AlignWith( A );
Z1_VR_STAR = Z1_MC_STAR;
DiagonalScale( RIGHT, NORMAL, w1, Z1_VR_STAR );
Z1Adj_STAR_MR.AlignWith( A );
Adjoint( Z1_VR_STAR, Z1Adj_STAR_MR );
LocalTrrk( uplo, F(1), Z1_MC_STAR, Z1Adj_STAR_MR, F(1), A );
}
}
virtual void CbSignal()
{
int n = Blocksize()/2;
t_sample const *in = InSig(0);
float df = Samplerate()/2/n;
float a = 0,b = 0;
for(int i = 1; i <= n; ++i) {
float f = log(i*df);
a += f*in[i];
b += in[i];
}
centroid = exp(a/b);
if(autobang)
tmr.Now();
}
void SUMMA_NTC
( Orientation orientB,
T alpha,
const AbstractDistMatrix<T>& APre,
const AbstractDistMatrix<T>& BPre,
AbstractDistMatrix<T>& CPre )
{
EL_DEBUG_CSE
const Int sumDim = APre.Width();
const Int bsize = Blocksize();
const Grid& g = APre.Grid();
const bool conjugate = ( orientB == ADJOINT );
DistMatrixReadProxy<T,T,MC,MR> AProx( APre );
DistMatrixReadProxy<T,T,MC,MR> BProx( BPre );
DistMatrixReadWriteProxy<T,T,MC,MR> CProx( CPre );
auto& A = AProx.GetLocked();
auto& B = BProx.GetLocked();
auto& C = CProx.Get();
// Temporary distributions
DistMatrix<T,MC,STAR> A1_MC_STAR(g);
DistMatrix<T,VR,STAR> B1_VR_STAR(g);
DistMatrix<T,STAR,MR> B1Trans_STAR_MR(g);
A1_MC_STAR.AlignWith( C );
B1_VR_STAR.AlignWith( C );
B1Trans_STAR_MR.AlignWith( C );
for( Int k=0; k<sumDim; k+=bsize )
{
const Int nb = Min(bsize,sumDim-k);
auto A1 = A( ALL, IR(k,k+nb) );
auto B1 = B( ALL, IR(k,k+nb) );
A1_MC_STAR = A1;
B1_VR_STAR = B1;
Transpose( B1_VR_STAR, B1Trans_STAR_MR, conjugate );
// C[MC,MR] += alpha A1[MC,*] (B1[MR,*])^T
LocalGemm
( NORMAL, NORMAL, alpha, A1_MC_STAR, B1Trans_STAR_MR, T(1), C );
}
}
