inline void
Wilkinson( Matrix<T>& A, int k )
{
#ifndef RELEASE
CallStackEntry entry("Wilkinson");
#endif
const int n = 2*k+1;
A.ResizeTo( n, n );
MakeZeros( A );
for( int j=0; j<n; ++j )
{
if( j <= k )
A.Set( j, j, T(k-j) );
else
A.Set( j, j, T(j-k) );
if( j > 0 )
A.Set( j-1, j, T(1) );
if( j < n-1 )
A.Set( j+1, j, T(1) );
}
}
inline void
MakeOneTwoOne( Matrix<T>& A )
{
#ifndef RELEASE
PushCallStack("MakeOneTwoOne");
#endif
if( A.Height() != A.Width() )
throw std::logic_error("Cannot make a non-square matrix 1-2-1");
MakeZeros( A );
const int n = A.Width();
for( int j=0; j<n; ++j )
{
A.Set( j, j, (T)2 );
if( j > 0 )
A.Set( j-1, j, (T)1 );
if( j < n )
A.Set( j+1, j, (T)1 );
}
#ifndef RELEASE
PopCallStack();
#endif
}
inline void
GolubReinschUpper
( DistMatrix<F>& A, DistMatrix<BASE(F),VR,STAR>& s, DistMatrix<F>& V )
{
#ifndef RELEASE
CallStackEntry entry("svd::GolubReinschUpper");
#endif
typedef BASE(F) Real;
const Int m = A.Height();
const Int n = A.Width();
const Int k = Min( m, n );
const Int offdiagonal = ( m>=n ? 1 : -1 );
const char uplo = ( m>=n ? 'U' : 'L' );
const Grid& g = A.Grid();
// Bidiagonalize A
DistMatrix<F,STAR,STAR> tP( g ), tQ( g );
Bidiag( A, tP, tQ );
// Grab copies of the diagonal and sub/super-diagonal of A
DistMatrix<Real,MD,STAR> d_MD_STAR(g), e_MD_STAR(g);
A.GetRealPartOfDiagonal( d_MD_STAR );
A.GetRealPartOfDiagonal( e_MD_STAR, offdiagonal );
// NOTE: lapack::BidiagQRAlg expects e to be of length k
DistMatrix<Real,STAR,STAR> d_STAR_STAR( d_MD_STAR ),
eHat_STAR_STAR( k, 1, g ),
e_STAR_STAR( g );
View( e_STAR_STAR, eHat_STAR_STAR, 0, 0, k-1, 1 );
e_STAR_STAR = e_MD_STAR;
// Initialize U and VAdj to the appropriate identity matrices
DistMatrix<F,VC,STAR> U_VC_STAR( g );
DistMatrix<F,STAR,VC> VAdj_STAR_VC( g );
U_VC_STAR.AlignWith( A );
VAdj_STAR_VC.AlignWith( V );
Identity( U_VC_STAR, m, k );
Identity( VAdj_STAR_VC, k, n );
// Compute the SVD of the bidiagonal matrix and accumulate the Givens
// rotations into our local portion of U and VAdj
Matrix<F>& ULoc = U_VC_STAR.Matrix();
Matrix<F>& VAdjLoc = VAdj_STAR_VC.Matrix();
lapack::BidiagQRAlg
( uplo, k, VAdjLoc.Width(), ULoc.Height(),
d_STAR_STAR.Buffer(), e_STAR_STAR.Buffer(),
VAdjLoc.Buffer(), VAdjLoc.LDim(),
ULoc.Buffer(), ULoc.LDim() );
// Make a copy of A (for the Householder vectors) and pull the necessary
// portions of U and VAdj into a standard matrix dist.
DistMatrix<F> B( A );
if( m >= n )
{
DistMatrix<F> AT(g), AB(g);
DistMatrix<F,VC,STAR> UT_VC_STAR(g), UB_VC_STAR(g);
PartitionDown( A, AT, AB, n );
PartitionDown( U_VC_STAR, UT_VC_STAR, UB_VC_STAR, n );
AT = UT_VC_STAR;
MakeZeros( AB );
Adjoint( VAdj_STAR_VC, V );
}
else
{
DistMatrix<F> VT(g), VB(g);
DistMatrix<F,STAR,VC> VAdjL_STAR_VC(g), VAdjR_STAR_VC(g);
PartitionDown( V, VT, VB, m );
PartitionRight( VAdj_STAR_VC, VAdjL_STAR_VC, VAdjR_STAR_VC, m );
Adjoint( VAdjL_STAR_VC, VT );
MakeZeros( VB );
}
// Backtransform U and V
bidiag::ApplyU( LEFT, NORMAL, B, tQ, A );
bidiag::ApplyV( LEFT, NORMAL, B, tP, V );
// Copy out the appropriate subset of the singular values
s = d_STAR_STAR;
}
inline void
GolubReinschUpper_FLA
( DistMatrix<F>& A, DistMatrix<BASE(F),VR,STAR>& s, DistMatrix<F>& V )
{
#ifndef RELEASE
CallStackEntry entry("svd::GolubReinschUpper_FLA");
#endif
typedef BASE(F) Real;
const Int m = A.Height();
const Int n = A.Width();
const Int k = Min( m, n );
const Int offdiagonal = ( m>=n ? 1 : -1 );
const Grid& g = A.Grid();
// Bidiagonalize A
DistMatrix<F,STAR,STAR> tP(g), tQ(g);
Bidiag( A, tP, tQ );
// Grab copies of the diagonal and sub/super-diagonal of A
DistMatrix<Real,MD,STAR> d_MD_STAR(g), e_MD_STAR(g);
A.GetRealPartOfDiagonal( d_MD_STAR );
A.GetRealPartOfDiagonal( e_MD_STAR, offdiagonal );
// In order to use serial QR kernels, we need the full bidiagonal matrix
// on each process
DistMatrix<Real,STAR,STAR> d_STAR_STAR( d_MD_STAR ),
e_STAR_STAR( e_MD_STAR );
// Initialize U and VAdj to the appropriate identity matrices
DistMatrix<F,VC,STAR> U_VC_STAR(g), V_VC_STAR(g);
U_VC_STAR.AlignWith( A );
V_VC_STAR.AlignWith( V );
Identity( U_VC_STAR, m, k );
Identity( V_VC_STAR, n, k );
FlaSVD
( k, U_VC_STAR.LocalHeight(), V_VC_STAR.LocalHeight(),
d_STAR_STAR.Buffer(), e_STAR_STAR.Buffer(),
U_VC_STAR.Buffer(), U_VC_STAR.LDim(),
V_VC_STAR.Buffer(), V_VC_STAR.LDim() );
// Make a copy of A (for the Householder vectors) and pull the necessary
// portions of U and V into a standard matrix dist.
DistMatrix<F> B( A );
if( m >= n )
{
DistMatrix<F> AT(g), AB(g);
DistMatrix<F,VC,STAR> UT_VC_STAR(g), UB_VC_STAR(g);
PartitionDown( A, AT, AB, n );
PartitionDown( U_VC_STAR, UT_VC_STAR, UB_VC_STAR, n );
AT = UT_VC_STAR;
MakeZeros( AB );
V = V_VC_STAR;
}
else
{
DistMatrix<F> VT(g), VB(g);
DistMatrix<F,VC,STAR> VT_VC_STAR(g), VB_VC_STAR(g);
PartitionDown( V, VT, VB, m );
PartitionDown( V_VC_STAR, VT_VC_STAR, VB_VC_STAR, m );
VT = VT_VC_STAR;
MakeZeros( VB );
}
// Backtransform U and V
bidiag::ApplyU( LEFT, NORMAL, B, tQ, A );
bidiag::ApplyV( LEFT, NORMAL, B, tP, V );
// Copy out the appropriate subset of the singular values
s = d_STAR_STAR;
}
bool NnlsBlockpivot(const DenseMatrix<T>& LHS,
const DenseMatrix<T>& RHS,
DenseMatrix<T>& X, // input as xinit
DenseMatrix<T>& Y) // gradX
{
// Solve (LHS)*X = RHS for X by block principal pivoting. Matrix LHS
// is assumed to be symmetric positive definite.
const int PBAR = 3;
const unsigned int WIDTH = RHS.Width();
const unsigned int HEIGHT = RHS.Height();
const unsigned int MAX_ITER = HEIGHT*5;
BitMatrix passive_set = (X > T(0));
std::vector<unsigned int> tmp_indices(WIDTH);
for (unsigned int i=0; i<WIDTH; ++i)
tmp_indices[i] = i;
MakeZeros(X);
if (!BppSolveNormalEqNoGroup(tmp_indices, passive_set, LHS, RHS, X))
return false;
// Y = LHS * X - RHS
Gemm(NORMAL, NORMAL, T(1), LHS, X, T(0), Y);
Axpy( T(-1), RHS, Y);
std::vector<int> P(WIDTH, PBAR), Ninf(WIDTH, HEIGHT+1);
BitMatrix nonopt_set = (Y < T(0)) & ~passive_set;
BitMatrix infeas_set = (X < T(0)) & passive_set;
std::vector<int> col_sums(WIDTH);
std::vector<int> not_good(WIDTH);
nonopt_set.SumColumns(not_good);
infeas_set.SumColumns(col_sums);
not_good += col_sums;
BitMatrix not_opt_cols = (not_good > 0);
BitMatrix not_opt_mask;
std::vector<unsigned int> non_opt_col_indices(WIDTH);
not_opt_cols.Find(non_opt_col_indices);
DenseMatrix<double> RHSsub(HEIGHT, WIDTH);
DenseMatrix<double> Xsub(HEIGHT, WIDTH);
DenseMatrix<double> Ysub(HEIGHT, WIDTH);
unsigned int iter = 0;
while (!non_opt_col_indices.empty())
{
// exit if not getting anywhere
if (iter >= MAX_ITER)
return false;
UpdatePassiveSet(passive_set, PBAR, HEIGHT,
not_opt_cols, nonopt_set, infeas_set,
not_good, P, Ninf);
// equivalent of repmat(NotOptCols, HEIGHT, 1)
not_opt_mask = MatrixFromColumnMask(not_opt_cols, HEIGHT);
// Setup for the normal equation solver by extracting submatrices
// from RHS and X. The normal equation solver will extract further
// subproblems from RHSsub and Xsub and write all updated values
// back into RHSsub and Xsub.
RHS.SubmatrixFromCols(RHSsub, non_opt_col_indices);
X.SubmatrixFromCols(Xsub, non_opt_col_indices);
if (!BppSolveNormalEqNoGroup(non_opt_col_indices, passive_set, LHS, RHSsub, Xsub))
return false;
ZeroizeSmallValues(Xsub, 1.0e-12);
// compute Ysub = LHS * Xsub - RHSsub
Ysub.Resize(RHSsub.Height(), RHSsub.Width());
Gemm(NORMAL, NORMAL, T(1), LHS, Xsub, T(0), Ysub);
Axpy( T(-1), RHSsub, Ysub);
// update Y and X using the new values in Ysub and Xsub
OverwriteCols(Y, Ysub, non_opt_col_indices, non_opt_col_indices.size());
OverwriteCols(X, Xsub, non_opt_col_indices, non_opt_col_indices.size());
ZeroizeSmallValues(X, 1.0e-12);
ZeroizeSmallValues(Y, 1.0e-12);
// Check optimality - BppUpdateSets does the equivalent of the next two lines.
// nonopt_set = not_opt_mask & (Y < T(0)) & ~passive_set;
// infeas_set = not_opt_mask & (X < T(0)) & passive_set;
BppUpdateSets(nonopt_set, infeas_set, not_opt_mask, X, Y, passive_set);
nonopt_set.SumColumns(not_good);
infeas_set.SumColumns(col_sums);
not_good += col_sums;
not_opt_cols = (not_good > 0);
not_opt_cols.Find(non_opt_col_indices);
++iter;
}
return true;
}
inline void
SimpleSVDUpper
( DistMatrix<Complex<double> >& A,
DistMatrix<double,VR,STAR>& s,
DistMatrix<Complex<double> >& V )
{
#ifndef RELEASE
PushCallStack("svd::SimpleSVDUpper");
#endif
typedef double Real;
typedef Complex<Real> C;
const int m = A.Height();
const int n = A.Width();
const int k = std::min( m, n );
const int offdiagonal = ( m>=n ? 1 : -1 );
const char uplo = ( m>=n ? 'U' : 'L' );
const Grid& g = A.Grid();
// Bidiagonalize A
DistMatrix<C,STAR,STAR> tP( g ), tQ( g );
Bidiag( A, tP, tQ );
// Grab copies of the diagonal and sub/super-diagonal of A
DistMatrix<Real,MD,STAR> d_MD_STAR( g ),
e_MD_STAR( g );
A.GetRealPartOfDiagonal( d_MD_STAR );
A.GetRealPartOfDiagonal( e_MD_STAR, offdiagonal );
// In order to use serial QR kernels, we need the full bidiagonal matrix
// on each process
DistMatrix<Real,STAR,STAR> d_STAR_STAR( d_MD_STAR ),
e_STAR_STAR( e_MD_STAR );
// Initialize U and VAdj to the appropriate identity matrices
DistMatrix<C,VC,STAR> U_VC_STAR( g );
DistMatrix<C,VC,STAR> V_VC_STAR( g );
U_VC_STAR.AlignWith( A );
V_VC_STAR.AlignWith( V );
Identity( m, k, U_VC_STAR );
Identity( n, k, V_VC_STAR );
// Compute the SVD of the bidiagonal matrix and accumulate the Givens
// rotations into our local portion of U and V
// NOTE: This _only_ works in the case where m >= n
const int numAccum = 32;
const int maxNumIts = 30;
const int bAlg = 512;
std::vector<C> GBuffer( (k-1)*numAccum ),
HBuffer( (k-1)*numAccum );
FLA_Bsvd_v_opz_var1
( k, U_VC_STAR.LocalHeight(), V_VC_STAR.LocalHeight(),
numAccum, maxNumIts,
d_STAR_STAR.LocalBuffer(), 1,
e_STAR_STAR.LocalBuffer(), 1,
&GBuffer[0], 1, k-1,
&HBuffer[0], 1, k-1,
U_VC_STAR.LocalBuffer(), 1, U_VC_STAR.LocalLDim(),
V_VC_STAR.LocalBuffer(), 1, V_VC_STAR.LocalLDim(),
bAlg );
// Make a copy of A (for the Householder vectors) and pull the necessary
// portions of U and V into a standard matrix dist.
DistMatrix<C> B( A );
if( m >= n )
{
DistMatrix<C> AT( g ),
AB( g );
DistMatrix<C,VC,STAR> UT_VC_STAR( g ),
UB_VC_STAR( g );
PartitionDown( A, AT,
AB, n );
PartitionDown( U_VC_STAR, UT_VC_STAR,
UB_VC_STAR, n );
AT = UT_VC_STAR;
MakeZeros( AB );
V = V_VC_STAR;
}
else
{
DistMatrix<C> VT( g ),
VB( g );
DistMatrix<C,VC,STAR> VT_VC_STAR( g ),
VB_VC_STAR( g );
PartitionDown( V, VT,
VB, m );
PartitionDown
( V_VC_STAR, VT_VC_STAR,
VB_VC_STAR, m );
VT = VT_VC_STAR;
MakeZeros( VB );
}
// Backtransform U and V
if( m >= n )
{
ApplyPackedReflectors
( LEFT, LOWER, VERTICAL, BACKWARD, UNCONJUGATED, 0, B, tQ, A );
ApplyPackedReflectors
( LEFT, UPPER, HORIZONTAL, BACKWARD, UNCONJUGATED, 1, B, tP, V );
}
else
{
ApplyPackedReflectors
( LEFT, LOWER, VERTICAL, BACKWARD, UNCONJUGATED, -1, B, tQ, A );
ApplyPackedReflectors
( LEFT, UPPER, HORIZONTAL, BACKWARD, UNCONJUGATED, 0, B, tP, V );
}
// Copy out the appropriate subset of the singular values
s = d_STAR_STAR;
#ifndef RELEASE
PopCallStack();
#endif
}
inline void
SimpleSVDUpper
( DistMatrix<Real>& A,
DistMatrix<Real,VR,STAR>& s,
DistMatrix<Real>& V )
{
#ifndef RELEASE
PushCallStack("svd::SimpleSVDUpper");
#endif
const int m = A.Height();
const int n = A.Width();
const int k = std::min( m, n );
const int offdiagonal = ( m>=n ? 1 : -1 );
const char uplo = ( m>=n ? 'U' : 'L' );
const Grid& g = A.Grid();
// Bidiagonalize A
Bidiag( A );
// Grab copies of the diagonal and sub/super-diagonal of A
DistMatrix<Real,MD,STAR> d_MD_STAR( g ),
e_MD_STAR( g );
A.GetDiagonal( d_MD_STAR );
A.GetDiagonal( e_MD_STAR, offdiagonal );
// In order to use serial QR kernels, we need the full bidiagonal matrix
// on each process.
//
// NOTE: lapack::BidiagQRAlg expects e to be of length k
DistMatrix<Real,STAR,STAR> d_STAR_STAR( d_MD_STAR );
DistMatrix<Real,STAR,STAR> eHat_STAR_STAR( k, 1, g );
DistMatrix<Real,STAR,STAR> e_STAR_STAR( g );
e_STAR_STAR.View( eHat_STAR_STAR, 0, 0, k-1, 1 );
e_STAR_STAR = e_MD_STAR;
// Initialize U and VTrans to the appropriate identity matrices.
DistMatrix<Real,VC,STAR> U_VC_STAR( g );
DistMatrix<Real,STAR,VC> VTrans_STAR_VC( g );
U_VC_STAR.AlignWith( A );
VTrans_STAR_VC.AlignWith( V );
Identity( m, k, U_VC_STAR );
Identity( k, n, VTrans_STAR_VC );
// Compute the SVD of the bidiagonal matrix and accumulate the Givens
// rotations into our local portion of U and VTrans
Matrix<Real>& ULocal = U_VC_STAR.LocalMatrix();
Matrix<Real>& VTransLocal = VTrans_STAR_VC.LocalMatrix();
lapack::BidiagQRAlg
( uplo, k, VTransLocal.Width(), ULocal.Height(),
d_STAR_STAR.LocalBuffer(), e_STAR_STAR.LocalBuffer(),
VTransLocal.Buffer(), VTransLocal.LDim(),
ULocal.Buffer(), ULocal.LDim() );
// Make a copy of A (for the Householder vectors) and pull the necessary
// portions of U and VTrans into a standard matrix dist.
DistMatrix<Real> B( A );
if( m >= n )
{
DistMatrix<Real> AT( g ),
AB( g );
DistMatrix<Real,VC,STAR> UT_VC_STAR( g ),
UB_VC_STAR( g );
PartitionDown( A, AT,
AB, n );
PartitionDown( U_VC_STAR, UT_VC_STAR,
UB_VC_STAR, n );
AT = UT_VC_STAR;
MakeZeros( AB );
Transpose( VTrans_STAR_VC, V );
}
else
{
DistMatrix<Real> VT( g ),
VB( g );
DistMatrix<Real,STAR,VC>
VTransL_STAR_VC( g ), VTransR_STAR_VC( g );
PartitionDown( V, VT,
VB, m );
PartitionRight( VTrans_STAR_VC, VTransL_STAR_VC, VTransR_STAR_VC, m );
Transpose( VTransL_STAR_VC, VT );
MakeZeros( VB );
}
// Backtransform U and V
if( m >= n )
{
ApplyPackedReflectors
( LEFT, LOWER, VERTICAL, BACKWARD, 0, B, A );
ApplyPackedReflectors
( LEFT, UPPER, HORIZONTAL, BACKWARD, 1, B, V );
}
else
{
ApplyPackedReflectors
( LEFT, LOWER, VERTICAL, BACKWARD, -1, B, A );
ApplyPackedReflectors
( LEFT, UPPER, HORIZONTAL, BACKWARD, 0, B, V );
}
// Copy out the appropriate subset of the singular values
s = d_STAR_STAR;
#ifndef RELEASE
PopCallStack();
#endif
}
