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 }