inline void
Syr2
( UpperOrLower uplo,
T alpha, const DistMatrix<T>& x,
const DistMatrix<T>& y,
DistMatrix<T>& A,
bool conjugate=false )
{
#ifndef RELEASE
CallStackEntry entry("Syr2");
if( A.Grid() != x.Grid() || x.Grid() != y.Grid() )
LogicError
("{A,x,y} must be distributed over the same grid");
if( A.Height() != A.Width() )
LogicError("A must be square");
const Int xLength = ( x.Width()==1 ? x.Height() : x.Width() );
const Int yLength = ( y.Width()==1 ? y.Height() : y.Width() );
if( A.Height() != xLength || A.Height() != yLength )
{
std::ostringstream msg;
msg << "A must conform with x: \n"
<< " A ~ " << A.Height() << " x " << A.Width() << "\n"
<< " x ~ " << x.Height() << " x " << x.Width() << "\n"
<< " y ~ " << y.Height() << " x " << y.Width() << "\n";
LogicError( msg.str() );
}
#endif
const Grid& g = A.Grid();
const Int localHeight = A.LocalHeight();
const Int localWidth = A.LocalWidth();
const Int r = g.Height();
const Int c = g.Width();
const Int colShift = A.ColShift();
const Int rowShift = A.RowShift();
if( x.Width() == 1 && y.Width() == 1 )
{
DistMatrix<T,MC,STAR> x_MC_STAR(g), y_MC_STAR(g);
DistMatrix<T,MR,STAR> x_MR_STAR(g), y_MR_STAR(g);
x_MC_STAR.AlignWith( A );
x_MR_STAR.AlignWith( A );
y_MC_STAR.AlignWith( A );
y_MR_STAR.AlignWith( A );
//--------------------------------------------------------------------//
x_MC_STAR = x;
x_MR_STAR = x_MC_STAR;
y_MC_STAR = y;
y_MR_STAR = y_MC_STAR;
const T* xBuffer = x_MC_STAR.LockedBuffer();
const T* yBuffer = y_MC_STAR.LockedBuffer();
if( uplo == LOWER )
{
for( Int jLoc=0; jLoc<localWidth; ++jLoc )
{
const Int j = rowShift + jLoc*c;
const Int heightAboveDiag = Length(j,colShift,r);
const T beta = y_MR_STAR.GetLocal(jLoc,0);
const T kappa = x_MR_STAR.GetLocal(jLoc,0);
const T gamma = ( conjugate ? alpha*Conj(beta) : alpha*beta );
const T delta = ( conjugate ? alpha*Conj(kappa) : alpha*kappa );
T* ACol = A.Buffer(0,jLoc);
for( Int iLoc=heightAboveDiag; iLoc<localHeight; ++iLoc )
ACol[iLoc] += gamma*xBuffer[iLoc] + delta*yBuffer[iLoc];
}
}
else
{
for( Int jLoc=0; jLoc<localWidth; ++jLoc )
{
const Int j = rowShift + jLoc*c;
const Int heightToDiag = Length(j+1,colShift,r);
const T beta = y_MR_STAR.GetLocal(jLoc,0);
const T kappa = x_MR_STAR.GetLocal(jLoc,0);
const T gamma = ( conjugate ? alpha*Conj(beta) : alpha*beta );
const T delta = ( conjugate ? alpha*Conj(kappa) : alpha*kappa );
T* ACol = A.Buffer(0,jLoc);
for( Int iLoc=0; iLoc<heightToDiag; ++iLoc )
ACol[iLoc] += gamma*xBuffer[iLoc] + delta*yBuffer[iLoc];
}
}
//--------------------------------------------------------------------//
}
else if( x.Width() == 1 )
{
DistMatrix<T,MC,STAR> x_MC_STAR(g);
DistMatrix<T,MR,STAR> x_MR_STAR(g);
DistMatrix<T,STAR,MC> y_STAR_MC(g);
DistMatrix<T,STAR,MR> y_STAR_MR(g);
x_MC_STAR.AlignWith( A );
x_MR_STAR.AlignWith( A );
y_STAR_MC.AlignWith( A );
y_STAR_MR.AlignWith( A );
//--------------------------------------------------------------------//
x_MC_STAR = x;
x_MR_STAR = x_MC_STAR;
y_STAR_MR = y;
y_STAR_MC = y_STAR_MR;
const T* xBuffer = x_MC_STAR.LockedBuffer();
const T* yBuffer = y_STAR_MC.LockedBuffer();
const Int incy = y_STAR_MC.LDim();
if( uplo == LOWER )
{
for( Int jLoc=0; jLoc<localWidth; ++jLoc )
{
const Int j = rowShift + jLoc*c;
const Int heightAboveDiag = Length(j,colShift,r);
const T beta = y_STAR_MR.GetLocal(0,jLoc);
const T kappa = x_MR_STAR.GetLocal(jLoc,0);
const T gamma = ( conjugate ? alpha*Conj(beta) : alpha*beta );
const T delta = ( conjugate ? alpha*Conj(kappa) : alpha*kappa );
T* ACol = A.Buffer(0,jLoc);
for( Int iLoc=heightAboveDiag; iLoc<localHeight; ++iLoc )
ACol[iLoc] += gamma*xBuffer[iLoc] +
delta*yBuffer[iLoc*incy];
}
}
else
{
for( Int jLoc=0; jLoc<localWidth; ++jLoc )
{
const Int j = rowShift + jLoc*c;
const Int heightToDiag = Length(j+1,colShift,r);
const T beta = y_STAR_MR.GetLocal(0,jLoc);
const T kappa = x_MR_STAR.GetLocal(jLoc,0);
const T gamma = ( conjugate ? alpha*Conj(beta) : alpha*beta );
const T delta = ( conjugate ? alpha*Conj(kappa) : alpha*kappa );
T* ACol = A.Buffer(0,jLoc);
for( Int iLoc=0; iLoc<heightToDiag; ++iLoc )
ACol[iLoc] += gamma*xBuffer[iLoc] +
delta*yBuffer[iLoc*incy];
}
}
//--------------------------------------------------------------------//
}
else if( y.Width() == 1 )
{
DistMatrix<T,STAR,MC> x_STAR_MC(g);
DistMatrix<T,STAR,MR> x_STAR_MR(g);
DistMatrix<T,MC,STAR> y_MC_STAR(g);
DistMatrix<T,MR,STAR> y_MR_STAR(g);
x_STAR_MC.AlignWith( A );
x_STAR_MR.AlignWith( A );
y_MC_STAR.AlignWith( A );
y_MR_STAR.AlignWith( A );
//--------------------------------------------------------------------//
x_STAR_MR = x;
x_STAR_MC = x_STAR_MR;
y_MC_STAR = y;
y_MR_STAR = y_MC_STAR;
const T* xBuffer = x_STAR_MC.LockedBuffer();
const T* yBuffer = y_MC_STAR.LockedBuffer();
const Int incx = x_STAR_MC.LDim();
if( uplo == LOWER )
{
for( Int jLoc=0; jLoc<localWidth; ++jLoc )
{
const Int j = rowShift + jLoc*c;
const Int heightAboveDiag = Length(j,colShift,r);
const T beta = x_STAR_MR.GetLocal(0,jLoc);
const T kappa = y_MR_STAR.GetLocal(jLoc,0);
const T gamma = ( conjugate ? alpha*Conj(beta) : alpha*beta );
const T delta = ( conjugate ? alpha*Conj(kappa) : alpha*kappa );
T* ACol = A.Buffer(0,jLoc);
for( Int iLoc=heightAboveDiag; iLoc<localHeight; ++iLoc )
ACol[iLoc] += gamma*xBuffer[iLoc*incx] +
delta*yBuffer[iLoc];
}
}
else
{
for( Int jLoc=0; jLoc<localWidth; ++jLoc )
{
const Int j = rowShift + jLoc*c;
const Int heightToDiag = Length(j+1,colShift,r);
const T beta = x_STAR_MR.GetLocal(0,jLoc);
const T kappa = y_MR_STAR.GetLocal(jLoc,0);
const T gamma = ( conjugate ? alpha*Conj(beta) : alpha*beta );
const T delta = ( conjugate ? alpha*Conj(kappa) : alpha*kappa );
T* ACol = A.Buffer(0,jLoc);
for( Int iLoc=0; iLoc<heightToDiag; ++iLoc )
ACol[iLoc] += gamma*xBuffer[iLoc*incx] +
delta*yBuffer[iLoc];
}
}
//--------------------------------------------------------------------//
}
else
{
DistMatrix<T,STAR,MC> x_STAR_MC(g), y_STAR_MC(g);
DistMatrix<T,STAR,MR> x_STAR_MR(g), y_STAR_MR(g);
x_STAR_MC.AlignWith( A );
x_STAR_MR.AlignWith( A );
y_STAR_MC.AlignWith( A );
y_STAR_MR.AlignWith( A );
//--------------------------------------------------------------------//
x_STAR_MR = x;
x_STAR_MC = x_STAR_MR;
y_STAR_MR = y;
y_STAR_MC = y_STAR_MR;
const T* xBuffer = x_STAR_MC.LockedBuffer();
const T* yBuffer = y_STAR_MC.LockedBuffer();
const Int incx = x_STAR_MC.LDim();
const Int incy = y_STAR_MC.LDim();
if( uplo == LOWER )
{
for( Int jLoc=0; jLoc<localWidth; ++jLoc )
{
const Int j = rowShift + jLoc*c;
const Int heightAboveDiag = Length(j,colShift,r);
const T beta = y_STAR_MR.GetLocal(0,jLoc);
const T kappa = x_STAR_MR.GetLocal(0,jLoc);
const T gamma = ( conjugate ? alpha*Conj(beta) : alpha*beta );
const T delta = ( conjugate ? alpha*Conj(kappa) : alpha*kappa );
T* ACol = A.Buffer(0,jLoc);
for( Int iLoc=heightAboveDiag; iLoc<localHeight; ++iLoc )
ACol[iLoc] += gamma*xBuffer[iLoc*incx] +
delta*yBuffer[iLoc*incy];
}
}
else
{
for( Int jLoc=0; jLoc<localWidth; ++jLoc )
{
const Int j = rowShift + jLoc*c;
const Int heightToDiag = Length(j+1,colShift,r);
const T beta = y_STAR_MR.GetLocal(0,jLoc);
const T kappa = x_STAR_MR.GetLocal(0,jLoc);
const T gamma = ( conjugate ? alpha*Conj(beta) : alpha*beta );
const T delta = ( conjugate ? alpha*Conj(kappa) : alpha*kappa );
T* ACol = A.Buffer(0,jLoc);
for( Int iLoc=0; iLoc<heightToDiag; ++iLoc )
ACol[iLoc] += gamma*xBuffer[iLoc*incx] +
delta*yBuffer[iLoc*incy];
}
}
//--------------------------------------------------------------------//
}
}
inline void
Her
( UpperOrLower uplo,
T alpha, const DistMatrix<T>& x,
DistMatrix<T>& A )
{
#ifndef RELEASE
PushCallStack("Her");
if( A.Grid() != x.Grid() )
throw std::logic_error("{A,x} must be distributed over the same grid");
if( A.Height() != A.Width() )
throw std::logic_error("A must be square");
const int xLength = ( x.Width()==1 ? x.Height() : x.Width() );
if( A.Height() != xLength )
{
std::ostringstream msg;
msg << "A must conform with x: \n"
<< " A ~ " << A.Height() << " x " << A.Width() << "\n"
<< " x ~ " << x.Height() << " x " << x.Width() << "\n";
throw std::logic_error( msg.str() );
}
#endif
const Grid& g = A.Grid();
const int localHeight = A.LocalHeight();
const int localWidth = A.LocalWidth();
const int r = g.Height();
const int c = g.Width();
const int colShift = A.ColShift();
const int rowShift = A.RowShift();
if( x.Width() == 1 )
{
DistMatrix<T,MC,STAR> x_MC_STAR(g);
DistMatrix<T,MR,STAR> x_MR_STAR(g);
x_MC_STAR.AlignWith( A );
x_MR_STAR.AlignWith( A );
//--------------------------------------------------------------------//
x_MC_STAR = x;
x_MR_STAR = x_MC_STAR;
const T* xLocal = x_MC_STAR.LockedLocalBuffer();
if( uplo == LOWER )
{
for( int jLocal=0; jLocal<localWidth; ++jLocal )
{
const int j = rowShift + jLocal*c;
const int heightAboveDiag = LocalLength(j,colShift,r);
const T gamma = alpha*Conj(x_MR_STAR.GetLocal(jLocal,0));
T* ALocalCol = A.LocalBuffer(0,jLocal);
for( int iLocal=heightAboveDiag; iLocal<localHeight; ++iLocal )
ALocalCol[iLocal] += gamma*xLocal[iLocal];
}
}
else
{
for( int jLocal=0; jLocal<localWidth; ++jLocal )
{
const int j = rowShift + jLocal*c;
const int heightToDiag = LocalLength(j+1,colShift,r);
const T gamma = alpha*Conj(x_MR_STAR.GetLocal(jLocal,0));
T* ALocalCol = A.LocalBuffer(0,jLocal);
for( int iLocal=0; iLocal<heightToDiag; ++iLocal )
ALocalCol[iLocal] += gamma*xLocal[iLocal];
}
}
//--------------------------------------------------------------------//
x_MC_STAR.FreeAlignments();
x_MR_STAR.FreeAlignments();
}
else
{
DistMatrix<T,STAR,MC> x_STAR_MC(g);
DistMatrix<T,STAR,MR> x_STAR_MR(g);
x_STAR_MC.AlignWith( A );
x_STAR_MR.AlignWith( A );
//--------------------------------------------------------------------//
x_STAR_MR = x;
x_STAR_MC = x_STAR_MR;
const T* xLocal = x_STAR_MC.LockedLocalBuffer();
const int incx = x_STAR_MC.LocalLDim();
if( uplo == LOWER )
{
for( int jLocal=0; jLocal<localWidth; ++jLocal )
{
const int j = rowShift + jLocal*c;
const int heightAboveDiag = LocalLength(j,colShift,r);
const T gamma = alpha*Conj(x_STAR_MR.GetLocal(0,jLocal));
T* ALocalCol = A.LocalBuffer(0,jLocal);
for( int iLocal=heightAboveDiag; iLocal<localHeight; ++iLocal )
ALocalCol[iLocal] += gamma*xLocal[iLocal*incx];
}
}
else
{
for( int jLocal=0; jLocal<localWidth; ++jLocal )
{
const int j = rowShift + jLocal*c;
const int heightToDiag = LocalLength(j+1,colShift,r);
const T gamma = alpha*Conj(x_STAR_MR.GetLocal(0,jLocal));
T* ALocalCol = A.LocalBuffer(0,jLocal);
for( int iLocal=0; iLocal<heightToDiag; ++iLocal )
ALocalCol[iLocal] += gamma*xLocal[iLocal*incx];
}
}
//--------------------------------------------------------------------//
x_STAR_MC.FreeAlignments();
x_STAR_MR.FreeAlignments();
}
#ifndef RELEASE
PopCallStack();
#endif
}
inline void
Symv
( UpperOrLower uplo,
T alpha, const DistMatrix<T>& A,
const DistMatrix<T>& x,
T beta, DistMatrix<T>& y,
bool conjugate=false )
{
#ifndef RELEASE
CallStackEntry entry("Symv");
if( A.Grid() != x.Grid() || x.Grid() != y.Grid() )
throw std::logic_error
("{A,x,y} must be distributed over the same grid");
if( A.Height() != A.Width() )
throw std::logic_error("A must be square");
if( ( x.Width() != 1 && x.Height() != 1 ) ||
( y.Width() != 1 && y.Height() != 1 ) )
throw std::logic_error("x and y are assumed to be vectors");
const int xLength = ( x.Width()==1 ? x.Height() : x.Width() );
const int yLength = ( y.Width()==1 ? y.Height() : y.Width() );
if( A.Height() != xLength || A.Height() != yLength )
{
std::ostringstream msg;
msg << "Nonconformal Symv: \n"
<< " A ~ " << A.Height() << " x " << A.Width() << "\n"
<< " x ~ " << x.Height() << " x " << x.Width() << "\n"
<< " y ~ " << y.Height() << " x " << y.Width() << "\n";
throw std::logic_error( msg.str() );
}
#endif
const Grid& g = A.Grid();
if( x.Width() == 1 && y.Width() == 1 )
{
// Temporary distributions
DistMatrix<T,MC,STAR> x_MC_STAR(g), z_MC_STAR(g);
DistMatrix<T,MR,STAR> x_MR_STAR(g), z_MR_STAR(g);
DistMatrix<T,MR,MC > z_MR_MC(g);
DistMatrix<T> z(g);
// Begin the algoritm
Scale( beta, y );
x_MC_STAR.AlignWith( A );
x_MR_STAR.AlignWith( A );
z_MC_STAR.AlignWith( A );
z_MR_STAR.AlignWith( A );
z.AlignWith( y );
Zeros( z_MC_STAR, y.Height(), 1 );
Zeros( z_MR_STAR, y.Height(), 1 );
//--------------------------------------------------------------------//
x_MC_STAR = x;
x_MR_STAR = x_MC_STAR;
if( uplo == LOWER )
{
internal::LocalSymvColAccumulateL
( alpha, A, x_MC_STAR, x_MR_STAR, z_MC_STAR, z_MR_STAR, conjugate );
}
else
{
internal::LocalSymvColAccumulateU
( alpha, A, x_MC_STAR, x_MR_STAR, z_MC_STAR, z_MR_STAR, conjugate );
}
z_MR_MC.SumScatterFrom( z_MR_STAR );
z = z_MR_MC;
z.SumScatterUpdate( T(1), z_MC_STAR );
Axpy( T(1), z, y );
//--------------------------------------------------------------------//
x_MC_STAR.FreeAlignments();
x_MR_STAR.FreeAlignments();
z_MC_STAR.FreeAlignments();
z_MR_STAR.FreeAlignments();
z.FreeAlignments();
}
else if( x.Width() == 1 )
{
// Temporary distributions
DistMatrix<T,MC,STAR> x_MC_STAR(g), z_MC_STAR(g);
DistMatrix<T,MR,STAR> x_MR_STAR(g), z_MR_STAR(g);
DistMatrix<T,MR,MC > z_MR_MC(g);
DistMatrix<T> z(g), zTrans(g);
// Begin the algoritm
Scale( beta, y );
x_MC_STAR.AlignWith( A );
x_MR_STAR.AlignWith( A );
z_MC_STAR.AlignWith( A );
z_MR_STAR.AlignWith( A );
z.AlignWith( y );
z_MR_MC.AlignWith( y );
Zeros( z_MC_STAR, y.Width(), 1 );
Zeros( z_MR_STAR, y.Width(), 1 );
//--------------------------------------------------------------------//
x_MC_STAR = x;
x_MR_STAR = x_MC_STAR;
if( uplo == LOWER )
{
internal::LocalSymvColAccumulateL
( alpha, A, x_MC_STAR, x_MR_STAR, z_MC_STAR, z_MR_STAR, conjugate );
}
else
{
internal::LocalSymvColAccumulateU
( alpha, A, x_MC_STAR, x_MR_STAR, z_MC_STAR, z_MR_STAR, conjugate );
}
z.SumScatterFrom( z_MC_STAR );
z_MR_MC = z;
z_MR_MC.SumScatterUpdate( T(1), z_MR_STAR );
Transpose( z_MR_MC, zTrans );
Axpy( T(1), zTrans, y );
//--------------------------------------------------------------------//
x_MC_STAR.FreeAlignments();
x_MR_STAR.FreeAlignments();
z_MC_STAR.FreeAlignments();
z_MR_STAR.FreeAlignments();
z.FreeAlignments();
z_MR_MC.FreeAlignments();
}
else if( y.Width() == 1 )
{
// Temporary distributions
DistMatrix<T,STAR,MC> x_STAR_MC(g), z_STAR_MC(g);
DistMatrix<T,STAR,MR> x_STAR_MR(g), z_STAR_MR(g);
DistMatrix<T,MR, MC> z_MR_MC(g);
DistMatrix<T> z(g), zTrans(g);
// Begin the algoritm
Scale( beta, y );
x_STAR_MC.AlignWith( A );
x_STAR_MR.AlignWith( A );
z_STAR_MC.AlignWith( A );
z_STAR_MR.AlignWith( A );
z.AlignWith( y );
z_MR_MC.AlignWith( y );
Zeros( z_STAR_MC, 1, y.Height() );
Zeros( z_STAR_MR, 1, y.Height() );
//--------------------------------------------------------------------//
x_STAR_MR = x;
x_STAR_MC = x_STAR_MR;
if( uplo == LOWER )
{
internal::LocalSymvRowAccumulateL
( alpha, A, x_STAR_MC, x_STAR_MR, z_STAR_MC, z_STAR_MR, conjugate );
}
else
{
internal::LocalSymvRowAccumulateU
( alpha, A, x_STAR_MC, x_STAR_MR, z_STAR_MC, z_STAR_MR, conjugate );
}
z.SumScatterFrom( z_STAR_MR );
z_MR_MC = z;
z_MR_MC.SumScatterUpdate( T(1), z_STAR_MC );
Transpose( z_MR_MC, zTrans );
Axpy( T(1), zTrans, y );
//--------------------------------------------------------------------//
x_STAR_MC.FreeAlignments();
x_STAR_MR.FreeAlignments();
z_STAR_MC.FreeAlignments();
z_STAR_MR.FreeAlignments();
z.FreeAlignments();
z_MR_MC.FreeAlignments();
}
else
{
// Temporary distributions
DistMatrix<T,STAR,MC> x_STAR_MC(g), z_STAR_MC(g);
DistMatrix<T,STAR,MR> x_STAR_MR(g), z_STAR_MR(g);
DistMatrix<T,MR, MC> z_MR_MC(g);
DistMatrix<T> z(g);
// Begin the algoritm
Scale( beta, y );
x_STAR_MC.AlignWith( A );
x_STAR_MR.AlignWith( A );
z_STAR_MC.AlignWith( A );
z_STAR_MR.AlignWith( A );
z.AlignWith( y );
z_MR_MC.AlignWith( y );
Zeros( z_STAR_MC, 1, y.Width() );
Zeros( z_STAR_MR, 1, y.Width() );
//--------------------------------------------------------------------//
x_STAR_MR = x;
x_STAR_MC = x_STAR_MR;
if( uplo == LOWER )
{
internal::LocalSymvRowAccumulateL
( alpha, A, x_STAR_MC, x_STAR_MR, z_STAR_MC, z_STAR_MR, conjugate );
}
else
{
internal::LocalSymvRowAccumulateU
( alpha, A, x_STAR_MC, x_STAR_MR, z_STAR_MC, z_STAR_MR, conjugate );
}
z_MR_MC.SumScatterFrom( z_STAR_MC );
z = z_MR_MC;
z.SumScatterUpdate( T(1), z_STAR_MR );
Axpy( T(1), z, y );
//--------------------------------------------------------------------//
x_STAR_MC.FreeAlignments();
x_STAR_MR.FreeAlignments();
z_STAR_MC.FreeAlignments();
z_STAR_MR.FreeAlignments();
z.FreeAlignments();
z_MR_MC.FreeAlignments();
}
}
inline void
Geru
( T alpha, const DistMatrix<T>& x,
const DistMatrix<T>& y,
DistMatrix<T>& A )
{
#ifndef RELEASE
PushCallStack("Geru");
if( A.Grid() != x.Grid() || x.Grid() != y.Grid() )
throw std::logic_error("{A,x,y} must be distributed over the same grid");
if( ( x.Width() != 1 && x.Height() != 1 ) ||
( y.Width() != 1 && y.Height() != 1 ) )
throw std::logic_error("x and y are assumed to be vectors");
const int xLength = ( x.Width()==1 ? x.Height() : x.Width() );
const int yLength = ( y.Width()==1 ? y.Height() : y.Width() );
if( A.Height() != xLength || A.Width() != yLength )
{
std::ostringstream msg;
msg << "Nonconformal Geru: \n"
<< " A ~ " << A.Height() << " x " << A.Width() << "\n"
<< " x ~ " << x.Height() << " x " << x.Width() << "\n"
<< " y ~ " << y.Height() << " x " << y.Width() << "\n";
throw std::logic_error( msg.str() );
}
#endif
const Grid& g = A.Grid();
if( x.Width() == 1 && y.Width() == 1 )
{
// Temporary distributions
DistMatrix<T,MC,STAR> x_MC_STAR(g);
DistMatrix<T,MR,STAR> y_MR_STAR(g);
// Begin the algoritm
x_MC_STAR.AlignWith( A );
y_MR_STAR.AlignWith( A );
//--------------------------------------------------------------------//
x_MC_STAR = x;
y_MR_STAR = y;
Geru
( alpha, x_MC_STAR.LockedMatrix(),
y_MR_STAR.LockedMatrix(),
A.Matrix() );
//--------------------------------------------------------------------//
x_MC_STAR.FreeAlignments();
y_MR_STAR.FreeAlignments();
}
else if( x.Width() == 1 )
{
// Temporary distributions
DistMatrix<T,MC, STAR> x_MC_STAR(g);
DistMatrix<T,STAR,MR > y_STAR_MR(g);
// Begin the algorithm
x_MC_STAR.AlignWith( A );
y_STAR_MR.AlignWith( A );
//--------------------------------------------------------------------//
x_MC_STAR = x;
y_STAR_MR = y;
Geru
( alpha, x_MC_STAR.LockedMatrix(),
y_STAR_MR.LockedMatrix(),
A.Matrix() );
//--------------------------------------------------------------------//
x_MC_STAR.FreeAlignments();
y_STAR_MR.FreeAlignments();
}
else if( y.Width() == 1 )
{
// Temporary distributions
DistMatrix<T,STAR,MC > x_STAR_MC(g);
DistMatrix<T,MR, STAR> y_MR_STAR(g);
// Begin the algorithm
x_STAR_MC.AlignWith( A );
y_MR_STAR.AlignWith( A );
//--------------------------------------------------------------------//
x_STAR_MC = x;
y_MR_STAR = y;
Geru
( alpha, x_STAR_MC.LockedMatrix(),
y_MR_STAR.LockedMatrix(),
A.Matrix() );
//--------------------------------------------------------------------//
x_STAR_MC.FreeAlignments();
y_MR_STAR.FreeAlignments();
}
else
{
// Temporary distributions
DistMatrix<T,STAR,MC> x_STAR_MC(g);
DistMatrix<T,STAR,MR> y_STAR_MR(g);
// Begin the algorithm
x_STAR_MC.AlignWith( A );
y_STAR_MR.AlignWith( A );
//--------------------------------------------------------------------//
x_STAR_MC = x;
y_STAR_MR = y;
Geru
( alpha, x_STAR_MC.LockedMatrix(),
y_STAR_MR.LockedMatrix(),
A.Matrix() );
//--------------------------------------------------------------------//
x_STAR_MC.FreeAlignments();
y_STAR_MR.FreeAlignments();
}
#ifndef RELEASE
PopCallStack();
#endif
}
