Elemental 0.78-p1 documentation

Repartitioning

«  Partitioning   ::   Contents   ::   Sliding partitions  »

Repartitioning

RepartitionUp

Given the partition

\[\begin{split}A = \left(\begin{array}{c} A_T \\ \hline A_B \end{array}\right),\end{split}\]

and a blocksize, \(n_b\), turn the two-way partition into the three-way partition

\[\begin{split}\left(\begin{array}{c} A_T \\ \hline A_B \end{array}\right) = \left(\begin{array}{c} A_0 \\ A_1 \\ \hline A_2 \end{array}\right),\end{split}\]

where \(A_1\) is of height \(n_b\) and \(A_2 = A_B\).

void RepartitionUp( Matrix<T>& AT, Matrix<T>& A0, Matrix<T>& A1, Matrix<T>& AB, Matrix<T>& A2, int bsize=Blocksize() )
void LockedRepartitionUp( const Matrix<T>& AT, Matrix<T>& A0, Matrix<T>& A1, const Matrix<T>& AB, Matrix<T>& A2, int bsize=Blocksize() )

Templated over the datatype, T.

void RepartitionUp( DistMatrix<T,U,V>& AT, DistMatrix<T,U,V>& A0, DistMatrix<T,U,V>& A1, DistMatrix<T,U,V>& AB, DistMatrix<T,U,V>& A2, int bsize=Blocksize() )
void LockedRepartitionUp( const DistMatrix<T,U,V>& AT, DistMatrix<T,U,V>& A0, DistMatrix<T,U,V>& A1, const DistMatrix<T,U,V>& AB, DistMatrix<T,U,V>& A2, int bsize=Blocksize() )

Templated over the datatype, T, and distribution scheme, (U,V).

Note that each of the above routines is meant to be used in a manner similar to the following:

RepartitionUp( AT,  A0,
                    A1,
              /**/ /**/
               AB,  A2, blocksize );

RepartitionDown

Given the partition

\[\begin{split}A = \left(\begin{array}{c} A_T \\ \hline A_B \end{array}\right),\end{split}\]

and a blocksize, \(n_b\), turn the two-way partition into the three-way partition

\[\begin{split}\left(\begin{array}{c} A_T \\ \hline A_B \end{array}\right) = \left(\begin{array}{c} A_0 \\ \hline A_1 \\ A_2 \end{array}\right),\end{split}\]

where \(A_1\) is of height \(n_b\) and \(A_0 = A_T\).

void RepartitionDown( Matrix<T>& AT, Matrix<T>& A0, Matrix<T>& A1, Matrix<T>& AB, Matrix<T>& A2, int bsize=Blocksize() )
void LockedRepartitionDown( const Matrix<T>& AT, Matrix<T>& A0, Matrix<T>& A1, const Matrix<T>& AB, Matrix<T>& A2, int bsize=Blocksize() )

Templated over the datatype, T.

void RepartitionDown( DistMatrix<T,U,V>& AT, DistMatrix<T,U,V>& A0, DistMatrix<T,U,V>& A1, DistMatrix<T,U,V>& AB, DistMatrix<T,U,V>& A2, int bsize=Blocksize() )
void LockedRepartitionDown( const DistMatrix<T,U,V>& AT, DistMatrix<T,U,V>& A0, DistMatrix<T,U,V>& A1, const DistMatrix<T,U,V>& AB, DistMatrix<T,U,V>& A2, int bsize=Blocksize() )

Templated over the datatype, T, and distribution scheme, (U,V).

Note that each of the above routines is meant to be used in a manner similar to the following:

RepartitionDown( AT,  A0,
                /**/ /**/
                      A1,
                 AB,  A2, blocksize );

RepartitionLeft

Given the partition

\[\begin{split}A = \left(\begin{array}{c|c} A_L & A_R \end{array}\right),\end{split}\]

and a blocksize, \(n_b\), turn the two-way partition into the three-way partition

\[\begin{split}\left(\begin{array}{c|c} A_L & A_R \end{array}\right) = \left(\begin{array}{cc|c} A_0 & A_1 & A_2 \end{array}\right),\end{split}\]

where \(A_1\) is of width \(n_b\) and \(A_2=A_R\).

void RepartitionLeft( Matrix<T>& AL, Matrix<T>& AR, Matrix<T>& A0, Matrix<T>& A1, Matrix<T>& A2, int bsize=Blocksize() )
void LockedRepartitionLeft( const Matrix<T>& AL, const Matrix<T>& AR, Matrix<T>& A0, Matrix<T>& A1, Matrix<T>& A2, int bsize=Blocksize() )

Templated over the datatype, T.

void RepartitionLeft( DistMatrix<T,U,V>& AL, DistMatrix<T,U,V>& AR, DistMatrix<T,U,V>& A0, DistMatrix<T,U,V>& A1, DistMatrix<T,U,V>& A2, int bsize=Blocksize() )
void LockedRepartitionLeft( const DistMatrix<T,U,V>& AL, const DistMatrix<T,U,V>& AR, DistMatrix<T,U,V>& A0, DistMatrix<T,U,V>& A1, DistMatrix<T,U,V>& A2, int bsize=Blocksize() )

Templated over the datatype, T, and distribution scheme, (U,V).

Note that each of the above routines is meant to be used in a manner similar to the following:

RepartitionLeft( AL,     /**/ AR,
                 A0, A1, /**/ A2, blocksize );

RepartitionRight

Given the partition

\[\begin{split}A = \left(\begin{array}{c|c} A_L & A_R \end{array}\right),\end{split}\]

and a blocksize, \(n_b\), turn the two-way partition into the three-way partition

\[\begin{split}\left(\begin{array}{c|c} A_L & A_R \end{array}\right) = \left(\begin{array}{c|cc} A_0 & A_1 & A_2 \end{array}\right),\end{split}\]

where \(A_1\) is of width \(n_b\) and \(A_0=A_L\).

void RepartitionRight( Matrix<T>& AL, Matrix<T>& AR, Matrix<T>& A0, Matrix<T>& A1, Matrix<T>& A2, int bsize=Blocksize() )
void LockedRepartitionRight( const Matrix<T>& AL, const Matrix<T>& AR, Matrix<T>& A0, Matrix<T>& A1, Matrix<T>& A2, int bsize=Blocksize() )

Templated over the datatype, T.

void RepartitionRight( DistMatrix<T,U,V>& AL, DistMatrix<T,U,V>& AR, DistMatrix<T,U,V>& A0, DistMatrix<T,U,V>& A1, DistMatrix<T,U,V>& A2, int bsize=Blocksize() )
void LockedRepartitionRight( const DistMatrix<T,U,V>& AL, const DistMatrix<T,U,V>& AR, DistMatrix<T,U,V>& A0, DistMatrix<T,U,V>& A1, DistMatrix<T,U,V>& A2, int bsize=Blocksize() )

Templated over the datatype, T, and distribution scheme, (U,V).

Note that each of the above routines is meant to be used in a manner similar to the following:

RepartitionRight( AL, /**/ AR,
                  A0, /**/ A1, A2, blocksize );

RepartitionUpDiagonal

Given the partition

\[\begin{split}A = \left(\begin{array}{c|c} A_{TL} & A_{TR} \\ \hline A_{BL} & A_{BR} \end{array}\right),\end{split}\]

turn the two-by-two partition into the three-by-three partition

\[\begin{split}\left(\begin{array}{c|c} A_{TL} & A_{TR} \\ \hline A_{BL} & A_{BR} \end{array}\right) = \left(\begin{array}{cc|c} A_{00} & A_{01} & A_{02} \\ A_{10} & A_{11} & A_{12} \\ \hline A_{20} & A_{21} & A_{22} \end{array}\right),\end{split}\]

where \(A_{11}\) is \(n_b \times n_b\) and the corresponding quadrants are equivalent.

void RepartitionUpDiagonal( Matrix<T>& ATL, Matrix<T>& ATR, Matrix<T>& A00, Matrix<T>& A01, Matrix<T>& A02, Matrix<T>& A10, Matrix<T>& A11, Matrix<T>& A12, Matrix<T>& ABL, Matrix<T>& ABR, Matrix<T>& A20, Matrix<T>& A21, Matrix<T>& A22, int bsize=Blocksize() )
void LockedRepartitionUpDiagonal( const Matrix<T>& ATL, const Matrix<T>& ATR, Matrix<T>& A00, Matrix<T>& A01, Matrix<T>& A02, Matrix<T>& A10, Matrix<T>& A11, Matrix<T>& A12, const Matrix<T>& ABL, const Matrix<T>& ABR, Matrix<T>& A20, Matrix<T>& A21, Matrix<T>& A22, int bsize=Blocksize() )

Templated over the datatype, T.

void RepartitionUpDiagonal( DistMatrix<T,U,V>& ATL, DistMatrix<T,U,V>& ATR, DistMatrix<T,U,V>& A00, DistMatrix<T,U,V>& A01, DistMatrix<T,U,V>& A02, DistMatrix<T,U,V>& A10, DistMatrix<T,U,V>& A11, DistMatrix<T,U,V>& A12, DistMatrix<T,U,V>& ABL, DistMatrix<T,U,V>& ABR, DistMatrix<T,U,V>& A20, DistMatrix<T,U,V>& A21, DistMatrix<T,U,V>& A22, int bsize=Blocksize() )
void LockedRepartitionUpDiagonal( const DistMatrix<T,U,V>& ATL, const DistMatrix<T,U,V>& ATR, DistMatrix<T,U,V>& A00, DistMatrix<T,U,V>& A01, DistMatrix<T,U,V>& A02, DistMatrix<T,U,V>& A10, DistMatrix<T,U,V>& A11, DistMatrix<T,U,V>& A12, const DistMatrix<T,U,V>& ABL, const DistMatrix<T,U,V>& ABR, DistMatrix<T,U,V>& A20, DistMatrix<T,U,V>& A21, DistMatrix<T,U,V>& A22, int bsize=Blocksize() )

Templated over the datatype, T, and distribution scheme, (U,V).

Note that each of the above routines is meant to be used in a manner similar to the following:

RepartitionUpDiagonal( ATL, /**/ ATR,  A00, A01, /**/ A02,
                            /**/       A10, A11, /**/ A12,
                      /*************/ /******************/
                       ABL, /**/ ABR,  A20, A21, /**/ A22, blocksize );

RepartitionDownDiagonal

Given the partition

\[\begin{split}A = \left(\begin{array}{c|c} A_{TL} & A_{TR} \\ \hline A_{BL} & A_{BR} \end{array}\right),\end{split}\]

turn the two-by-two partition into the three-by-three partition

\[\begin{split}\left(\begin{array}{c|c} A_{TL} & A_{TR} \\ \hline A_{BL} & A_{BR} \end{array}\right) = \left(\begin{array}{c|cc} A_{00} & A_{01} & A_{02} \\ \hline A_{10} & A_{11} & A_{12} \\ A_{20} & A_{21} & A_{22} \end{array}\right),\end{split}\]

where \(A_{11}\) is \(n_b \times n_b\) and the corresponding quadrants are equivalent.

void RepartitionDownDiagonal( Matrix<T>& ATL, Matrix<T>& ATR, Matrix<T>& A00, Matrix<T>& A01, Matrix<T>& A02, Matrix<T>& A10, Matrix<T>& A11, Matrix<T>& A12, Matrix<T>& ABL, Matrix<T>& ABR, Matrix<T>& A20, Matrix<T>& A21, Matrix<T>& A22, int bsize=Blocksize() )
void LockedRepartitionDownDiagonal( const Matrix<T>& ATL, const Matrix<T>& ATR, Matrix<T>& A00, Matrix<T>& A01, Matrix<T>& A02, Matrix<T>& A10, Matrix<T>& A11, Matrix<T>& A12, const Matrix<T>& ABL, const Matrix<T>& ABR, Matrix<T>& A20, Matrix<T>& A21, Matrix<T>& A22, int bsize=Blocksize() )

Templated over the datatype, T.

void RepartitionDownDiagonal( DistMatrix<T,U,V>& ATL, DistMatrix<T,U,V>& ATR, DistMatrix<T,U,V>& A00, DistMatrix<T,U,V>& A01, DistMatrix<T,U,V>& A02, DistMatrix<T,U,V>& A10, DistMatrix<T,U,V>& A11, DistMatrix<T,U,V>& A12, DistMatrix<T,U,V>& ABL, DistMatrix<T,U,V>& ABR, DistMatrix<T,U,V>& A20, DistMatrix<T,U,V>& A21, DistMatrix<T,U,V>& A22, int bsize=Blocksize() )
void LockedRepartitionDownDiagonal( const DistMatrix<T,U,V>& ATL, const DistMatrix<T,U,V>& ATR, DistMatrix<T,U,V>& A00, DistMatrix<T,U,V>& A01, DistMatrix<T,U,V>& A02, DistMatrix<T,U,V>& A10, DistMatrix<T,U,V>& A11, DistMatrix<T,U,V>& A12, const DistMatrix<T,U,V>& ABL, const DistMatrix<T,U,V>& ABR, DistMatrix<T,U,V>& A20, DistMatrix<T,U,V>& A21, DistMatrix<T,U,V>& A22, int bsize=Blocksize() )

Templated over the datatype, T, and distribution scheme, (U,V).

Note that each of the above routines is meant to be used in a manner similar to the following:

RepartitionDownDiagonal( ATL, /**/ ATR,  A00, /**/ A01, A02,
                        /*************/ /******************/
                              /**/       A10, /**/ A11, A12,
                         ABL, /**/ ABR,  A20, /**/ A21, A22, blocksize );

«  Partitioning   ::   Contents   ::   Sliding partitions  »