inline void
MakeOneTwoOne( DistMatrix<T,U,V>& 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 localHeight = A.LocalHeight();
const int localWidth = A.LocalWidth();
const int colShift = A.ColShift();
const int rowShift = A.RowShift();
const int colStride = A.ColStride();
const int rowStride = A.RowStride();
for( int jLocal=0; jLocal<localWidth; ++jLocal )
{
const int j = rowShift + jLocal*rowStride;
for( int iLocal=0; iLocal<localHeight; ++iLocal )
{
const int i = colShift + iLocal*colStride;
if( i == j )
A.SetLocal( iLocal, jLocal, T(2) );
else if( i == j-1 || i == j+1 )
A.SetLocal( iLocal, jLocal, T(1) );
}
}
#ifndef RELEASE
PopCallStack();
#endif
}
inline void
MakeJordan( DistMatrix<T,U,V>& J, T lambda )
{
DEBUG_ONLY(CallStackEntry cse("MakeJordan"))
Zero( J.Matrix() );
const Int localHeight = J.LocalHeight();
const Int localWidth = J.LocalWidth();
const Int colShift = J.ColShift();
const Int rowShift = J.RowShift();
const Int colStride = J.ColStride();
const Int rowStride = J.RowStride();
for( Int jLoc=0; jLoc<localWidth; ++jLoc )
{
const Int j = rowShift + jLoc*rowStride;
for( Int iLoc=0; iLoc<localHeight; ++iLoc )
{
const Int i = colShift + iLoc*colStride;
if( i == j )
J.SetLocal( iLoc, jLoc, lambda );
else if( i == j-1 )
J.SetLocal( iLoc, jLoc, T(1) );
}
}
}
inline void
Wilkinson( DistMatrix<T,U,V>& A, int k )
{
#ifndef RELEASE
CallStackEntry entry("Wilkinson");
#endif
const int n = 2*k+1;
A.ResizeTo( n, n );
MakeZeros( A );
const int localHeight = A.LocalHeight();
const int localWidth = A.LocalWidth();
const int colShift = A.ColShift();
const int rowShift = A.RowShift();
const int colStride = A.ColStride();
const int rowStride = A.RowStride();
for( int jLocal=0; jLocal<localWidth; ++jLocal )
{
const int j = rowShift + jLocal*rowStride;
for( int iLocal=0; iLocal<localHeight; ++iLocal )
{
const int i = colShift + iLocal*colStride;
if( i == j )
{
if( j <= k )
A.SetLocal( iLocal, jLocal, T(k-j) );
else
A.SetLocal( iLocal, jLocal, T(j-k) );
}
else if( i == j-1 || i == j+1 )
A.SetLocal( iLocal, jLocal, T(1) );
}
}
}
inline void
MakeGKS( DistMatrix<F,U,V>& A )
{
#ifndef RELEASE
CallStackEntry entry("MakeGKS");
#endif
const Int m = A.Height();
const Int n = A.Width();
if( m != n )
LogicError("Cannot make a non-square matrix GKS");
const Int localHeight = A.LocalHeight();
const Int localWidth = A.LocalWidth();
const Int colShift = A.ColShift();
const Int rowShift = A.RowShift();
const Int colStride = A.ColStride();
const Int rowStride = A.RowStride();
for( Int jLoc=0; jLoc<localWidth; ++jLoc )
{
const Int j = rowShift + jLoc*rowStride;
const F jDiag = F(1)/Sqrt(F(j));
for( Int iLoc=0; iLoc<localHeight; ++iLoc )
{
const Int i = colShift + iLoc*colStride;
if( i < j )
A.SetLocal( iLoc, jLoc, -jDiag );
else if( i == j )
A.SetLocal( iLoc, jLoc, jDiag );
else
A.SetLocal( iLoc, jLoc, 0 );
}
}
}
inline void
Riemann( DistMatrix<T,U,V>& R, int n )
{
#ifndef RELEASE
CallStackEntry entry("Riemann");
#endif
R.ResizeTo( n, n );
const int localHeight = R.LocalHeight();
const int localWidth = R.LocalWidth();
const int colShift = R.ColShift();
const int rowShift = R.RowShift();
const int colStride = R.ColStride();
const int rowStride = R.RowStride();
for( int jLocal=0; jLocal<localWidth; ++jLocal )
{
const int j = rowShift + jLocal*rowStride;
for( int iLocal=0; iLocal<localHeight; ++iLocal )
{
const int i = colShift + iLocal*colStride;
if( ((j+2)%(i+2))==0 )
R.SetLocal( iLocal, jLocal, T(i+1) );
else
R.SetLocal( iLocal, jLocal, T(-1) );
}
}
}
inline void
MakeDiscreteFourier( DistMatrix<Complex<R>,U,V>& A )
{
#ifndef RELEASE
CallStackEntry entry("MakeDiscreteFourier");
#endif
typedef Complex<R> F;
const int m = A.Height();
const int n = A.Width();
if( m != n )
throw std::logic_error("Cannot make a non-square DFT matrix");
const R pi = 4*Atan( R(1) );
const F nSqrt = Sqrt( R(n) );
const int localHeight = A.LocalHeight();
const int localWidth = A.LocalWidth();
const int colShift = A.ColShift();
const int rowShift = A.RowShift();
const int colStride = A.ColStride();
const int rowStride = A.RowStride();
for( int jLocal=0; jLocal<localWidth; ++jLocal )
{
const int j = rowShift + jLocal*rowStride;
for( int iLocal=0; iLocal<localHeight; ++iLocal )
{
const int i = colShift + iLocal*colStride;
A.SetLocal( iLocal, jLocal, Exp(-2*pi*i*j/n)/nSqrt );
const R theta = -2*pi*i*j/n;
const Complex<R> alpha( Cos(theta), Sin(theta) );
A.SetLocal( iLocal, jLocal, alpha/nSqrt );
}
}
}
inline void
Redheffer( DistMatrix<T,U,V>& R, Int n )
{
#ifndef RELEASE
CallStackEntry entry("Redheffer");
#endif
R.ResizeTo( n, n );
const Int localHeight = R.LocalHeight();
const Int localWidth = R.LocalWidth();
const Int colShift = R.ColShift();
const Int rowShift = R.RowShift();
const Int colStride = R.ColStride();
const Int rowStride = R.RowStride();
for( Int jLoc=0; jLoc<localWidth; ++jLoc )
{
const Int j = rowShift + jLoc*rowStride;
for( Int iLoc=0; iLoc<localHeight; ++iLoc )
{
const Int i = colShift + iLoc*colStride;
if( j==0 || ((j+1)%(i+1))==0 )
R.SetLocal( iLoc, jLoc, T(1) );
else
R.SetLocal( iLoc, jLoc, T(0) );
}
}
}
inline void
Walsh( int k, DistMatrix<T,U,V>& A, bool binary )
{
#ifndef RELEASE
PushCallStack("Walsh");
#endif
if( k < 1 )
throw std::logic_error("Walsh matrices are only defined for k>=1");
const unsigned n = 1u<<k;
A.ResizeTo( n, n );
// Run an O(n^2 log n / p) algorithm based upon successive sign flips
const T onValue = 1;
const T offValue = ( binary ? 0 : -1 );
const unsigned localHeight = A.LocalHeight();
const unsigned localWidth = A.LocalWidth();
const unsigned colShift = A.ColShift();
const unsigned rowShift = A.RowShift();
const unsigned colStride = A.ColStride();
const unsigned rowStride = A.RowStride();
for( unsigned jLocal=0; jLocal<localWidth; ++jLocal )
{
const unsigned j = rowShift + jLocal*rowStride;
for( unsigned iLocal=0; iLocal<localHeight; ++iLocal )
{
const unsigned i = colShift + iLocal*colStride;
// Recurse on the quadtree, flipping the sign of the entry each
// time we are in the bottom-right quadrant
unsigned r = i;
unsigned s = j;
unsigned t = n;
bool on = true;
while( t != 1u )
{
t >>= 1;
if( r >= t && s >= t )
on = !on;
r %= t;
s %= t;
}
if( on )
A.SetLocal( iLocal, jLocal, onValue );
else
A.SetLocal( iLocal, jLocal, offValue );
}
}
#ifndef RELEASE
PopCallStack();
#endif
}
int Corrupt( DistMatrix<F>& A, double probCorrupt )
{
#ifndef RELEASE
CallStackEntry entry("Corrupt");
#endif
typedef BASE(F) Real;
Int numLocalCorrupt = 0;
const Int localHeight = A.LocalHeight();
const Int localWidth = A.LocalWidth();
for( Int jLocal=0; jLocal<localWidth; ++jLocal )
{
for( Int iLocal=0; iLocal<localHeight; ++iLocal )
{
if( Uniform<Real>() <= probCorrupt )
{
++numLocalCorrupt;
const F perturb = SampleBall<F>();
A.SetLocal( iLocal, jLocal, A.GetLocal(iLocal,jLocal)+perturb );
}
}
}
Int numCorrupt;
mpi::AllReduce
( &numLocalCorrupt, &numCorrupt, 1, mpi::SUM, A.Grid().VCComm() );
return numCorrupt;
}
inline void
MakeLegendre( DistMatrix<F,U,V>& A )
{
#ifndef RELEASE
CallStackEntry entry("MakeLegendre");
#endif
if( A.Height() != A.Width() )
LogicError("Cannot make a non-square matrix Legendre");
MakeZeros( A );
const Int localHeight = A.LocalHeight();
const Int localWidth = A.LocalWidth();
const Int colShift = A.ColShift();
const Int rowShift = A.RowShift();
const Int colStride = A.ColStride();
const Int rowStride = A.RowStride();
for( Int jLoc=0; jLoc<localWidth; ++jLoc )
{
const Int j = rowShift + jLoc*rowStride;
for( Int iLoc=0; iLoc<localHeight; ++iLoc )
{
const Int i = colShift + iLoc*colStride;
if( j == i+1 || j == i-1 )
{
const Int k = Max( i, j );
const F gamma = F(1) / Pow( F(2)*k, F(2) );
const F beta = F(1) / (2*Sqrt(F(1)-gamma));
A.SetLocal( iLoc, jLoc, beta );
}
}
}
}
inline void
Diagonal( const std::vector<T>& d, DistMatrix<T,U,V>& D )
{
#ifndef RELEASE
PushCallStack("Diagonal");
#endif
const int n = d.size();
D.ResizeTo( n, n );
MakeZeros( D );
const int localWidth = D.LocalWidth();
const int colShift = D.ColShift();
const int rowShift = D.RowShift();
const int colStride = D.ColStride();
const int rowStride = D.RowStride();
for( int jLocal=0; jLocal<localWidth; ++jLocal )
{
const int j = rowShift + jLocal*rowStride;
if( (j-colShift+colStride) % colStride == 0 )
{
const int iLocal = (j-colShift) / colStride;
D.SetLocal( iLocal, jLocal, d[j] );
}
}
#ifndef RELEASE
PopCallStack();
#endif
}
void dotproduct(DistMatrix<R> &A,DistMatrix<R> &B){
if(A.Height() != B.Height()){
//ERROR!
}
if(A.Width() != B.Width()){
//ERROR!
}
double temp,temp1;
const int colShift = A.ColShift(); // first row we own
const int rowShift = A.RowShift(); // first col we own
const int colStride = A.ColStride();
const int rowStride = A.RowStride();
const int localHeight = A.LocalHeight();
const int localWidth = A.LocalWidth();
for( int iLocal=0; iLocal<localHeight; ++iLocal ){
for( int jLocal=0; jLocal<localWidth; ++jLocal ){
const int i = colShift + iLocal*colStride;
const int j = rowShift + jLocal*rowStride;
temp = A.GetLocal(iLocal, jLocal);
temp1 = B.GetLocal(iLocal,jLocal);
B.SetLocal(iLocal, jLocal, (temp*temp1));
}
}
}
//w = -log(rand(m,n));
void log_uniform(DistMatrix<R> &U){
//boost::random::gamma_distribution<> dist(df/2.0,2.0);
boost::random::uniform_01<> dist;
boost::random::mt19937 rng(static_cast<boost::uint32_t>(commRank));
double temp;
const int colShift = U.ColShift(); // first row we own
const int rowShift = U.RowShift(); // first col we own
const int colStride = U.ColStride();
const int rowStride = U.RowStride();
const int localHeight = U.LocalHeight();
const int localWidth = U.LocalWidth();
for( int iLocal=0; iLocal<localHeight; ++iLocal ){
for( int jLocal=0; jLocal<localWidth; ++jLocal ){
const int i = colShift + iLocal*colStride;
const int j = rowShift + jLocal*rowStride;
temp = dist(rng);
U.SetLocal(iLocal, jLocal, log(temp));
}
}
}
void calc_x_else(const R alpha, const R beta,const R c, const R delta, DistMatrix<R> &x, DistMatrix<R> &phi,DistMatrix<R> &w){
R bphi;
R temp;
R temp2;
const R pi = 4*atan(1);
const int colShift = x.ColShift(); // first row we own
const int rowShift = x.RowShift(); // first col we own
const int colStride = x.ColStride();
const int rowStride = x.RowStride();
const int localHeight = x.LocalHeight();
const int localWidth = x.LocalWidth();
for( int iLocal=0; iLocal<localHeight; ++iLocal ){
for( int jLocal=0; jLocal<localWidth; ++jLocal ){
const int i = colShift + iLocal*colStride;
const int j = rowShift + jLocal*rowStride;
temp = phi.GetLocal(0,jLocal);//phi
temp2 = w.GetLocal(0,jLocal); //w
bphi = (pi/2) + beta * temp;
//cout<< (delta + c * (((2/pi) * (bphi * tan(temp) - beta * log((pi/2) * temp2 * cos(temp) / bphi))) + (beta * tan (pi *alpha/2))))<<endl;
x.SetLocal(iLocal, jLocal, (-1* sqrt(abs(delta + c * (((2/pi) * (bphi * tan(temp) - beta * log((pi/2) * temp2 * cos(temp) / bphi))) + (beta * tan (pi *alpha/2)))))));
}
}
}
void calc_x_if(const R alpha,const R beta,const R c, const R delta,DistMatrix<R> &x, DistMatrix<R> &phi,DistMatrix<R> &w){
R temp; // phi
R temp2; // w
R aphi;
R a1phi;
const R pi = 4*atan(1);
const R zeta = beta * tan(pi * alpha/2);
const int colShift = x.ColShift(); // first row we own
const int rowShift = x.RowShift(); // first col we own
const int colStride = x.ColStride();
const int rowStride = x.RowStride();
const int localHeight = x.LocalHeight();
const int localWidth = x.LocalWidth();
for( int iLocal=0; iLocal<localHeight; ++iLocal ){
for( int jLocal=0; jLocal<localWidth; ++jLocal ){
const int i = colShift + iLocal*colStride;
const int j = rowShift + jLocal*rowStride;
temp = phi.GetLocal(iLocal,jLocal);//phi
temp2 = w.GetLocal(iLocal,jLocal); //w
aphi = alpha * temp;
a1phi = (1-alpha)*temp;
x.SetLocal(iLocal, jLocal, (-1 * sqrt(abs(delta + c *( ( (sin(aphi)+zeta * cos(aphi))/ cos(temp)) * -1 * pow( abs( ((cos(a1phi) + zeta * sin(a1phi))/ (temp2 * cos(temp))) ) ,((1-alpha)/alpha) ) + beta * tan(pi * alpha/2) )))) );
}
}
}
inline void
Hankel( DistMatrix<T,U,V>& A, Int m, Int n, const std::vector<T>& a )
{
#ifndef RELEASE
CallStackEntry entry("Hankel");
#endif
const Int length = m+n-1;
if( a.size() != (Unsigned)length )
LogicError("a was the wrong size");
A.ResizeTo( m, n );
const Int localHeight = A.LocalHeight();
const Int localWidth = A.LocalWidth();
const Int colShift = A.ColShift();
const Int rowShift = A.RowShift();
const Int colStride = A.ColStride();
const Int rowStride = A.RowStride();
for( Int jLoc=0; jLoc<localWidth; ++jLoc )
{
const Int j = rowShift + jLoc*rowStride;
for( Int iLoc=0; iLoc<localHeight; ++iLoc )
{
const Int i = colShift + iLoc*colStride;
A.SetLocal( iLoc, jLoc, a[i+j] );
}
}
}
inline void
Hankel( int m, int n, const std::vector<T>& a, DistMatrix<T,U,V>& A )
{
#ifndef RELEASE
PushCallStack("Hankel");
#endif
const int length = m+n-1;
if( a.size() != (unsigned)length )
throw std::logic_error("a was the wrong size");
A.ResizeTo( m, n );
const int localHeight = A.LocalHeight();
const int localWidth = A.LocalWidth();
const int colShift = A.ColShift();
const int rowShift = A.RowShift();
const int colStride = A.ColStride();
const int rowStride = A.RowStride();
for( int jLocal=0; jLocal<localWidth; ++jLocal )
{
const int j = rowShift + jLocal*rowStride;
for( int iLocal=0; iLocal<localHeight; ++iLocal )
{
const int i = colShift + iLocal*colStride;
A.SetLocal( iLocal, jLocal, a[i+j] );
}
}
#ifndef RELEASE
PopCallStack();
#endif
}
inline void
Pei( DistMatrix<T,U,V>& P, Int n, T alpha )
{
#ifndef RELEASE
CallStackEntry entry("MakeIdentity");
#endif
P.ResizeTo( n, n );
const Int localHeight = P.LocalHeight();
const Int localWidth = P.LocalWidth();
const Int colShift = P.ColShift();
const Int rowShift = P.RowShift();
const Int colStride = P.ColStride();
const Int rowStride = P.RowStride();
for( Int jLoc=0; jLoc<localWidth; ++jLoc )
{
const Int j = rowShift + jLoc*rowStride;
for( Int iLoc=0; iLoc<localHeight; ++iLoc )
{
const Int i = colShift + iLoc*colStride;
P.SetLocal( iLoc, jLoc, T(1) );
if( i == j )
P.UpdateLocal( iLoc, jLoc, alpha );
}
}
}
//phi = (rand(m,n)-.5)*pi;
void phi_uniform(DistMatrix<R> &U){
boost::random::uniform_01<> dist;
boost::random::mt19937 rng(static_cast<boost::uint32_t>(commRank));
R temp;
R pi = 4*atan(1);
const int colShift = U.ColShift(); // first row we own
const int rowShift = U.RowShift(); // first col we own
const int colStride = U.ColStride();
const int rowStride = U.RowStride();
const int localHeight = U.LocalHeight();
const int localWidth = U.LocalWidth();
for( int iLocal=0; iLocal<localHeight; ++iLocal ){
for( int jLocal=0; jLocal<localWidth; ++jLocal ){
const int i = colShift + iLocal*colStride;
const int j = rowShift + jLocal*rowStride;
temp = dist(rng);
U.SetLocal(iLocal, jLocal, ((temp-0.5)*pi) );
}
}
}
inline void
MakeHilbert( DistMatrix<F,U,V>& A )
{
#ifndef RELEASE
CallStackEntry entry("MakeHilbert");
#endif
const Int m = A.Height();
const Int n = A.Width();
if( m != n )
LogicError("Cannot make a non-square matrix Hilbert");
const F one = F(1);
const Int localHeight = A.LocalHeight();
const Int localWidth = A.LocalWidth();
const Int colShift = A.ColShift();
const Int rowShift = A.RowShift();
const Int colStride = A.ColStride();
const Int rowStride = A.RowStride();
for( Int jLoc=0; jLoc<localWidth; ++jLoc )
{
const Int j = rowShift + jLoc*rowStride;
for( Int iLoc=0; iLoc<localHeight; ++iLoc )
{
const Int i = colShift + iLoc*colStride;
A.SetLocal( iLoc, jLoc, one/(i+j+1) );
}
}
}
static void Func
( DistMatrix<T,STAR,VR>& A, T center, typename Base<T>::type radius )
{
const int m = A.Height();
const int localWidth = A.LocalWidth();
for( int jLocal=0; jLocal<localWidth; ++jLocal )
for( int i=0; i<m; ++i )
A.SetLocal( i, jLocal, center+radius*SampleUnitBall<T>() );
}
static void Func
( DistMatrix<T,VR,STAR>& A, T center, typename Base<T>::type radius )
{
const int n = A.Width();
const int localHeight = A.LocalHeight();
for( int j=0; j<n; ++j )
for( int iLocal=0; iLocal<localHeight; ++iLocal )
A.SetLocal( iLocal, j, center+radius*SampleUnitBall<T>() );
}
static void Func
( DistMatrix<T,MC,MR>& A, T center, typename Base<T>::type radius )
{
const int localHeight = A.LocalHeight();
const int localWidth = A.LocalWidth();
for( int jLocal=0; jLocal<localWidth; ++jLocal )
for( int iLocal=0; iLocal<localHeight; ++iLocal )
A.SetLocal( iLocal, jLocal, center+radius*SampleUnitBall<T>() );
}
inline void
MakeKahan( F phi, DistMatrix<F,U,V>& A )
{
#ifndef RELEASE
PushCallStack("MakeKahan");
#endif
typedef typename Base<F>::type R;
const int m = A.Height();
const int n = A.Width();
if( m != n )
throw std::logic_error("Cannot make a non-square matrix Kahan");
if( Abs(phi) >= R(1) )
throw std::logic_error("Phi must be in (0,1)");
const F zeta = Sqrt(1-phi*Conj(phi));
const int localHeight = A.LocalHeight();
const int localWidth = A.LocalWidth();
const int colShift = A.ColShift();
const int rowShift = A.RowShift();
const int colStride = A.ColStride();
const int rowStride = A.RowStride();
for( int iLocal=0; iLocal<localHeight; ++iLocal )
{
const int i = colShift + iLocal*colStride;
const F zetaPow = Pow( zeta, R(i) );
for( int jLocal=0; jLocal<localWidth; ++jLocal )
{
const int j = rowShift + jLocal*rowStride;
if( i > j )
A.SetLocal( iLocal, jLocal, F(0) );
else if( i == j )
A.SetLocal( iLocal, jLocal, zetaPow );
else
A.SetLocal( iLocal, jLocal, -phi*zetaPow );
}
}
#ifndef RELEASE
PopCallStack();
#endif
}
inline void
Lehmer( DistMatrix<F,U,V>& L, Int n )
{
DEBUG_ONLY(CallStackEntry cse("Lehmer"))
L.Resize( n, n );
const Int localHeight = L.LocalHeight();
const Int localWidth = L.LocalWidth();
for( Int jLoc=0; jLoc<localWidth; ++jLoc )
{
const Int j = L.GlobalCol(jLoc);
for( Int iLoc=0; iLoc<localHeight; ++iLoc )
{
const Int i = L.GlobalRow(iLoc);
if( i < j )
L.SetLocal( iLoc, jLoc, F(i+1)/F(j+1) );
else
L.SetLocal( iLoc, jLoc, F(j+1)/F(i+1) );
}
}
}
inline void
MakeOnes( DistMatrix<T,U,V>& A )
{
#ifndef RELEASE
CallStackEntry entry("MakeOnes");
#endif
const int localHeight = A.LocalHeight();
const int localWidth = A.LocalWidth();
for( int jLocal=0; jLocal<localWidth; ++jLocal )
for( int iLocal=0; iLocal<localHeight; ++iLocal )
A.SetLocal( iLocal, jLocal, T(1) );
}
void NormalizeEntries( DistMatrix<F,U,V>& A )
{
const Int localHeight = A.LocalHeight();
const Int localWidth = A.LocalWidth();
for( Int jLocal=0; jLocal<localWidth; ++jLocal )
{
for( Int iLocal=0; iLocal<localHeight; ++iLocal )
{
const F alpha = A.GetLocal( iLocal, jLocal );
A.SetLocal( iLocal, jLocal, alpha/Abs(alpha) );
}
}
}
//function to generate W and Sqrt W for skewed t mvt rnd
void invgamma_matrix(DistMatrix<R> &W, DistMatrix<R> &sqrtW, const int df){
boost::random::gamma_distribution<> dist(df/2.0,2.0);
boost::random::mt19937 rng(static_cast<boost::uint32_t>(commRank));
double temp;
const int colShift = W.ColShift(); // first row we own
const int rowShift = W.RowShift(); // first col we own
const int colStride = W.ColStride();
const int rowStride = W.RowStride();
const int localHeight = W.LocalHeight();
const int localWidth = W.LocalWidth();
for( int iLocal=0; iLocal<localHeight; ++iLocal ){
for( int jLocal=0; jLocal<localWidth; ++jLocal ){
//const int i = colShift + iLocal*colStride;
//const int j = rowShift + jLocal*rowStride;
temp = (double)df/dist(rng);
W.SetLocal( iLocal, jLocal, temp );
sqrtW.SetLocal( iLocal, jLocal, sqrt(temp));
}
}
}
inline void HermitianSVD
( UpperOrLower uplo, DistMatrix<F>& A,
DistMatrix<BASE(F),VR,STAR>& s, DistMatrix<F>& U, DistMatrix<F>& V )
{
#ifndef RELEASE
CallStackEntry entry("HermitianSVD");
#endif
#ifdef HAVE_PMRRR
typedef BASE(F) R;
// Grab an eigenvalue decomposition of A
HermitianEig( uplo, A, s, V );
// Redistribute the singular values into an [MR,* ] distribution
const Grid& grid = A.Grid();
DistMatrix<R,MR,STAR> s_MR_STAR( grid );
s_MR_STAR.AlignWith( V.DistData() );
s_MR_STAR = s;
// Set the singular values to the absolute value of the eigenvalues
const Int numLocalVals = s.LocalHeight();
for( Int iLoc=0; iLoc<numLocalVals; ++iLoc )
{
const R sigma = s.GetLocal(iLoc,0);
s.SetLocal(iLoc,0,Abs(sigma));
}
// Copy V into U (flipping the sign as necessary)
U.AlignWith( V );
U.ResizeTo( V.Height(), V.Width() );
const Int localHeight = V.LocalHeight();
const Int localWidth = V.LocalWidth();
for( Int jLoc=0; jLoc<localWidth; ++jLoc )
{
const R sigma = s_MR_STAR.GetLocal( jLoc, 0 );
F* UCol = U.Buffer( 0, jLoc );
const F* VCol = V.LockedBuffer( 0, jLoc );
if( sigma >= 0 )
for( Int iLoc=0; iLoc<localHeight; ++iLoc )
UCol[iLoc] = VCol[iLoc];
else
for( Int iLoc=0; iLoc<localHeight; ++iLoc )
UCol[iLoc] = -VCol[iLoc];
}
#else
U = A;
MakeHermitian( uplo, U );
SVD( U, s, V );
#endif // ifdef HAVE_PMRRR
}
inline void
Riemann( DistMatrix<T,U,V>& R, Int n )
{
DEBUG_ONLY(CallStackEntry cse("Riemann"))
R.Resize( n, n );
const Int localHeight = R.LocalHeight();
const Int localWidth = R.LocalWidth();
const Int colShift = R.ColShift();
const Int rowShift = R.RowShift();
const Int colStride = R.ColStride();
const Int rowStride = R.RowStride();
for( Int jLoc=0; jLoc<localWidth; ++jLoc )
{
const Int j = rowShift + jLoc*rowStride;
for( Int iLoc=0; iLoc<localHeight; ++iLoc )
{
const Int i = colShift + iLoc*colStride;
if( ((j+2)%(i+2))==0 )
R.SetLocal( iLoc, jLoc, T(i+1) );
else
R.SetLocal( iLoc, jLoc, T(-1) );
}
}
}