int main() { int n,c1,c2,c3,i; double cos; printf("Enter the number: "); scanf("%d",&n); int *ar; int *br; ar = (int *)malloc(sizeof(int)*n); for (i=0;i<n;i++) { printf("Enter the element of array: "); scanf("%d",&ar[i]); } br = (int *)malloc(sizeof(int)*n); printf("\n"); for (i=0;i<n;i++) { printf("Enter the element of array: "); scanf("%d",&br[i]); } Scal(ar,ar,n,&c1); Scal(br,br,n,&c2); if ((c1==0)&&(c2==0)) printf("1"); else if ((c1==0)||(c2==0)) printf("0"); else { Scal(ar,br,n,&c3); cos = c3/(sqrt(c1)*sqrt(c2)); } if (cos==1) printf("1"); else printf("0"); return 0; }
/* Prototype implementation for specialized functions */ void Vector::AddTwoVectorsImpl(Number a, const Vector& v1, Number b, const Vector& v2, Number c) { if (c==0.) { if (a==1.) { Copy(v1); if (b!=0.) { Axpy(b, v2); } } else if (a==0.) { if (b==0.) { Set(0.); } else { Copy(v2); if (b!=1.) { Scal(b); } } } else { if (b==1.) { Copy(v2); Axpy(a, v1); } else if (b==0.) { Copy(v1); Scal(a); } else { Copy(v1); Scal(a); Axpy(b, v2); } } } else { /* c==0. */ if (c!=1.) { Scal(c); } if (a!=0.) { Axpy(a, v1); } if (b!=0.) { Axpy(b, v2); } } }
// Describes how to run the CLBlast routine static StatusCode RunRoutine(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) { #ifdef OPENCL_API auto queue_plain = queue(); auto event = cl_event{}; auto status = Scal(args.n, args.alpha, buffers.x_vec(), args.x_offset, args.x_inc, &queue_plain, &event); if (status == StatusCode::kSuccess) { clWaitForEvents(1, &event); clReleaseEvent(event); } #elif CUDA_API auto status = Scal(args.n, args.alpha, buffers.x_vec(), args.x_offset, args.x_inc, queue.GetContext()(), queue.GetDevice()()); cuStreamSynchronize(queue()); #endif return status; }
Vettore Piano::ProjOnNorm(Vettore *v){ double Len = 0.; for(int d=0;d<v->NDim;d++){ Len += v->x[d]*Norm[d]; } Vettore Scal(Len*Norm[0],Len*Norm[1],Len*Norm[2]); return Scal; }
void Gemv ( char trans, int m, int n, T alpha, const T* A, int lda, const T* x, int incx, T beta, T* y, int incy ) { if( trans == 'N' ) { if( m > 0 && n == 0 && beta == 0 ) { for( int i=0; i<m; ++i ) y[i*incy] = 0; return; } Scal( m, beta, y, incy ); for( int i=0; i<m; ++i ) for( int j=0; j<n; ++j ) y[i*incy] += alpha*A[i+j*lda]*x[j*incx]; } else if( trans == 'T' ) { if( n > 0 && m == 0 && beta == 0 ) { for( int i=0; i<n; ++i ) y[i*incy] = 0; return; } Scal( n, beta, y, incy ); for( int i=0; i<n; ++i ) for( int j=0; j<m; ++j ) y[i*incy] += alpha*A[j+i*lda]*x[j*incx]; } else { if( n > 0 && m == 0 && beta == 0 ) { for( int i=0; i<n; ++i ) y[i*incy] = 0; return; } Scal( n, beta, y, incy ); for( int i=0; i<n; ++i ) for( int j=0; j<m; ++j ) y[i*incy] += alpha*Conj(A[j+i*lda])*x[j*incx]; } }
// Describes how to run the CLBlast routine static StatusCode RunRoutine(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) { auto queue_plain = queue(); auto event = cl_event{}; auto status = Scal(args.n, args.alpha, buffers.x_vec(), args.x_offset, args.x_inc, &queue_plain, &event); clWaitForEvents(1, &event); return status; }
/*! *\brief Mergesort na tablicy * *\param[in] tablica-struktura przechowujaca tablice dynamiczna *\param[in] lewy- lewa granica sortowania (numer indeksu) *\param[in] prawy- prawa granica sortowania (numer indeksu) */ void MSort::Mergesort(Tab &tablica,int lewy,int prawy){ if(prawy<=lewy) return; int srodek = (prawy+lewy)/2; Mergesort(tablica,lewy,srodek); Mergesort(tablica,srodek+1,prawy); Scal(tablica,lewy,srodek,prawy); }
void Vector::normalize() { Scal d = norm(); Scal t; if (d != Scal(0.0f)) { t= 1/d; x *= t; y *= t; z *= t; } }
bool ICoDF_HTM::HTM::CheckPointInTriangle(std::pair<double, double> A, std::pair<double, double> B, std::pair<double, double> C, std::pair<double, double> P) { std::pair<double, double> v0 = CalcCoordPoint(C, A); std::pair<double, double> v1 = CalcCoordPoint(B, A); std::pair<double, double> v2 = CalcCoordPoint(P, A); const double dot00 = Scal(v0, v0); const double dot01 = Scal(v0, v1); const double dot02 = Scal(v0, v2); const double dot11 = Scal(v1, v1); const double dot12 = Scal(v1, v2); const double invDenom = 1 / (dot00 * dot11 - dot01 * dot01); const double u = (dot11 * dot02 - dot01 * dot12) * invDenom; const double v = (dot00 * dot12 - dot01 * dot02) * invDenom; return ((u >= 0) && (v >= 0) && (u + v < 1)); }
Vector Vector::normalized() const{ Scal d = norm(); Scal t; Vector v = *this; if (d != Scal(0)) { t= 1/d; v.x *= t; v.y *= t; v.z *= t; } return v; }
inline void LU( Matrix<F>& A ) { #ifndef RELEASE PushCallStack("LU"); #endif // Matrix views Matrix<F> ATL, ATR, A00, a01, A02, alpha21T, ABL, ABR, a10, alpha11, a12, a21B, A20, a21, A22; PushBlocksizeStack( 1 ); PartitionDownDiagonal ( A, ATL, ATR, ABL, ABR, 0 ); while( ATL.Height() < A.Height() && ATL.Width() < A.Width() ) { RepartitionDownDiagonal ( ATL, /**/ ATR, A00, /**/ a01, A02, /*************/ /**********************/ /**/ a10, /**/ alpha11, a12, ABL, /**/ ABR, A20, /**/ a21, A22 ); //--------------------------------------------------------------------// F alpha = alpha11.Get(0,0); if( alpha == static_cast<F>(0) ) throw SingularMatrixException(); Scal( static_cast<F>(1)/alpha, a21 ); Geru( (F)-1, a21, a12, A22 ); //--------------------------------------------------------------------// SlidePartitionDownDiagonal ( ATL, /**/ ATR, A00, a01, /**/ A02, /**/ a10, alpha11, /**/ a12, /*************/ /**********************/ ABL, /**/ ABR, A20, a21, /**/ A22 ); } PopBlocksizeStack(); #ifndef RELEASE PopCallStack(); #endif }
inline void SVD ( DistMatrix<F>& A, DistMatrix<typename Base<F>::type,VR,STAR>& s, DistMatrix<F>& V, double heightRatio ) { #ifndef RELEASE PushCallStack("SVD"); if( heightRatio <= 1.0 ) throw std::logic_error("Nonsensical switchpoint for SVD"); #endif typedef typename Base<F>::type Real; // Check if we need to rescale the matrix, and do so if necessary bool needRescaling; Real scale; svd::CheckScale( A, needRescaling, scale ); if( needRescaling ) Scale( scale, A ); // TODO: Switch between different algorithms. For instance, starting // with a QR decomposition of tall-skinny matrices. if( A.Height() >= A.Width() ) { svd::SVDUpper( A, s, V, heightRatio ); } else { // Lower bidiagonalization is not yet supported, so we instead play a // trick to get the SVD of A. Adjoint( A, V ); svd::SVDUpper( V, s, A, heightRatio ); } // Rescale the singular values if necessary if( needRescaling ) Scal( 1/scale, s ); #ifndef RELEASE PopCallStack(); #endif }
inline void SingularValues ( DistMatrix<F>& A, DistMatrix<typename Base<F>::type,VR,STAR>& s, double heightRatio ) { #ifndef RELEASE PushCallStack("SingularValues"); #endif typedef typename Base<F>::type R; // Check if we need to rescale the matrix, and do so if necessary bool needRescaling; R scale; svd::CheckScale( A, needRescaling, scale ); if( needRescaling ) Scale( scale, A ); // TODO: Switch between different algorithms. For instance, starting // with a QR decomposition of tall-skinny matrices. if( A.Height() >= A.Width() ) { svd::SingularValuesUpper( A, s, heightRatio ); } else { // Lower bidiagonalization is not yet supported, so we instead play a // trick to get the SVD of A. DistMatrix<F> AAdj( A.Grid() ); Adjoint( A, AAdj ); svd::SingularValuesUpper( AAdj, s, heightRatio ); } // Rescale the singular values if necessary if( needRescaling ) Scal( 1/scale, s ); #ifndef RELEASE PopCallStack(); #endif }
inline void internal::HemmLLC ( T alpha, const DistMatrix<T,MC,MR>& A, const DistMatrix<T,MC,MR>& B, T beta, DistMatrix<T,MC,MR>& C ) { #ifndef RELEASE PushCallStack("internal::HemmLLC"); 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(); // Matrix views DistMatrix<T,MC,MR> 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,MC,MR> BT(g), B0(g), BB(g), B1(g), B2(g); DistMatrix<T,MC,MR> CT(g), C0(g), CAbove(g), CB(g), C1(g), CBelow(g), C2(g); // Temporary distributions DistMatrix<T,MC, STAR> AColPan_MC_STAR(g); DistMatrix<T,STAR,MC > ARowPan_STAR_MC(g); DistMatrix<T,MR, STAR> B1Adj_MR_STAR(g); // Start the algorithm Scal( beta, C ); LockedPartitionDownDiagonal ( A, ATL, ATR, ABL, ABR, 0 ); LockedPartitionDown ( B, BT, BB, 0 ); PartitionDown ( C, CT, CB, 0 ); while( CB.Height() > 0 ) { LockedRepartitionDownDiagonal ( ATL, /**/ ATR, A00, /**/ A01, A02, /*************/ /******************/ /**/ A10, /**/ A11, A12, ABL, /**/ ABR, A20, /**/ A21, A22 ); LockedRepartitionDown ( BT, B0, /**/ /**/ B1, BB, B2 ); RepartitionDown ( CT, C0, /**/ /**/ C1, CB, C2 ); ARowPan.LockedView1x2( A10, A11 ); AColPan.LockedView2x1 ( A11, A21 ); CAbove.View2x1 ( C0, C1 ); CBelow.View2x1 ( C1, C2 ); AColPan_MC_STAR.AlignWith( CBelow ); ARowPan_STAR_MC.AlignWith( CAbove ); B1Adj_MR_STAR.AlignWith( C ); //--------------------------------------------------------------------// AColPan_MC_STAR = AColPan; ARowPan_STAR_MC = ARowPan; MakeTrapezoidal( LEFT, LOWER, 0, AColPan_MC_STAR ); MakeTrapezoidal( RIGHT, LOWER, -1, ARowPan_STAR_MC ); B1Adj_MR_STAR.AdjointFrom( B1 ); internal::LocalGemm ( NORMAL, ADJOINT, alpha, AColPan_MC_STAR, B1Adj_MR_STAR, (T)1, CBelow ); internal::LocalGemm ( ADJOINT, ADJOINT, alpha, ARowPan_STAR_MC, B1Adj_MR_STAR, (T)1, CAbove ); //--------------------------------------------------------------------// AColPan_MC_STAR.FreeAlignments(); ARowPan_STAR_MC.FreeAlignments(); B1Adj_MR_STAR.FreeAlignments(); SlideLockedPartitionDownDiagonal ( ATL, /**/ ATR, A00, A01, /**/ A02, /**/ A10, A11, /**/ A12, /*************/ /******************/ ABL, /**/ ABR, A20, A21, /**/ A22 ); SlideLockedPartitionDown ( BT, B0, B1, /**/ /**/ BB, B2 ); SlidePartitionDown ( CT, C0, C1, /**/ /**/ CB, C2 ); } #ifndef RELEASE PopCallStack(); #endif }
Scal Vector::norm() const{ auto r = (x*x+y*y+z*z); return Scal(std::sqrt(r)); }
inline void internal::GemmTNB ( Orientation orientationOfA, T alpha, const DistMatrix<T,MC,MR>& A, const DistMatrix<T,MC,MR>& B, T beta, DistMatrix<T,MC,MR>& C ) { #ifndef RELEASE PushCallStack("internal::GemmTNB"); if( A.Grid() != B.Grid() || B.Grid() != C.Grid() ) throw std::logic_error ("{A,B,C} must be distributed over the same grid"); if( orientationOfA == NORMAL ) throw std::logic_error("GemmTNB assumes A is (Conjugate)Transposed"); if( A.Width() != C.Height() || B.Width() != C.Width() || A.Height() != B.Height() ) { std::ostringstream msg; msg << "Nonconformal GemmTNB: \n" << " A ~ " << A.Height() << " x " << A.Width() << "\n" << " B ~ " << B.Height() << " x " << B.Width() << "\n" << " C ~ " << C.Height() << " x " << C.Width() << "\n"; throw std::logic_error( msg.str() ); } #endif const Grid& g = A.Grid(); // Matrix views DistMatrix<T,MC,MR> AL(g), AR(g), A0(g), A1(g), A2(g); DistMatrix<T,MC,MR> CT(g), C0(g), CB(g), C1(g), C2(g); // Temporary distributions DistMatrix<T,MC,STAR> A1_MC_STAR(g); DistMatrix<T,STAR,MR> D1_STAR_MR(g); // Start the algorithm Scal( beta, C ); LockedPartitionRight( A, AL, AR, 0 ); PartitionDown ( C, CT, CB, 0 ); while( AR.Width() > 0 ) { LockedRepartitionRight ( AL, /**/ AR, A0, /**/ A1, A2 ); RepartitionDown ( CT, C0, /**/ /**/ C1, CB, C2 ); A1_MC_STAR.AlignWith( B ); D1_STAR_MR.AlignWith( B ); D1_STAR_MR.ResizeTo( C1.Height(), C1.Width() ); //--------------------------------------------------------------------// A1_MC_STAR = A1; // A1[MC,*] <- A1[MC,MR] // D1[*,MR] := alpha (A1[MC,*])^T B[MC,MR] // = alpha (A1^T)[*,MC] B[MC,MR] internal::LocalGemm ( orientationOfA, NORMAL, alpha, A1_MC_STAR, B, (T)0, D1_STAR_MR ); // C1[MC,MR] += scattered result of D1[*,MR] summed over grid cols C1.SumScatterUpdate( (T)1, D1_STAR_MR ); //--------------------------------------------------------------------// A1_MC_STAR.FreeAlignments(); D1_STAR_MR.FreeAlignments(); SlideLockedPartitionRight ( AL, /**/ AR, A0, A1, /**/ A2 ); SlidePartitionDown ( CT, C0, C1, /**/ /**/ CB, C2 ); } #ifndef RELEASE PopCallStack(); #endif }
inline void internal::GemmTNC ( Orientation orientationOfA, T alpha, const DistMatrix<T,MC,MR>& A, const DistMatrix<T,MC,MR>& B, T beta, DistMatrix<T,MC,MR>& C ) { #ifndef RELEASE PushCallStack("internal::GemmTNC"); if( A.Grid() != B.Grid() || B.Grid() != C.Grid() ) throw std::logic_error ("{A,B,C} must be distributed over the same grid"); if( orientationOfA == NORMAL ) throw std::logic_error("GemmTNC assumes A is (Conjugate)Transposed"); if( A.Width() != C.Height() || B.Width() != C.Width() || A.Height() != B.Height() ) { std::ostringstream msg; msg << "Nonconformal GemmTNC: \n" << " A ~ " << A.Height() << " x " << A.Width() << "\n" << " B ~ " << B.Height() << " x " << B.Width() << "\n" << " C ~ " << C.Height() << " x " << C.Width() << "\n"; throw std::logic_error( msg.str().c_str() ); } #endif const Grid& g = A.Grid(); // Matrix views DistMatrix<T,MC,MR> AT(g), A0(g), AB(g), A1(g), A2(g); DistMatrix<T,MC,MR> BT(g), B0(g), BB(g), B1(g), B2(g); // Temporary distributions DistMatrix<T,STAR,MC> A1_STAR_MC(g); DistMatrix<T,STAR,MR> B1_STAR_MR(g); // Start the algorithm Scal( beta, C ); LockedPartitionDown ( A, AT, AB, 0 ); LockedPartitionDown ( B, BT, BB, 0 ); while( AB.Height() > 0 ) { LockedRepartitionDown ( AT, A0, /**/ /**/ A1, AB, A2 ); LockedRepartitionDown ( BT, B0, /**/ /**/ B1, BB, B2 ); A1_STAR_MC.AlignWith( C ); B1_STAR_MR.AlignWith( C ); //--------------------------------------------------------------------// A1_STAR_MC = A1; // A1[*,MC] <- A1[MC,MR] B1_STAR_MR = B1; // B1[*,MR] <- B1[MC,MR] // C[MC,MR] += alpha (A1[*,MC])^T B1[*,MR] // = alpha (A1^T)[MC,*] B1[*,MR] internal::LocalGemm ( orientationOfA, NORMAL, alpha, A1_STAR_MC, B1_STAR_MR, (T)1, C ); //--------------------------------------------------------------------// A1_STAR_MC.FreeAlignments(); B1_STAR_MR.FreeAlignments(); SlideLockedPartitionDown ( AT, A0, A1, /**/ /**/ AB, A2 ); SlideLockedPartitionDown ( BT, B0, B1, /**/ /**/ BB, B2 ); } #ifndef RELEASE PopCallStack(); #endif }
inline void internal::GemmTNA ( Orientation orientationOfA, T alpha, const DistMatrix<T,MC,MR>& A, const DistMatrix<T,MC,MR>& B, T beta, DistMatrix<T,MC,MR>& C ) { #ifndef RELEASE PushCallStack("internal::GemmTNA"); if( A.Grid() != B.Grid() || B.Grid() != C.Grid() ) throw std::logic_error ("{A,B,C} must be distributed over the same grid"); if( orientationOfA == NORMAL ) throw std::logic_error("GemmTNA assumes A is (Conjugate)Transposed"); if( A.Width() != C.Height() || B.Width() != C.Width() || A.Height() != B.Height() ) { std::ostringstream msg; msg << "Nonconformal GemmTNA: \n" << " A ~ " << A.Height() << " x " << A.Width() << "\n" << " B ~ " << B.Height() << " x " << B.Width() << "\n" << " C ~ " << C.Height() << " x " << C.Width() << "\n"; throw std::logic_error( msg.str().c_str() ); } #endif const Grid& g = A.Grid(); // Matrix views DistMatrix<T,MC,MR> BL(g), BR(g), B0(g), B1(g), B2(g); DistMatrix<T,MC,MR> CL(g), CR(g), C0(g), C1(g), C2(g); // Temporary distributions DistMatrix<T,MC,STAR> B1_MC_STAR(g); DistMatrix<T,MR,STAR> D1_MR_STAR(g); DistMatrix<T,MR,MC > D1_MR_MC(g); DistMatrix<T,MC,MR > D1(g); // Start the algorithm Scal( beta, C ); LockedPartitionRight( B, BL, BR, 0 ); PartitionRight( C, CL, CR, 0 ); while( BR.Width() > 0 ) { LockedRepartitionRight ( BL, /**/ BR, B0, /**/ B1, B2 ); RepartitionRight ( CL, /**/ CR, C0, /**/ C1, C2 ); B1_MC_STAR.AlignWith( A ); D1_MR_STAR.AlignWith( A ); D1_MR_STAR.ResizeTo( C1.Height(), C1.Width() ); D1.AlignWith( C1 ); //--------------------------------------------------------------------// B1_MC_STAR = B1; // B1[MC,*] <- B1[MC,MR] // D1[MR,*] := alpha (A1[MC,MR])^T B1[MC,*] // = alpha (A1^T)[MR,MC] B1[MC,*] internal::LocalGemm ( orientationOfA, NORMAL, alpha, A, B1_MC_STAR, (T)0, D1_MR_STAR ); // C1[MC,MR] += scattered & transposed D1[MR,*] summed over grid cols D1_MR_MC.SumScatterFrom( D1_MR_STAR ); D1 = D1_MR_MC; Axpy( (T)1, D1, C1 ); //--------------------------------------------------------------------// B1_MC_STAR.FreeAlignments(); D1_MR_STAR.FreeAlignments(); D1.FreeAlignments(); SlideLockedPartitionRight ( BL, /**/ BR, B0, B1, /**/ B2 ); SlidePartitionRight ( CL, /**/ CR, C0, C1, /**/ C2 ); } #ifndef RELEASE PopCallStack(); #endif }
void __fastcall Tunnel::MakeKeyFrames( char *nom, short nseg, short condition ) { short i, k; GLfloat tmp[3]; GLfloat dir[10][3]; MakeDir(nom, nseg, dir); /////////////////////// // Position KeyFrames /////////////////////// // 1st PosKey[0][0] = PosKey[0][1] = PosKey[0][2] = 0; Affect(PosKeyDir[0], dir[1]); PosKeyTime[0] = 0; // 2st Scal(PosKey[1], LSEG, dir[1]); Affect(PosKeyDir[1], dir[1]); PosKeyTime[1] = (double) LSEG / SPEED; for(k=2, i=2 ; i<=nseg ; i++) { // k-ieme Add(tmp, dir[i-1], dir[i]); Scal(tmp, RSEG, tmp); Add(PosKey[k], PosKey[k-1], tmp); Affect(PosKeyDir[k], dir[i]); PosKeyTime[k] = PosKeyTime[k-1] + (double) M_PI_2 * RSEG / SPEED; k++; // k-ieme (+1) Scal(tmp, LSEG, dir[i]); Add(PosKey[k], PosKey[k-1], tmp); Affect(PosKeyDir[k], dir[i]); PosKeyTime[k] = PosKeyTime[k-1] + (double) LSEG / SPEED; k++; } nPosKey = k-1; LastPosKey = 0; NextPosKey = 1; //////////////////////////////////////////////// // Rotation KeyFrames, fonction des conditions //////////////////////////////////////////////// if(condition == 1) { // 1st Affect(RotKeyDir[0], dir[1]); RotKeyUp[0][0] = RotKeyUp[0][2] = 0; RotKeyUp[0][1] = 1; RotKeyTime[0] = PosKeyTime[0]; for(k=1, i=1 ; i<nseg ; ) { // k-ieme Affect(RotKeyDir[k], dir[i]); Affect(RotKeyUp[k], RotKeyUp[k-1]); // Meme que précédement RotKeyTime[k] = PosKeyTime[k] - (double) ANTICIPATION/SPEED; k++; i++; // k-ieme +1 Affect(RotKeyDir[k], dir[i]); Cross(tmp, RotKeyDir[k-1], RotKeyDir[k]); if(CompareAbs(tmp, RotKeyUp[k-1])) // Si rotation autour de RotKeyUp Affect(RotKeyUp[k], RotKeyUp[k-1]); else // Sinon applique la rotation à RotKeyUp Cross(RotKeyUp[k], tmp, RotKeyUp[k-1]); RotKeyTime[k] = PosKeyTime[k]; k++; } // dernier Affect(RotKeyDir[k], dir[i]); Affect(RotKeyUp[k], RotKeyUp[k-1]); // Meme que précédement RotKeyTime[k] = PosKeyTime[k]; nRotKey = k; LastRotKey = 0; NextRotKey = 1; } else if(condition == 2) { // 1st Affect(RotKeyDir[0], dir[1]); RotKeyUp[0][0] = RotKeyUp[0][2] = 0; RotKeyUp[0][1] = 1; RotKeyTime[0] = PosKeyTime[0]; for(k=1, i=1 ; i<nseg ; ) { // k-ieme Affect(RotKeyDir[k], dir[i]); Affect(RotKeyUp[k], RotKeyUp[k-1]); // Meme que précédement RotKeyTime[k] = PosKeyTime[k] - (double) ANTICIPATION/SPEED; k++; i++; // k-ieme +1 Affect(RotKeyDir[k], dir[i]); Cross(tmp, RotKeyDir[k-1], RotKeyDir[k]); if(CompareAbs(tmp, RotKeyUp[k-1])) // Si rotation autour de RotKeyUp Affect(RotKeyUp[k], RotKeyUp[0]); else // Sinon applique la rotation à RotKeyUp Cross(RotKeyUp[k], tmp, RotKeyUp[k-1]); RotKeyTime[k] = PosKeyTime[k]; k++; } // dernier Affect(RotKeyDir[k], dir[i]); Affect(RotKeyUp[k], RotKeyUp[k-1]); // Meme que précédement RotKeyTime[k] = PosKeyTime[k]; nRotKey = k; LastRotKey = 0; NextRotKey = 1; } else if(condition == 3) { // 1st Affect(RotKeyDir[0], dir[1]); RotKeyUp[0][0] = RotKeyUp[0][2] = 0; RotKeyUp[0][1] = 1; RotKeyTime[0] = PosKeyTime[0]; for(k=1, i=1 ; i<nseg ; ) { // k-ieme Affect(RotKeyDir[k], RotKeyDir[k-1]); Affect(RotKeyUp[k], RotKeyUp[0]); // Meme que précédement RotKeyTime[k] = PosKeyTime[k] - (double) ANTICIPATION/SPEED; k++; i++; // k-ieme +1 if(dir[i][1] == 1 || dir[i][1] == -1) // si segment vertical { if(i+1 <= nseg) Affect(RotKeyDir[k], dir[i+1]); else Affect(RotKeyDir[k], RotKeyDir[k-1]); } else Affect(RotKeyDir[k], dir[i]); Affect(RotKeyUp[k], RotKeyUp[0]); RotKeyTime[k] = PosKeyTime[k]; k++; } // dernier if(dir[i][1] == 1 || dir[i][1] == -1) // si segment vertical Affect(RotKeyDir[k], RotKeyDir[k-1]); else Affect(RotKeyDir[k], dir[i]); Affect(RotKeyUp[k], RotKeyUp[0]); // Meme que précédement RotKeyTime[k] = PosKeyTime[k]; nRotKey = k; LastRotKey = 0; NextRotKey = 1; } }
////////////////////////////////// // Camera's position calculation ////////////////////////////////// void __fastcall Tunnel::CameraPosition( GLfloat t ) { GLfloat N[3]; GLfloat tmp[3], tmp2[3]; double r, teta; ////////////////// // Position keys ////////////////// if(t >= PosKeyTime[NextPosKey]) { if(NextPosKey == nPosKey) // fin d'animation : quite return(false); else { LastPosKey++; NextPosKey++; } } if(Compare(PosKeyDir[LastPosKey], PosKeyDir[NextPosKey])) { // Segment de droite r = (t - PosKeyTime[LastPosKey])/(PosKeyTime[NextPosKey] - PosKeyTime[LastPosKey]); Scal(tmp, (GLfloat) LSEG*r, PosKeyDir[LastPosKey]); Add(View, tmp, PosKey[LastPosKey]); } else { // Arc de cercle teta = M_PI_2 * (t - PosKeyTime[LastPosKey])/(PosKeyTime[NextPosKey] - PosKeyTime[LastPosKey]); Scal(tmp, (GLfloat) RSEG*sin(teta), PosKeyDir[LastPosKey]); Scal(tmp2, (GLfloat) -RSEG*cos(teta), PosKeyDir[NextPosKey]); Add(View, tmp, tmp2); Scal(tmp, (GLfloat) RSEG, PosKeyDir[NextPosKey]); Add(View, View, tmp); Add(View, View, PosKey[LastPosKey]); } ////////////////// // Rotation keys ////////////////// if(t >= RotKeyTime[NextRotKey]) { if(NextRotKey == nRotKey) // fin d'animation : quite return(false); else { LastRotKey++; NextRotKey++; } // Initialisations de keyframe au cas ou pas de rotation envisagée Affect(ViewDir, RotKeyDir[LastRotKey]); Affect(ViewUp, RotKeyUp[LastRotKey]); } r = (t - RotKeyTime[LastRotKey])/(RotKeyTime[NextRotKey] - RotKeyTime[LastRotKey]); if(! Compare(RotKeyUp[LastRotKey], RotKeyUp[NextRotKey])) Interpolate(ViewUp, r, RotKeyUp[LastRotKey], RotKeyUp[NextRotKey]); if(! Compare(RotKeyDir[LastRotKey], RotKeyDir[NextRotKey])) Interpolate(ViewDir, r, RotKeyDir[LastRotKey], RotKeyDir[NextRotKey]); #ifdef FPS_DEBUG frames++; if(frames >= 10) { char str[40]; sprintf(str, "Navigation 3D (%.2ffps)", 10000/(t-oldt)); fprintf(fdebug, "\n%.2ffps", 10000/(t-oldt)); // SetWindowText(GLwin.hWnd, str); oldt = t; frames = 0; } #endif // Calcule Ref à partir de viewdir Add(Ref, View, ViewDir); return(true); }
inline void internal::TrmmLUNC ( UnitOrNonUnit diag, T alpha, const DistMatrix<T,MC,MR>& U, DistMatrix<T,MC,MR>& X ) { #ifndef RELEASE PushCallStack("internal::TrmmLUNC"); if( U.Grid() != X.Grid() ) throw std::logic_error ("U and X must be distributed over the same grid"); if( U.Height() != U.Width() || U.Width() != X.Height() ) { std::ostringstream msg; msg << "Nonconformal TrmmLUN: \n" << " U ~ " << U.Height() << " x " << U.Width() << "\n" << " X ~ " << X.Height() << " x " << X.Width() << "\n"; throw std::logic_error( msg.str().c_str() ); } #endif const Grid& g = U.Grid(); // Matrix views DistMatrix<T,MC,MR> UTL(g), UTR(g), U00(g), U01(g), U02(g), UBL(g), UBR(g), U10(g), U11(g), U12(g), U20(g), U21(g), U22(g); DistMatrix<T,MC,MR> XT(g), X0(g), XB(g), X1(g), X2(g); // Temporary distributions DistMatrix<T,STAR,STAR> U11_STAR_STAR(g); DistMatrix<T,STAR,MC > U12_STAR_MC(g); DistMatrix<T,STAR,VR > X1_STAR_VR(g); DistMatrix<T,MR, STAR> D1Trans_MR_STAR(g); DistMatrix<T,MR, MC > D1Trans_MR_MC(g); DistMatrix<T,MC, MR > D1(g); // Start the algorithm Scal( alpha, X ); LockedPartitionDownDiagonal ( U, UTL, UTR, UBL, UBR, 0 ); PartitionDown ( X, XT, XB, 0 ); while( XB.Height() > 0 ) { LockedRepartitionDownDiagonal ( UTL, /**/ UTR, U00, /**/ U01, U02, /*************/ /******************/ /**/ U10, /**/ U11, U12, UBL, /**/ UBR, U20, /**/ U21, U22 ); RepartitionDown ( XT, X0, /**/ /**/ X1, XB, X2 ); U12_STAR_MC.AlignWith( X2 ); D1Trans_MR_STAR.AlignWith( X1 ); D1Trans_MR_MC.AlignWith( X1 ); D1.AlignWith( X1 ); D1Trans_MR_STAR.ResizeTo( X1.Width(), X1.Height() ); D1.ResizeTo( X1.Height(), X1.Width() ); //--------------------------------------------------------------------// X1_STAR_VR = X1; U11_STAR_STAR = U11; internal::LocalTrmm ( LEFT, UPPER, NORMAL, diag, (T)1, U11_STAR_STAR, X1_STAR_VR ); X1 = X1_STAR_VR; U12_STAR_MC = U12; internal::LocalGemm ( TRANSPOSE, TRANSPOSE, (T)1, X2, U12_STAR_MC, (T)0, D1Trans_MR_STAR ); D1Trans_MR_MC.SumScatterFrom( D1Trans_MR_STAR ); Transpose( D1Trans_MR_MC.LocalMatrix(), D1.LocalMatrix() ); Axpy( (T)1, D1, X1 ); //--------------------------------------------------------------------// D1.FreeAlignments(); D1Trans_MR_MC.FreeAlignments(); D1Trans_MR_STAR.FreeAlignments(); U12_STAR_MC.FreeAlignments(); SlideLockedPartitionDownDiagonal ( UTL, /**/ UTR, U00, U01, /**/ U02, /**/ U10, U11, /**/ U12, /*************/ /******************/ UBL, /**/ UBR, U20, U21, /**/ U22 ); SlidePartitionDown ( XT, X0, X1, /**/ /**/ XB, X2 ); } #ifndef RELEASE PopCallStack(); #endif }
inline void internal::SymmRUC ( T alpha, const DistMatrix<T,MC,MR>& A, const DistMatrix<T,MC,MR>& B, T beta, DistMatrix<T,MC,MR>& C ) { #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(); // Matrix views DistMatrix<T,MC,MR> 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,MC,MR> BL(g), BR(g), B0(g), B1(g), B2(g); DistMatrix<T,MC,MR> 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); // Start the algorithm Scal( 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 ); ARowPan.LockedView1x2( A11, A12 ); AColPan.LockedView2x1 ( A01, A11 ); CLeft.View1x2( C0, C1 ); CRight.View1x2( C1, C2 ); B1_MC_STAR.AlignWith( C ); 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 ); ARowPanTrans_MR_STAR.TransposeFrom( ARowPan ); MakeTrapezoidal( LEFT, LOWER, 0, ARowPanTrans_MR_STAR ); MakeTrapezoidal( RIGHT, LOWER, -1, AColPanTrans_STAR_MR ); internal::LocalGemm ( NORMAL, TRANSPOSE, alpha, B1_MC_STAR, ARowPanTrans_MR_STAR, (T)1, CRight ); internal::LocalGemm ( NORMAL, NORMAL, alpha, B1_MC_STAR, AColPanTrans_STAR_MR, (T)1, CLeft ); //--------------------------------------------------------------------// B1_MC_STAR.FreeAlignments(); 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 internal::HemmLLA ( T alpha, const DistMatrix<T,MC,MR>& A, const DistMatrix<T,MC,MR>& B, T beta, DistMatrix<T,MC,MR>& C ) { #ifndef RELEASE PushCallStack("internal::HemmLLA"); 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(); DistMatrix<T,MC,MR> BL(g), BR(g), B0(g), B1(g), B2(g); DistMatrix<T,MC,MR> CL(g), CR(g), C0(g), C1(g), C2(g); DistMatrix<T,MC,STAR> B1_MC_STAR(g); DistMatrix<T,VR,STAR> B1_VR_STAR(g); DistMatrix<T,STAR,MR> B1Adj_STAR_MR(g); DistMatrix<T,MC,MR > Z1(g); DistMatrix<T,MC,STAR> Z1_MC_STAR(g); DistMatrix<T,MR,STAR> Z1_MR_STAR(g); DistMatrix<T,MR,MC > Z1_MR_MC(g); Scal( beta, C ); LockedPartitionRight ( B, BL, BR, 0 ); PartitionRight ( C, CL, CR, 0 ); while( CL.Width() < C.Width() ) { LockedRepartitionRight ( BL, /**/ BR, B0, /**/ B1, B2 ); RepartitionRight ( CL, /**/ CR, C0, /**/ C1, C2 ); B1_MC_STAR.AlignWith( A ); B1_VR_STAR.AlignWith( A ); B1Adj_STAR_MR.AlignWith( A ); Z1_MC_STAR.AlignWith( A ); Z1_MR_STAR.AlignWith( A ); Z1.AlignWith( C1 ); Z1_MC_STAR.ResizeTo( C1.Height(), C1.Width() ); Z1_MR_STAR.ResizeTo( C1.Height(), C1.Width() ); //--------------------------------------------------------------------// B1_MC_STAR = B1; B1_VR_STAR = B1_MC_STAR; B1Adj_STAR_MR.AdjointFrom( B1_VR_STAR ); Zero( Z1_MC_STAR ); Zero( Z1_MR_STAR ); internal::LocalSymmetricAccumulateLL ( ADJOINT, alpha, A, B1_MC_STAR, B1Adj_STAR_MR, Z1_MC_STAR, Z1_MR_STAR ); Z1_MR_MC.SumScatterFrom( Z1_MR_STAR ); Z1 = Z1_MR_MC; Z1.SumScatterUpdate( (T)1, Z1_MC_STAR ); Axpy( (T)1, Z1, C1 ); //--------------------------------------------------------------------// B1_MC_STAR.FreeAlignments(); B1_VR_STAR.FreeAlignments(); B1Adj_STAR_MR.FreeAlignments(); Z1_MC_STAR.FreeAlignments(); Z1_MR_STAR.FreeAlignments(); Z1.FreeAlignments(); SlideLockedPartitionRight ( BL, /**/ BR, B0, B1, /**/ B2 ); SlidePartitionRight ( CL, /**/ CR, C0, C1, /**/ C2 ); } #ifndef RELEASE PopCallStack(); #endif }
inline void internal::PanelLU ( DistMatrix<F, STAR,STAR>& A, DistMatrix<F, MC, STAR>& B, DistMatrix<int,STAR,STAR>& p, int pivotOffset ) { #ifndef RELEASE PushCallStack("internal::PanelLU"); if( A.Grid() != p.Grid() || p.Grid() != B.Grid() ) throw std::logic_error ("Matrices must be distributed over the same grid"); if( A.Width() != B.Width() ) throw std::logic_error("A and B must be the same width"); if( A.Height() != p.Height() || p.Width() != 1 ) throw std::logic_error("p must be a vector that conforms with A"); #endif const Grid& g = A.Grid(); const int r = g.Height(); const int colShift = B.ColShift(); const int colAlignment = B.ColAlignment(); // Matrix views DistMatrix<F,STAR,STAR> ATL(g), ATR(g), A00(g), a01(g), A02(g), ABL(g), ABR(g), a10(g), alpha11(g), a12(g), A20(g), a21(g), A22(g); DistMatrix<F,MC,STAR> BL(g), BR(g), B0(g), b1(g), B2(g); DistMatrix<int,STAR,STAR> pT(g), p0(g), pB(g), psi1(g), p2(g); const int width = A.Width(); const int numBytes = (width+1)*sizeof(F)+sizeof(int); std::vector<byte> sendData(numBytes); std::vector<byte> recvData(numBytes); // Extract pointers to send and recv data F* sendBufFloat = (F*) &sendData[0]; F* recvBufFloat = (F*) &recvData[0]; int* sendBufInt = (int*) &sendData[(width+1)*sizeof(F)]; int* recvBufInt = (int*) &recvData[(width+1)*sizeof(F)]; // Start the algorithm PushBlocksizeStack( 1 ); PartitionDownDiagonal ( A, ATL, ATR, ABL, ABR, 0 ); PartitionRight( B, BL, BR, 0 ); PartitionDown ( p, pT, pB, 0 ); while( ATL.Height() < A.Height() ) { RepartitionDownDiagonal ( ATL, /**/ ATR, A00, /**/ a01, A02, /*************/ /**********************/ /**/ a10, /**/ alpha11, a12, ABL, /**/ ABR, A20, /**/ a21, A22 ); RepartitionRight ( BL, /**/ BR, B0, /**/ b1, B2 ); RepartitionDown ( pT, p0, /**/ /****/ psi1, pB, p2 ); //--------------------------------------------------------------------// // Store the index/value of the pivot candidate in A F pivotValue = alpha11.GetLocalEntry(0,0); int pivotIndex = a01.Height(); for( int i=0; i<a21.Height(); ++i ) { F value = a21.GetLocalEntry(i,0); if( FastAbs(value) > FastAbs(pivotValue) ) { pivotValue = value; pivotIndex = a01.Height() + i + 1; } } // Update the pivot candidate to include local data from B for( int i=0; i<B.LocalHeight(); ++i ) { F value = b1.GetLocalEntry(i,0); if( FastAbs(value) > FastAbs(pivotValue) ) { pivotValue = value; pivotIndex = A.Height() + colShift + i*r; } } // Fill the send buffer with: // [ pivotValue | pivotRow | pivotIndex ] if( pivotIndex < A.Height() ) { sendBufFloat[0] = A.GetLocalEntry(pivotIndex,a10.Width()); const int ALDim = A.LocalLDim(); const F* ABuffer = A.LocalBuffer(pivotIndex,0); for( int j=0; j<width; ++j ) sendBufFloat[j+1] = ABuffer[j*ALDim]; } else { const int localIndex = ((pivotIndex-A.Height())-colShift)/r; sendBufFloat[0] = b1.GetLocalEntry(localIndex,0); const int BLDim = B.LocalLDim(); const F* BBuffer = B.LocalBuffer(localIndex,0); for( int j=0; j<width; ++j ) sendBufFloat[j+1] = BBuffer[j*BLDim]; } *sendBufInt = pivotIndex; // Communicate to establish the pivot information mpi::AllReduce ( &sendData[0], &recvData[0], numBytes, PivotOp<F>(), g.ColComm() ); // Update the pivot vector const int maxIndex = *recvBufInt; p.SetLocalEntry(a01.Height(),0,maxIndex+pivotOffset); // Copy the current row into the pivot row if( maxIndex < A.Height() ) { const int ALDim = A.LocalLDim(); F* ASetBuffer = A.LocalBuffer(maxIndex,0); const F* AGetBuffer = A.LocalBuffer(A00.Height(),0); for( int j=0; j<width; ++j ) ASetBuffer[j*ALDim] = AGetBuffer[j*ALDim]; } else { const int ownerRank = (colAlignment+(maxIndex-A.Height())) % r; if( g.Row() == ownerRank ) { const int localIndex = ((maxIndex-A.Height())-colShift) / r; const int ALDim = A.LocalLDim(); const int BLDim = B.LocalLDim(); F* BBuffer = B.LocalBuffer(localIndex,0); const F* ABuffer = A.LocalBuffer(A00.Height(),0); for( int j=0; j<width; ++j ) BBuffer[j*BLDim] = ABuffer[j*ALDim]; } } // Copy the pivot row into the current row { F* ABuffer = A.LocalBuffer(A00.Height(),0); const int ALDim = A.LocalLDim(); for( int j=0; j<width; ++j ) ABuffer[j*ALDim] = recvBufFloat[j+1]; } // Now we can perform the update of the current panel F alpha = alpha11.GetLocalEntry(0,0); if( alpha == (F)0 ) throw SingularMatrixException(); F alpha11Inv = ((F)1) / alpha; Scal( alpha11Inv, a21.LocalMatrix() ); Scal( alpha11Inv, b1.LocalMatrix() ); Geru( (F)-1, a21.LocalMatrix(), a12.LocalMatrix(), A22.LocalMatrix() ); Geru( (F)-1, b1.LocalMatrix(), a12.LocalMatrix(), B2.LocalMatrix() ); //--------------------------------------------------------------------// SlidePartitionDownDiagonal ( ATL, /**/ ATR, A00, a01, /**/ A02, /**/ a10, alpha11, /**/ a12, /*************/ /**********************/ ABL, /**/ ABR, A20, a21, /**/ A22 ); SlidePartitionRight ( BL, /**/ BR, B0, b1, /**/ B2 ); SlidePartitionDown ( pT, p0, psi1, /**/ /****/ pB, p2 ); } PopBlocksizeStack(); #ifndef RELEASE PopCallStack(); #endif }
inline void internal::SymmRUA ( T alpha, const DistMatrix<T,MC,MR>& A, const DistMatrix<T,MC,MR>& B, T beta, DistMatrix<T,MC,MR>& C ) { #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(); DistMatrix<T,MC,MR> BT(g), B0(g), BB(g), B1(g), B2(g); DistMatrix<T,MC,MR> 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); Matrix<T> Z1Local; Scal( 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 ); 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 ); Z1Trans_MR_MC.AlignWith( C1 ); Z1Trans_MC_STAR.ResizeTo( C1.Width(), C1.Height() ); Z1Trans_MR_STAR.ResizeTo( C1.Width(), C1.Height() ); //--------------------------------------------------------------------// B1Trans_MR_STAR.TransposeFrom( B1 ); B1Trans_VC_STAR = B1Trans_MR_STAR; B1_STAR_MC.TransposeFrom( B1Trans_VC_STAR ); Zero( Z1Trans_MC_STAR ); Zero( Z1Trans_MR_STAR ); internal::LocalSymmetricAccumulateRU ( TRANSPOSE, 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.LockedLocalMatrix(), Z1Local ); Axpy( (T)1, Z1Local, C1.LocalMatrix() ); //--------------------------------------------------------------------// B1Trans_MR_STAR.FreeAlignments(); B1Trans_VC_STAR.FreeAlignments(); B1_STAR_MC.FreeAlignments(); Z1Trans_MC_STAR.FreeAlignments(); Z1Trans_MR_STAR.FreeAlignments(); Z1Trans_MR_MC.FreeAlignments(); SlideLockedPartitionDown ( BT, B0, B1, /**/ /**/ BB, B2 ); SlidePartitionDown ( CT, C0, C1, /**/ /**/ CB, C2 ); } #ifndef RELEASE PopCallStack(); #endif }