bool wxSFScaledDC::DoBlit(wxCoord xdest, wxCoord ydest, wxCoord width, wxCoord height, wxDC* source, wxCoord xsrc, wxCoord ysrc, int rop, bool useMask, wxCoord xsrcMask, wxCoord ysrcMask) { return m_pTargetDC->Blit( Scale(xdest), Scale(ydest), width, height, source, xsrc, ysrc, rop, useMask, xsrcMask, ysrcMask); }
void wxSFScaledDC::DoCrossHair(wxCoord x, wxCoord y) { m_pTargetDC->CrossHair( Scale(x), Scale(y) ); }
const DistMultiVec<T>& DistMultiVec<T>::operator*=( T alpha ) { DEBUG_ONLY(CSE cse("DistMultiVec::operator*=( T )")) Scale( alpha, *this ); return *this; }
void Renderer::Initialize() { //myCamera = std::unique_ptr<FPCamera>(new FPCamera()); collisionManager = std::unique_ptr<CollisionManager>( new CollisionManager()); ////////////////////////////////////////////////////////////////////////// //drawing a square. floor = std::unique_ptr<Model>(new Model()); floor->VertexData.push_back(glm::vec3(-1.0f, -1.0f, 0.0f)); floor->UVData.push_back(glm::vec2(0.0f,0.0f)); floor->VertexData.push_back(glm::vec3(1.0f, -1.0f, 0.0f)); floor->UVData.push_back(glm::vec2(10.0f,0.0f)); floor->VertexData.push_back(glm::vec3( 1.0f, 1.0f, 0.0f)); floor->UVData.push_back(glm::vec2(10.0f,10.0f)); floor->VertexData.push_back(glm::vec3( -1.0f, 1.0f, 0.0f)); floor->UVData.push_back(glm::vec2(0.0f,10.0f)); //first triangle. floor->IndicesData.push_back(0); floor->IndicesData.push_back(1); floor->IndicesData.push_back(3); //second triangle. floor->IndicesData.push_back(1); floor->IndicesData.push_back(2); floor->IndicesData.push_back(3); glm::vec3 squareNormal = glm::vec3(0.0,0.0,1.0); floor->NormalsData.push_back(squareNormal); floor->NormalsData.push_back(squareNormal); floor->NormalsData.push_back(squareNormal); floor->NormalsData.push_back(squareNormal); floor->Initialize(); floorTexture = std::unique_ptr<Texture>(new Texture("data/textures/rock.jpg",0)); ////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////// //load model. for (int i = 0; i < 70; i++){ ring[i] = std::unique_ptr < Rings >(new Rings(&staticModelShader)) ; ring[i]->initlalize(); collisionManager->AddCollidableModel((CollidableModel*)ring[i].get()); } ////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////// house = std::unique_ptr<Model3D>(new Model3D()); house->LoadFromFile("data/models/House/house.3ds"); house->Initialize(); house->SetBoundingBox(CollidableModel::CalculateBoundingBox(house->GetVertices(),-2.0f)); collisionManager->AddCollidableModel((CollidableModel*) house.get()); ////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////// // Create and compile our GLSL program from the shaders animatedModelShader.LoadProgram(); staticModelShader.LoadProgram(); ////////////////////////////////////////////////////////////////////////// player = unique_ptr<Hero>(new Hero(&animatedModelShader)); collisionManager->AddCollidableModel((CollidableModel*)player.get()); myCube = std::unique_ptr<Cube>(new Cube(&staticModelShader)); myCube->Initialize(); ////////////////////////////////////////////////////////////////////////// // Projection matrix : ////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////// // Configure the light. //setup the light position. staticModelShader.UseProgram(); LightPositionID = glGetUniformLocation(staticModelShader.programID,"LightPosition_worldspace"); lightPosition = glm::vec3(5.0,5.0,0.0); glUniform3fv(LightPositionID,1, &lightPosition[0]); //setup the ambient light component. AmbientLightID = glGetUniformLocation(staticModelShader.programID,"ambientLight"); ambientLight = glm::vec3(1.0,1.0,1.0); glUniform3fv(AmbientLightID,1, &ambientLight[0]); //setup the eye position. EyePositionID = glGetUniformLocation(staticModelShader.programID,"EyePosition_worldspace"); //send the eye position to the shaders. glUniform3fv(EyePositionID,1, &player->camera->GetEyePosition()[0]); /////////////////////////////////////////////////// //repeat the process for the animated models shader. animatedModelShader.UseProgram(); LightPositionID = glGetUniformLocation(animatedModelShader.programID,"LightPosition_worldspace"); lightPosition = glm::vec3(1.0,8.25,0.0); glUniform3fv(LightPositionID,1, &lightPosition[0]); //setup the ambient light component. AmbientLightID = glGetUniformLocation(animatedModelShader.programID,"ambientLight"); ambientLight = glm::vec3(1.0,1.0,1.0); glUniform3fv(AmbientLightID,1, &ambientLight[0]); //setup the eye position. EyePositionID = glGetUniformLocation(animatedModelShader.programID,"EyePosition_worldspace"); //send the eye position to the shaders. glUniform3fv(EyePositionID,1, &player->camera->GetEyePosition()[0]); ////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////// //Setting the initaial transformations floorM = glm::scale(1.0f,2.0f,50.0f)*glm::rotate(-90.0f,glm::vec3(1.0f,0.0f,0.0f)); for (int i = 0; i <= 6; i++) { ringM[i] = glm::translate(0.5f, 0.25f, 30.0f + i)* glm::scale(0.03f, 0.03f, 0.03f); ring[i]->bx(glm::vec3(0.5f, 0.25f, 30.0f + i)); ringM[7 + i] = glm::translate(-0.5f, 0.25f, 10.0f + i) * glm::scale(0.03f, 0.03f, 0.03f); ring[7 + i]->bx(glm::vec3(-0.5f, 0.25f, 10.0f + i)); ringM[14 + i] = glm::translate(0.0f, 0.25f, 20.0f + i) * glm::scale(0.03f, 0.03f, 0.03f); ring[14 + i]->bx(glm::vec3(0.0f, 0.25f, 20.0f + i)); ringM[21 + i] = glm::translate(0.5f, 0.25f, 0.0f + i) * glm::scale(0.03f, 0.03f, 0.03f); ring[21 + i]->bx(glm::vec3(0.5f, 0.25f, 0.0f + i)); ringM[28 + i] = glm::translate(-0.5f, 0.25f, -10.0f + i) * glm::scale(0.03f, 0.03f, 0.03f); ring[28 + i]->bx(glm::vec3(-0.5f, 0.25f, -10.0f + i)); ringM[35 + i] = glm::translate(0.0f, 0.25f, -20.0f + i) * glm::scale(0.03f, 0.03f, 0.03f); ring[35 + i]->bx(glm::vec3(0.0f, 0.25f, -20.0f + i)); ringM[42 + i] = glm::translate(0.5f, 0.25f, -30.0f + i) * glm::scale(0.03f, 0.03f, 0.03f); ring[42 + i]->bx(glm::vec3(0.5f, 0.25f, -30.0f + i)); ringM[49 + i] = glm::translate(-0.5f, 0.25f, 40.0f + i) * glm::scale(0.03f, 0.03f, 0.03f); ring[49 + i]->bx(glm::vec3(-0.5f, 0.25f, 40.0f + i)); ringM[56 + i] = glm::translate(0.0f, 0.25f, -40.0f + i) * glm::scale(0.03f, 0.03f, 0.03f); ring[56 + i]->bx(glm::vec3(0.0f, 0.25f, -40.0f + i)); ringM[63 + i] = glm::translate(0.0f, 0.25f, -48.0f + i) * glm::scale(0.03f, 0.03f, 0.03f); ring[63 + i]->bx(glm::vec3(0.0f, 0.25f, -48.0f + i)); } //we have to scale and translate the spider's bounding box to match the new position and size. houseM = glm::rotate(90.0f,1.0f,0.0f,0.0f) *glm::scale(0.1f,0.1f,0.1f); auto tempBox = house->GetBoundingBox(); tempBox.Scale(0.1f,0.1f,0.1f); tempBox.Rotate(90.0f,1.0f,0.0f,0.0f); house->SetBoundingBox(tempBox); ////////////////////////////////////////////////////////////////////////// }
wxMemoryInputStream privatestream(private_png, sizeof private_png); wxImage privateimage(privatestream, wxBITMAP_TYPE_PNG); wxMemoryInputStream staticstream(static_png, sizeof static_png); wxImage staticimage(staticstream, wxBITMAP_TYPE_PNG); wxMemoryInputStream conststream(const_png, sizeof const_png); wxImage constimage(conststream, wxBITMAP_TYPE_PNG); wxBitmap aBitmap(imageWidth,imageHeight); wxMemoryDC dc; dc.SelectObject(aBitmap); dc.SetBrush(*wxWHITE_BRUSH); dc.Clear(); dc.DrawBitmap(Scale(attributeimage),leftBorder,upperBorder,true); if (visibility == 0) dc.DrawBitmap(Scale(publicimage),leftBorder,upperBorder,true); if (visibility == 1) dc.DrawBitmap(Scale(protectedimage),leftBorder,upperBorder,true); if (visibility == 2) dc.DrawBitmap(Scale(privateimage),leftBorder,upperBorder,true); if (scope == 1) dc.DrawBitmap(Scale(staticimage),leftBorder,upperBorder,true); if (isConst) dc.DrawBitmap(Scale(constimage),leftBorder,upperBorder,true);
int Halley ( DistMatrix<F>& A, typename Base<F>::type upperBound ) { #ifndef RELEASE PushCallStack("Halley"); #endif typedef typename Base<F>::type R; const Grid& g = A.Grid(); const int height = A.Height(); const int width = A.Width(); const R oneHalf = R(1)/R(2); const R oneThird = R(1)/R(3); if( height < width ) throw std::logic_error("Height cannot be less than width"); const R epsilon = lapack::MachineEpsilon<R>(); const R tol = 5*epsilon; const R cubeRootTol = Pow(tol,oneThird); const R a = 3; const R b = 1; const R c = 3; // Form the first iterate Scale( 1/upperBound, A ); int numIts=0; R frobNormADiff; DistMatrix<F> ALast( g ); DistMatrix<F> Q( height+width, width, g ); DistMatrix<F> QT(g), QB(g); PartitionDown( Q, QT, QB, height ); DistMatrix<F> C( g ); DistMatrix<F> ATemp( g ); do { if( numIts > 100 ) throw std::runtime_error("Halley iteration did not converge"); ++numIts; ALast = A; // TODO: Come up with a test for when we can use the Cholesky approach if( true ) { // // The standard QR-based algorithm // QT = A; Scale( Sqrt(c), QT ); MakeIdentity( QB ); ExplicitQR( Q ); Gemm( NORMAL, ADJOINT, F(a-b/c)/Sqrt(c), QT, QB, F(b/c), A ); } else { // // Use faster Cholesky-based algorithm since A is well-conditioned // Identity( width, width, C ); Herk( LOWER, ADJOINT, F(c), A, F(1), C ); Cholesky( LOWER, C ); ATemp = A; Trsm( RIGHT, LOWER, ADJOINT, NON_UNIT, F(1), C, ATemp ); Trsm( RIGHT, LOWER, NORMAL, NON_UNIT, F(1), C, ATemp ); Scale( b/c, A ); Axpy( a-b/c, ATemp, A ); } Axpy( F(-1), A, ALast ); frobNormADiff = Norm( ALast, FROBENIUS_NORM ); } while( frobNormADiff > cubeRootTol ); #ifndef RELEASE PopCallStack(); #endif return numIts; }
inline void TrsmLLTSmall ( Orientation orientation, UnitOrNonUnit diag, F alpha, const DistMatrix<F,STAR,VR>& L, DistMatrix<F,VR,STAR>& X, bool checkIfSingular ) { #ifndef RELEASE PushCallStack("internal::TrsmLLTSmall"); if( L.Grid() != X.Grid() ) throw std::logic_error ("L and X must be distributed over the same grid"); if( orientation == NORMAL ) throw std::logic_error("TrsmLLT expects a (Conjugate)Transpose option"); if( L.Height() != L.Width() || L.Height() != X.Height() ) { std::ostringstream msg; msg << "Nonconformal TrsmLLT: \n" << " L ~ " << L.Height() << " x " << L.Width() << "\n" << " X ~ " << X.Height() << " x " << X.Width() << "\n"; throw std::logic_error( msg.str().c_str() ); } if( L.RowAlignment() != X.ColAlignment() ) throw std::logic_error("L and X must be aligned"); #endif const Grid& g = L.Grid(); // Matrix views DistMatrix<F,STAR,VR> LTL(g), LTR(g), L00(g), L01(g), L02(g), LBL(g), LBR(g), L10(g), L11(g), L12(g), L20(g), L21(g), L22(g); DistMatrix<F,VR,STAR> XT(g), X0(g), XB(g), X1(g), X2(g); // Temporary distributions DistMatrix<F,STAR,STAR> L11_STAR_STAR(g); DistMatrix<F,STAR,STAR> X1_STAR_STAR(g); // Start the algorithm Scale( alpha, X ); LockedPartitionUpDiagonal ( L, LTL, LTR, LBL, LBR, 0 ); PartitionUp ( X, XT, XB, 0 ); while( XT.Height() > 0 ) { LockedRepartitionUpDiagonal ( LTL, /**/ LTR, L00, L01, /**/ L02, /**/ L10, L11, /**/ L12, /*************/ /******************/ LBL, /**/ LBR, L20, L21, /**/ L22 ); RepartitionUp ( XT, X0, X1, /**/ /**/ XB, X2 ); //--------------------------------------------------------------------// L11_STAR_STAR = L11; // L11[* ,* ] <- L11[* ,VR] X1_STAR_STAR = X1; // X1[* ,* ] <- X1[VR,* ] // X1[* ,* ] := L11^-[T/H][* ,* ] X1[* ,* ] LocalTrsm ( LEFT, LOWER, orientation, diag, F(1), L11_STAR_STAR, X1_STAR_STAR, checkIfSingular ); X1 = X1_STAR_STAR; // X0[VR,* ] -= L10[* ,VR]^(T/H) X1[* ,* ] LocalGemm( orientation, NORMAL, F(-1), L10, X1_STAR_STAR, F(1), X0 ); //--------------------------------------------------------------------// SlideLockedPartitionUpDiagonal ( LTL, /**/ LTR, L00, /**/ L01, L02, /*************/ /******************/ /**/ L10, /**/ L11, L12, LBL, /**/ LBR, L20, /**/ L21, L22 ); SlidePartitionUp ( XT, X0, /**/ /**/ X1, XB, X2 ); } #ifndef RELEASE PopCallStack(); #endif }
inline void TrsmLLTLarge ( Orientation orientation, UnitOrNonUnit diag, F alpha, const DistMatrix<F>& L, DistMatrix<F>& X, bool checkIfSingular ) { #ifndef RELEASE PushCallStack("internal::TrsmLLTLarge"); if( orientation == NORMAL ) throw std::logic_error("TrsmLLT expects a (Conjugate)Transpose option"); #endif const Grid& g = L.Grid(); // Matrix views DistMatrix<F> LTL(g), LTR(g), L00(g), L01(g), L02(g), LBL(g), LBR(g), L10(g), L11(g), L12(g), L20(g), L21(g), L22(g); DistMatrix<F> XT(g), X0(g), XB(g), X1(g), X2(g); // Temporary distributions DistMatrix<F,STAR,MC > L10_STAR_MC(g); DistMatrix<F,STAR,STAR> L11_STAR_STAR(g); DistMatrix<F,STAR,MR > X1_STAR_MR(g); DistMatrix<F,STAR,VR > X1_STAR_VR(g); // Start the algorithm Scale( alpha, X ); LockedPartitionUpDiagonal ( L, LTL, LTR, LBL, LBR, 0 ); PartitionUp ( X, XT, XB, 0 ); while( XT.Height() > 0 ) { LockedRepartitionUpDiagonal ( LTL, /**/ LTR, L00, L01, /**/ L02, /**/ L10, L11, /**/ L12, /*************/ /******************/ LBL, /**/ LBR, L20, L21, /**/ L22 ); RepartitionUp ( XT, X0, X1, /**/ /**/ XB, X2 ); L10_STAR_MC.AlignWith( X0 ); X1_STAR_MR.AlignWith( X0 ); //--------------------------------------------------------------------// L11_STAR_STAR = L11; // L11[* ,* ] <- L11[MC,MR] X1_STAR_VR = X1; // X1[* ,VR] <- X1[MC,MR] // X1[* ,VR] := L11^-[T/H][* ,* ] X1[* ,VR] LocalTrsm ( LEFT, LOWER, orientation, diag, F(1), L11_STAR_STAR, X1_STAR_VR, checkIfSingular ); X1_STAR_MR = X1_STAR_VR; // X1[* ,MR] <- X1[* ,VR] X1 = X1_STAR_MR; // X1[MC,MR] <- X1[* ,MR] L10_STAR_MC = L10; // L10[* ,MC] <- L10[MC,MR] // X0[MC,MR] -= (L10[* ,MC])^(T/H) X1[* ,MR] // = L10^[T/H][MC,* ] X1[* ,MR] LocalGemm ( orientation, NORMAL, F(-1), L10_STAR_MC, X1_STAR_MR, F(1), X0 ); //--------------------------------------------------------------------// L10_STAR_MC.FreeAlignments(); X1_STAR_MR.FreeAlignments(); SlideLockedPartitionUpDiagonal ( LTL, /**/ LTR, L00, /**/ L01, L02, /*************/ /******************/ /**/ L10, /**/ L11, L12, LBL, /**/ LBR, L20, /**/ L21, L22 ); SlidePartitionUp ( XT, X0, /**/ /**/ X1, XB, X2 ); } #ifndef RELEASE PopCallStack(); #endif }
///////////////////////////////////////// // Display ///////////////////////////////////////// void display(void) { /*clear all pixels*/ glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); mv = LookAt(vec4(0, 0, 10+z_distance, 1.0), vec4(0, 0, 0, 1.0), vec4(0, 1, 0, 0.0)) * RotateX(-90) * RotateZ(rotateZEarth); //mv = mv * RotateY(view_roty) ;//RotateZ(view_rotz); //RotateX(view_rotx) ////////////////////////////// // Display all features ///////////////////////////// if ( true ) { glUseProgram(programAllFeatures); model_view = glGetUniformLocation(programAllFeatures, "model_view"); projection = glGetUniformLocation(programAllFeatures, "projection"); stack.push(mv); mv = mv*Scale(2,2,2); glUniformMatrix4fv(model_view, 1, GL_TRUE, mv); glVertexAttrib4fv(vAmbientDiffuseColor, vec4(.7, 0.7, 0.7, 1)); glVertexAttrib4fv(vSpecularColor, vec4(1.0f,1.0f,1.0f,1.0f)); glVertexAttrib1f(vSpecularExponent, 50.0); glUniform4fv(light_position, 1, vec4(50.0, 0.0, 0.0, 1)); glUniform4fv(light_color, 1, vec4(1,1,1,1)); glUniform4fv(ambient_light, 1, vec4(.5, .5, .5, 5)); // texture unit 0 : color earth glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, texName[0]); //which texture do we want? glDrawArrays( GL_QUAD_STRIP, 0, VertexCount ); mv = stack.pop(); // texture unit 1 : cloud earth //stack.push(mv); //mv = mv*Scale(2.05,2.05,2.05); //glUniformMatrix4fv(model_view, 1, GL_TRUE, mv); //glActiveTexture(GL_TEXTURE1); //glBindTexture(GL_TEXTURE_2D, texName[1]); //which texture do we want? //glDrawArrays( GL_QUAD_STRIP, 0, VertexCount ); //mv = stack.pop(); stack.push(mv); // texture unit 2 : specular earth glActiveTexture(GL_TEXTURE2); glBindTexture(GL_TEXTURE_2D, texName[2]); //which texture do we want? glDrawArrays( GL_QUAD_STRIP, 0, VertexCount ); // texture unit 4 : night earth glActiveTexture(GL_TEXTURE4); glBindTexture(GL_TEXTURE_2D, texName[4]); //which texture do we want? glDrawArrays( GL_QUAD_STRIP, 0, VertexCount ); mv = stack.pop(); } ////////////////////////////// // Display cloud ///////////////////////////// if ( false ) { glUseProgram(programAllFeatures); model_view = glGetUniformLocation(programAllFeatures, "model_view"); projection = glGetUniformLocation(programAllFeatures, "projection"); //glUseProgram(programCloud); //model_view = glGetUniformLocation(programCloud, "model_view"); //projection = glGetUniformLocation(programCloud, "projection"); glActiveTexture(GL_TEXTURE1); mv = mv*Scale(2.01,2.01,2.01); glUniformMatrix4fv(model_view, 1, GL_TRUE, mv); glBindTexture(GL_TEXTURE_2D, texName[1]); //which texture do we want? glDrawArrays( GL_QUAD_STRIP, 0, VertexCount ); } glUseProgram(programAllFeatures); glFlush(); /*start processing buffered OpenGL routines*/ glutSwapBuffers(); }
inline void SymmRUC ( T alpha, const DistMatrix<T>& A, const DistMatrix<T>& B, T beta, DistMatrix<T>& C, bool conjugate=false ) { #ifndef RELEASE PushCallStack("internal::SymmRUC"); if( A.Grid() != B.Grid() || B.Grid() != C.Grid() ) throw std::logic_error("{A,B,C} must be distributed on the same grid"); #endif const Grid& g = A.Grid(); const Orientation orientation = ( conjugate ? ADJOINT : TRANSPOSE ); // Matrix views DistMatrix<T> ATL(g), ATR(g), A00(g), A01(g), A02(g), AColPan(g), ABL(g), ABR(g), A10(g), A11(g), A12(g), ARowPan(g), A20(g), A21(g), A22(g); DistMatrix<T> BL(g), BR(g), B0(g), B1(g), B2(g); DistMatrix<T> CL(g), CR(g), C0(g), C1(g), C2(g), CLeft(g), CRight(g); // Temporary distributions DistMatrix<T,MC, STAR> B1_MC_STAR(g); DistMatrix<T,VR, STAR> AColPan_VR_STAR(g); DistMatrix<T,STAR,MR > AColPanTrans_STAR_MR(g); DistMatrix<T,MR, STAR> ARowPanTrans_MR_STAR(g); B1_MC_STAR.AlignWith( C ); // Start the algorithm Scale( beta, C ); LockedPartitionDownDiagonal ( A, ATL, ATR, ABL, ABR, 0 ); LockedPartitionRight( B, BL, BR, 0 ); PartitionRight( C, CL, CR, 0 ); while( CR.Width() > 0 ) { LockedRepartitionDownDiagonal ( ATL, /**/ ATR, A00, /**/ A01, A02, /*************/ /******************/ /**/ A10, /**/ A11, A12, ABL, /**/ ABR, A20, /**/ A21, A22 ); LockedRepartitionRight ( BL, /**/ BR, B0, /**/ B1, B2 ); RepartitionRight ( CL, /**/ CR, C0, /**/ C1, C2 ); LockedView1x2( ARowPan, A11, A12 ); LockedView2x1 ( AColPan, A01, A11 ); View1x2( CLeft, C0, C1 ); View1x2( CRight, C1, C2 ); AColPan_VR_STAR.AlignWith( CLeft ); AColPanTrans_STAR_MR.AlignWith( CLeft ); ARowPanTrans_MR_STAR.AlignWith( CRight ); //--------------------------------------------------------------------// B1_MC_STAR = B1; AColPan_VR_STAR = AColPan; AColPanTrans_STAR_MR.TransposeFrom( AColPan_VR_STAR, conjugate ); ARowPanTrans_MR_STAR.TransposeFrom( ARowPan, conjugate ); MakeTriangular( LOWER, ARowPanTrans_MR_STAR ); MakeTrapezoidal( RIGHT, LOWER, -1, AColPanTrans_STAR_MR ); LocalGemm ( NORMAL, orientation, alpha, B1_MC_STAR, ARowPanTrans_MR_STAR, T(1), CRight ); LocalGemm ( NORMAL, NORMAL, alpha, B1_MC_STAR, AColPanTrans_STAR_MR, T(1), CLeft ); //--------------------------------------------------------------------// AColPan_VR_STAR.FreeAlignments(); AColPanTrans_STAR_MR.FreeAlignments(); ARowPanTrans_MR_STAR.FreeAlignments(); SlideLockedPartitionDownDiagonal ( ATL, /**/ ATR, A00, A01, /**/ A02, /**/ A10, A11, /**/ A12, /*************/ /******************/ ABL, /**/ ABR, A20, A21, /**/ A22 ); SlideLockedPartitionRight ( BL, /**/ BR, B0, B1, /**/ B2 ); SlidePartitionRight ( CL, /**/ CR, C0, C1, /**/ C2 ); } #ifndef RELEASE PopCallStack(); #endif }
inline void SymmRUA ( T alpha, const DistMatrix<T>& A, const DistMatrix<T>& B, T beta, DistMatrix<T>& C, bool conjugate=false ) { #ifndef RELEASE PushCallStack("internal::SymmRUA"); if( A.Grid() != B.Grid() || B.Grid() != C.Grid() ) throw std::logic_error ("{A,B,C} must be distributed over the same grid"); #endif const Grid& g = A.Grid(); const Orientation orientation = ( conjugate ? ADJOINT : TRANSPOSE ); DistMatrix<T> BT(g), B0(g), BB(g), B1(g), B2(g); DistMatrix<T> CT(g), C0(g), CB(g), C1(g), C2(g); DistMatrix<T,MR, STAR> B1Trans_MR_STAR(g); DistMatrix<T,VC, STAR> B1Trans_VC_STAR(g); DistMatrix<T,STAR,MC > B1_STAR_MC(g); DistMatrix<T,MC, STAR> Z1Trans_MC_STAR(g); DistMatrix<T,MR, STAR> Z1Trans_MR_STAR(g); DistMatrix<T,MC, MR > Z1Trans(g); DistMatrix<T,MR, MC > Z1Trans_MR_MC(g); B1Trans_MR_STAR.AlignWith( A ); B1Trans_VC_STAR.AlignWith( A ); B1_STAR_MC.AlignWith( A ); Z1Trans_MC_STAR.AlignWith( A ); Z1Trans_MR_STAR.AlignWith( A ); Matrix<T> Z1Local; Scale( beta, C ); LockedPartitionDown ( B, BT, BB, 0 ); PartitionDown ( C, CT, CB, 0 ); while( CT.Height() < C.Height() ) { LockedRepartitionDown ( BT, B0, /**/ /**/ B1, BB, B2 ); RepartitionDown ( CT, C0, /**/ /**/ C1, CB, C2 ); Z1Trans_MR_MC.AlignWith( C1 ); Zeros( C1.Width(), C1.Height(), Z1Trans_MC_STAR ); Zeros( C1.Width(), C1.Height(), Z1Trans_MR_STAR ); //--------------------------------------------------------------------// B1Trans_MR_STAR.TransposeFrom( B1, conjugate ); B1Trans_VC_STAR = B1Trans_MR_STAR; B1_STAR_MC.TransposeFrom( B1Trans_VC_STAR, conjugate ); LocalSymmetricAccumulateRU ( orientation, alpha, A, B1_STAR_MC, B1Trans_MR_STAR, Z1Trans_MC_STAR, Z1Trans_MR_STAR ); Z1Trans.SumScatterFrom( Z1Trans_MC_STAR ); Z1Trans_MR_MC = Z1Trans; Z1Trans_MR_MC.SumScatterUpdate( T(1), Z1Trans_MR_STAR ); Transpose( Z1Trans_MR_MC.LockedMatrix(), Z1Local, conjugate ); Axpy( T(1), Z1Local, C1.Matrix() ); //--------------------------------------------------------------------// Z1Trans_MR_MC.FreeAlignments(); SlideLockedPartitionDown ( BT, B0, B1, /**/ /**/ BB, B2 ); SlidePartitionDown ( CT, C0, C1, /**/ /**/ CB, C2 ); } #ifndef RELEASE PopCallStack(); #endif }