matrix_skeletons Class Reference

Collection of skeletons on matricies(two-dimensional arrays). More...

#include <matrix_skeletons.h>

List of all members.

Static Public Member Functions
static int	setDistributionPolicy (int p)
	Set the distribution policy.
static int	getDistributionPolicy ()
	Return the distribution policy.
static void	calcDivision (int &r, int &c, const SKEL_MPI_INTRACOMM &com)
	Calculate divisions (r, c) according to the policy.
template<typename A, typename F>
static void	map_i (const F &f, dist_matrix< A > *mat)
	The map skeleton (inplace).
template<typename B, typename A, typename F>
static void	map (const F &f, const dist_matrix< A > *mat, dist_matrix< B > *dmb)
	The map skeleton.
template<typename A, typename F>
static dist_matrix< typename F::result_type > *	map (const F &f, const dist_matrix< A > *mat)
	The map skeleton(crates a new matrix).
template<typename C, typename A, typename B, typename F>
static void	zipwith (const F &f, const dist_matrix< A > *dma, const dist_matrix< B > *dmb, dist_matrix< C > *dmc)
	The zipwith skeleton(crates a new matrix).
template<typename A, typename B, typename F>
static dist_matrix< typename F::result_type > *	zipwith (const F &f, const dist_matrix< A > *dma, const dist_matrix< B > *dmb)
	The zipwith skeleton(creates a new matrix).
template<typename A, typename B>
static dist_matrix< std::pair< A, B > > *	zip (const dist_matrix< A > *dma, const dist_matrix< B > *dmb)
	The zip skeleton which is a specialization of zipwith.
template<typename A, typename F, typename G>
static void	reduceB (const F &oplus, const G &otimes, const dist_matrix< A > *mat, A *res)
	The reduce with broadcast.
template<typename A, typename F, typename G>
static A *	reduceB (const F &oplus, const G &otimes, const dist_matrix< A > *mat)
	The reduce with broadcast.
template<typename A, typename F, typename G>
static void	reduce (const F &oplus, const G &otimes, const dist_matrix< A > *mat, A *res)
	The reduce skeleton.
template<typename A, typename F, typename G>
static A *	reduce (const F &oplus, const G &otimes, const dist_matrix< A > *mat)
	The reduce skeleton (create new value).
template<typename A, typename F, typename G>
static void	reduceDC (const F &oplus, const G &otimes, const dist_matrix< A > *mat, A *res)
	The reduce skeleton(with divide and conquer local computation).
template<typename A, typename F, typename G>
static A *	reduceDC (const F &oplus, const G &otimes, const dist_matrix< A > *mat)
	The reduce skeleton (create new value, with divide and conquer local computation).
template<typename A, typename F, typename G>
static void	reduceDCN (const F &oplus, const G &otimes, const dist_matrix< A > *mat, A *res)
	The reduce skeleton(with divide and conquer local computation, nested parallelism).
template<typename A, typename F, typename G>
static A *	reduceDCN (const F &oplus, const G &otimes, const dist_matrix< A > *mat)
	The reduce skeleton (create new value, with divide and conquer local computation, nested parallelism).
template<typename A, typename F, typename G>
static void	reduceDCN2 (const F &oplus, const G &otimes, const dist_matrix< A > *mat, A *res)
	The reduce skeleton(with divide and conquer local computation, nested parallelism, broadcasting operands for each operator).
template<typename A, typename F, typename G>
static A *	reduceDCN2 (const F &oplus, const G &otimes, const dist_matrix< A > *mat)
	The reduce skeleton (create new value, with divide and conquer local computation, nested parallelism, broadcasting operands for each operator).
template<typename A, typename F, typename G, typename H>
static void	cata (const F &oplus, const G &otimes, const H &f, const dist_matrix< A > *mat, typename H::result_type *res)
	The cata skeleton.
template<typename A, typename F, typename G, typename H>
static H::result_type *	cata (const F &oplus, const G &otimes, const H &f, const dist_matrix< A > *mat)
	The cata skeleton (create new value).
template<typename A, typename F, typename G, typename H>
static void	cataDCN2 (const F &oplus, const G &otimes, const H &f, const dist_matrix< A > *mat, typename H::result_type *res)
	The cata skeleton(with divide and conquer local computation, nested parallelism, broadcasting operands for each operator).
template<typename A, typename F, typename G, typename H>
static H::result_type *	cataDCN2 (const F &oplus, const G &otimes, const H &f, const dist_matrix< A > *mat)
	The cata skeleton (create new value, with divide and conquer local computation, nested parallelism, broadcasting operands for each operator).
template<typename A, typename F, typename G>
static void	scan (const F &oplus, const G &otimes, const dist_matrix< A > *dma, dist_matrix< A > *dmb)
	The scan skeleton.
template<typename A, typename F, typename G>
static dist_matrix< A > *	scan (const F &oplus, const G &otimes, const dist_matrix< A > *dma)
	The scan skeleton.
template<typename A, typename F, typename G>
static void	scanr (const F &oplus, const G &otimes, const dist_matrix< A > *dma, dist_matrix< A > *dmb)
	The reverse-scan skeleton.
template<typename A, typename F, typename G>
static dist_matrix< A > *	scanr (const F &oplus, const G &otimes, const dist_matrix< A > *dma)
	The reverse-scan skeleton.
template<typename A>
static dist_matrix< matrix< A > > *	all_rows (const dist_matrix< A > *mat)
	A specialization of allreduce_row: all_rows.
template<typename A>
static dist_matrix< matrix< A > > *	all_cols (const dist_matrix< A > *mat)
	A specialization of allreduce_col: all_cols.
template<typename A, typename F>
static dist_matrix< A > *	allreduce_row (const F &otimes, const dist_matrix< A > *mat)
	A specialization of reduce: allreduce_row.
template<typename A, typename F>
static dist_matrix< A > *	allreduce_col (const F &oplus, const dist_matrix< A > *mat)
	A specialization of reduce: allreduce_col.
template<typename A, typename OP2, typename OT2, typename P, typename OP, typename OT, typename Q>
static void	acc (const OP2 &oplus2, const OT2 &otimes2, const P &p, const OP &oplus, const OT &otimes, const Q &q, const dist_matrix< A > *dma, typename P::result_type *res)
template<typename A, typename OP2, typename OT2, typename P, typename OP, typename OT, typename Q>
static P::result_type *	acc (const OP2 &oplus2, const OT2 &otimes2, const P &p, const OP &oplus, const OT &otimes, const Q &q, const dist_matrix< A > *dma)
template<typename A, typename F, typename G>
static void	scan2 (const F &oplus, const G &otimes, const dist_matrix< A > *dma, dist_matrix< A > *dmb)
template<typename A, typename F, typename G>
static dist_matrix< A > *	scan2 (const F &oplus, const G &otimes, const dist_matrix< A > *dma)
template<typename A>
static void	rotateRowsConst (int s, dist_matrix< A > *mat)
	Rotate row-blocks by s.
template<typename A, typename F>
static void	rotateRows (const F &f, dist_matrix< A > *mat)
	Rotate row-blocks by f(col-position).
template<typename A>
static void	rotateColsConst (int s, dist_matrix< A > *mat)
	Rotate column-blocks by s.
template<typename A, typename F>
static void	rotateCols (const F &f, dist_matrix< A > *mat)
	Rotate column-blocks by f(row-position).
Static Public Attributes
static int	distributionPolicy = matrix_skeletons::DPOLICY_RECTANGLE
	Policy of implicit distribution by constructors.
static const int	DPOLICY_RECTANGLE = 0
	Distribute policy RECTANGLE. Using all processors to distribute the matrix. Distributed matrix can be seen as a (r, c) matrix of matrices. r*c = processors, where r is division in row-direction, and c is division in column-direction.
static const int	DPOLICY_SQUARE = 1
	Distribute policy SQUARE. The matrix is distributed symmetrically in row- and column-direction. Distributed matrix can be seen as a (r, r) square matrix of matrices. r*r =< processors, where r is division in each-direction and (r+1) * (r+1) > processors.
static const int	DPOLICY_ROW = 2
	Distribute policy ROW. The matrix is distributed in row-direction. Distributed matrix can be seen as a (r, 1) matrix (vector) of matrices. r = processors, where r is division in row-direction.
static const int	DPOLICY_COLUMN = 3
	Distribute policy COLUMN. The matrix is distributed in column-direction. Distributed matrix can be seen as a (1, c) matrix (vector) of matrices. c = processors, where c is division in column-direction.
Classes
class	Mkpair
	A function object making a pair (fst, snd).

---

Detailed Description

Collection of skeletons on matricies(two-dimensional arrays).

This implementation is parallel, distributed.

Definition at line 70 of file matrix_skeletons.h.

---

Member Function Documentation

template<typename A, typename OP2, typename OT2, typename P, typename OP, typename OT, typename Q> static P::result_type* matrix_skeletons::acc (  const OP2 &  oplus2, const OT2 &  otimes2, const P &  p, const OP &  oplus, const OT &  otimes, const Q &  q, const dist_matrix< A > *  dma )  [static]

template<typename A, typename OP2, typename OT2, typename P, typename OP, typename OT, typename Q> static void matrix_skeletons::acc (  const OP2 &  oplus2, const OT2 &  otimes2, const P &  p, const OP &  oplus, const OT &  otimes, const Q &  q, const dist_matrix< A > *  dma, typename P::result_type *  res )  [static]

accumulate skeleton prototypes

template<typename A> static dist_matrix< matrix< A > >* matrix_skeletons::all_cols (  const dist_matrix< A > *  mat  )  [static]

A specialization of allreduce_col: all_cols. Resulting matrix consists of columns of the matrix mat. i.e. each element in a col of the matrix is corresponding col of this matrix. Definition (in Haskell) allcols :: Matrix a -> Matrix (Matrix a) allcols = allreduce_col (Abv) . map Sing Sample: < Haskell code > m2 = allcols m1 < C++ code > m2 = matrix_skeletons::allcols( m1 ); Parameters: mat  a matrix. Returns: a matrix consisting of columns of the matrix mat. See also: matrix_skeletons::allreduce_col(const F &, const dist_matrix<A> *)

template<typename A> static dist_matrix< matrix< A > >* matrix_skeletons::all_rows (  const dist_matrix< A > *  mat  )  [static]

A specialization of allreduce_row: all_rows. Resulting matrix consists of rows of the matrix mat. i.e. each element in a row of the matrix is corresponding row of this matrix. Definition (in Haskell) allrows :: Matrix a -> Matrix (Matrix a) allrows = allreduce_row (Bsd) . map Sing Sample: < Haskell code > m2 = allrows m1 < C++ code > m2 = matrix_skeletons::allrows( m1 ); Parameters: mat  a matrix. Returns: a matrix consisting of rows of the matrix mat. See also: matrix_skeletons::allreduce_row(const F &, const dist_matrix<A> *)

template<typename A, typename F> static dist_matrix< A >* matrix_skeletons::allreduce_col (  const F &  oplus, const dist_matrix< A > *  mat )  [static]

A specialization of reduce: allreduce_col. This reduces the matrix in column-direction only and broadcasts the result in each column. So almost all elements are shadows of first row. Please be careful with modifing the elements. Definition (in Haskell) allreduce_col :: (a -> a -> a) -> Matrix a -> Matrix a allreduce_col oplus = scanr (rr, ll) . scan (oplus, rr) where ll a b = a rr a b = b Sample: < Haskell code > m2 = allreduce_col (+) m1 < C++ code > m2 = matrix_skeletons::allreduce_col( Add(), m1 ); Parameters: oplus  a function taking two arguments x and y, returning result z, i.e. z = x oplus y. oplus should have the member void operator()(const A&, const A&, A*) const. The function object oplus should inherit skeleton::binary_function. oplus should be associative. mat  a matrix to be reduced. Returns: The resulting matrix in which the elements in a column have the same value, the result of reducing the column with oplus. See also: matrix_skeletons::reduce(const F &, const G &, const dist_matrix<A> *) matrix_skeletons::scan(const F &, const G &, const dist_matrix<A> *) matrix_skeletons::scanr(const F &, const G &, const dist_matrix<A> *) m_skeletons::allreduce_col(const F &, const matrix<A> *)

template<typename A, typename F> static dist_matrix< A >* matrix_skeletons::allreduce_row (  const F &  otimes, const dist_matrix< A > *  mat )  [static]

A specialization of reduce: allreduce_row. This reduces the matrix in row-direction only and broadcasts the result in each row. So almost all elements are shadows of first column. Please be careful with modifing the elements. Definition (in Haskell) allreduce_row :: (a -> a -> a) -> Matrix a -> Matrix a allreduce_row otimes = scanr (ll, rr) . scan (rr, otimes) where ll a b = a rr a b = b Sample: < Haskell code > m2 = allreduce_row (+) m1 < C++ code > m2 = matrix_skeletons::allreduce_row( Add(), m1 ); Parameters: otimes  a function taking two arguments x and y, returning result z, i.e. z = x otimes y. otimes should have the member void operator()(const A&, const A&, A*) const. The function object otimes should inherit skeleton::binary_function. otimes should be associative. mat  a matrix to be reduced. Returns: The resulting matrix in which the elements in a row have the same value, the result of reducing the row with otimes. See also: matrix_skeletons::reduce(const F &, const G &, const dist_matrix<A> *) matrix_skeletons::scan(const F &, const G &, const dist_matrix<A> *) matrix_skeletons::scanr(const F &, const G &, const dist_matrix<A> *) m_skeletons::allreduce_row(const F &, const matrix<A> *)

void matrix_skeletons::calcDivision (  int &  r, int &  c, const SKEL_MPI_INTRACOMM &  com )  [static]

Calculate divisions (r, c) according to the policy. Parameters: r  row-division c  col-division com  the communicator Definition at line 98 of file sketo.cpp. References distributionPolicy, DPOLICY_COLUMN, DPOLICY_RECTANGLE, DPOLICY_ROW, DPOLICY_SQUARE, and SKEL_MPI_Comm_size.

template<typename A, typename F, typename G, typename H> static H::result_type* matrix_skeletons::cata (  const F &  oplus, const G &  otimes, const H &  f, const dist_matrix< A > *  mat )  [static]

The cata skeleton (create new value). This skeleton reduces the matrix into a value with two binary operators after applying a function to each element. Definition (in Haskell) cata :: (a->a->a, a->a->a, b->a) -> Matrix b -> a cata (oplus, otimes, f) (Sing a) = f a cata (oplus, otimes, f) (Abv x y) = oplus ( cata (oplus, otimes, f) x) ( cata (oplus, otimes, f) y) cata (oplus, otimes, f) (Bsd x y) = otimes ( cata (oplus, otimes, f) x) ( cata (oplus, otimes, f) y) Two operators should have abiding property. Sample: < Haskell code > r = cata ((+), (+), square) m < C++ code > r = matrix_skeletons::cata( Add(), Add(), Square(), m); The matrices must be row-wise. Parameters: oplus  a function taking two arguments x and y, returning result z, i.e. z = x oplus y, and must be abiding with otimes. oplus should have the member void operator()(const A&, const A&, A*) const. The function object oplus should inherit skeleton::binary_function. A sample of function object is as follows: (Addition) class Add : public skeleton::binary_function <int, int, int> { public: void operator()(const int &i, const int &j, int *r) const { *r = i + j; } }; oplus should be associative. otimes  a function taking two arguments x and y, returning result z, i.e. z = x otimes y, and must be abiding with oplus. The function otimes oplus should inherit skeleton::binary_function. otimes should be associative. Associative and commutative operator has abiding property with itself. f  a function taking A, and returning result in B f should have the member void operator()(const A&, B*) const. The function object f should inherit skeleton::unary_function. A sample of function object is as follows: (square root of the value. type of result is double and type of argument is int) class Square : public skeleton::unary_function <int, double> { public: void operator()(const int &i, double *r) const { *r = sqrt((double)i); } }; mat  a matrix to which the reduce is applied. Returns: Resulting reduced value. User should free it. See also: m_skeletons::reduce(const F &, const G &, const matrix<A> *)

template<typename A, typename F, typename G, typename H> static void matrix_skeletons::cata (  const F &  oplus, const G &  otimes, const H &  f, const dist_matrix< A > *  mat, typename H::result_type *  res )  [static]

The cata skeleton. This skeleton reduces the matrix into a value with two binary operators after applying a function to each element. The matrices must be row-wise. Parameters: oplus  a function taking two arguments x and y, returning result z, i.e. z = x oplus y, and must be abiding with otimes. oplus should have the member void operator()(const A&, const A&, A*) const. The function object oplus should inherit skeleton::binary_function. A sample of function object is as follows: (Max) class Max : public skeleton::binary_function <int, int, int> { public: void operator()(const int &i, const int &j, int *r) const { *r = (i > j) ? i : j; } }; oplus should be associative. otimes  a function taking two arguments x and y, returning result z, i.e. z = x otimes y, and must be abiding with oplus. The function otimes oplus should inherit skeleton::binary_function. otimes should be associative. Associative and commutative operator has abiding property with itself. f  a function taking A, and returning result in B f should have the member void operator()(const A&, B*) const. The function object f should inherit skeleton::unary_function. A sample of function object is as follows: (square root of the value. type of result is double and type of argument is int) class Square : public skeleton::unary_function <int, double> { public: void operator()(const int &i, double *r) const { *r = sqrt((double)i); } }; mat  a matrix to which the cata is applied. res  resulting reduced value. See also: matrix_skeletons::cata(const F &, const G &, const H &, const dist_matrix<A> *)

template<typename A, typename F, typename G, typename H> static H::result_type* matrix_skeletons::cataDCN2 (  const F &  oplus, const G &  otimes, const H &  f, const dist_matrix< A > *  mat )  [static]

The cata skeleton (create new value, with divide and conquer local computation, nested parallelism, broadcasting operands for each operator). This skeleton reduces the matrix into a value with two binary operators after applying a function to each element. Definition (in Haskell) cata :: (a->a->a, a->a->a, b->a) -> Matrix b -> a cata (oplus, otimes, f) (Sing a) = f a cata (oplus, otimes, f) (Abv x y) = oplus ( cata (oplus, otimes, f) x) ( cata (oplus, otimes, f) y) cata (oplus, otimes, f) (Bsd x y) = otimes ( cata (oplus, otimes, f) x) ( cata (oplus, otimes, f) y) Two operators should have abiding property. Sample: < Haskell code > r = cata ((+), (+), square) m < C++ code > r = matrix_skeletons::cata( Add(), Add(), Square(), m); The matrices must be row-wise. Parameters: oplus  a function taking two arguments x and y, returning result z, i.e. z = x oplus y, and must be abiding with otimes. oplus should have the member void operator()(const A&, const A&, A*) const. The function object oplus should inherit skeleton::binary_function. A sample of function object is as follows: (Addition) class Add : public skeleton::binary_function <int, int, int> { public: void operator()(const int &i, const int &j, int *r) const { *r = i + j; } }; oplus should be associative. otimes  a function taking two arguments x and y, returning result z, i.e. z = x otimes y, and must be abiding with oplus. The function otimes oplus should inherit skeleton::binary_function. otimes should be associative. Associative and commutative operator has abiding property with itself. f  a function taking A, and returning result in B f should have the member void operator()(const A&, B*) const. The function object f should inherit skeleton::unary_function. A sample of function object is as follows: (square root of the value. type of result is double and type of argument is int) class Square : public skeleton::unary_function <int, double> { public: void operator()(const int &i, double *r) const { *r = sqrt((double)i); } }; mat  a matrix to which the reduce is applied. Returns: Resulting reduced value. User should free it. See also: m_skeletons::reduce(const F &, const G &, const matrix<A> *)

template<typename A, typename F, typename G, typename H> static void matrix_skeletons::cataDCN2 (  const F &  oplus, const G &  otimes, const H &  f, const dist_matrix< A > *  mat, typename H::result_type *  res )  [static]

The cata skeleton(with divide and conquer local computation, nested parallelism, broadcasting operands for each operator). This skeleton reduces the matrix into a value with two binary operators after applying a function to each element. The matrices must be row-wise. Parameters: oplus  a function taking two arguments x and y, returning result z, i.e. z = x oplus y, and must be abiding with otimes. oplus should have the member void operator()(const A&, const A&, A*) const. The function object oplus should inherit skeleton::binary_function. A sample of function object is as follows: (Max) class Max : public skeleton::binary_function <int, int, int> { public: void operator()(const int &i, const int &j, int *r) const { *r = (i > j) ? i : j; } }; oplus should be associative. otimes  a function taking two arguments x and y, returning result z, i.e. z = x otimes y, and must be abiding with oplus. The function otimes oplus should inherit skeleton::binary_function. otimes should be associative. Associative and commutative operator has abiding property with itself. f  a function taking A, and returning result in B f should have the member void operator()(const A&, B*) const. The function object f should inherit skeleton::unary_function. A sample of function object is as follows: (square root of the value. type of result is double and type of argument is int) class Square : public skeleton::unary_function <int, double> { public: void operator()(const int &i, double *r) const { *r = sqrt((double)i); } }; mat  a matrix to which the cata is applied. res  resulting reduced value. See also: matrix_skeletons::cataDCN2(const F &, const G &, const H &, const dist_matrix<A> *)

int matrix_skeletons::getDistributionPolicy (   )  [static]

Return the distribution policy. Returns: Current policy. See also: DPOLICY_RECTANGLE DPOLICY_SQUARE DPOLICY_ROW DPOLICY_COLUMN Definition at line 145 of file sketo.cpp. References distributionPolicy.

template<typename A, typename F> static dist_matrix<typename F::result_type>* matrix_skeletons::map (  const F &  f, const dist_matrix< A > *  mat )  [static]

The map skeleton(crates a new matrix). This function applies the function to each element of the matrix. Definition (in Haskell) map :: (a -> b) -> Matrix a -> Matrix b map f (Sing a) = Sing (f a) map f (Abv x y) = Abv (map f x) (map f y) map f (Bsd x y) = Bsd (map f x) (map f y) Sample: < Haskell code > m2 = map f m1 < C++ code > m2 = matrix_skeletons::map( f, m1 ); Parameters: f  a function taking A, and returning result in B f should have the member void operator()(const A&, B*) const. The function object f should inherit skeleton::unary_function. A sample of function object is as follows: (square root of the value. type of result is double and type of argument is int) class Square : public skeleton::unary_function <int, double> { public: void operator()(const int &i, double *r) const { *r = sqrt((double)i); } }; mat  matrix to which the skeleton is applied. Returns: A matrix to which the result is stored. See also: m_skeletons::map(const F&, const matrix <A>*)

template<typename B, typename A, typename F> static void matrix_skeletons::map (  const F &  f, const dist_matrix< A > *  mat, dist_matrix< B > *  dmb )  [static]

The map skeleton. This function applies the function to each element of the matrix. Parameters: f  a function taking A, and returning result in B f should have the member void operator()(const A&, B*) const. The function object f should inherit skeleton::unary_function. A sample of function object is as follows: (square root of the value. type of result is double and type of argument is int) class Square : public skeleton::unary_function <int, double> { public: void operator()(const int &i, double *r) const { *r = sqrt((double)i); } }; mat  matrix to which the skeleton is applied. dmb  matrix to which the result is stored. See also: matrix_skeletons::map(const F&, const dist_matrix <A>*)

template<typename A, typename F> static void matrix_skeletons::map_i (  const F &  f, dist_matrix< A > *  mat )  [static]

The map skeleton (inplace). This function applies the function to each element of the matrix. Parameters: f  a function object taking A, and overwriting the result on the argument. f should have the member void operator()(A*) const. A sample of function object is as follows: (the value *r is replaced by *r*2) class Double { public: void operator()(int *r) const { *r = *r*2; } }; mat  matrix to which the skeleton is applied. See also: matrix_skeletons::map(const F&, const dist_matrix <A>*)

template<typename A, typename F, typename G> static A* matrix_skeletons::reduce (  const F &  oplus, const G &  otimes, const dist_matrix< A > *  mat )  [static]

The reduce skeleton (create new value). This skeleton reduces the matrix into a value with two binary operators. Definition (in Haskell) reduce :: (a->a->a, a->a->a) -> Matrix a -> a reduce (oplus, otimes) (Sing a) = a reduce (oplus, otimes) (Abv x y) = oplus ( reduce (oplus, otimes) x) ( reduce (oplus, otimes) y) reduce (oplus, otimes) (Bsd x y) = otimes ( reduce (oplus, otimes) x) ( reduce (oplus, otimes) y) Two operators should have abiding property. Sample: < Haskell code > r = reduce ((+), (+)) m < C++ code > r = matrix_skeletons::reduce( Add(), Add(), m); The matrices must be row-wise. Parameters: oplus  a function taking two arguments x and y, returning result z, i.e. z = x oplus y, and must be abiding with otimes. oplus should have the member void operator()(const A&, const A&, A*) const. The function object oplus should inherit skeleton::binary_function. A sample of function object is as follows: (Addition) class Add : public skeleton::binary_function <int, int, int> { public: void operator()(const int &i, const int &j, int *r) const { *r = i + j; } }; oplus should be associative. otimes  a function taking two arguments x and y, returning result z, i.e. z = x otimes y, and must be abiding with oplus. The function otimes oplus should inherit skeleton::binary_function. otimes should be associative. Associative and commutative operator has abiding property with itself. mat  a matrix to which the reduce is applied. Returns: Resulting reduced value. User should free it. See also: m_skeletons::reduce(const F &, const G &, const matrix<A> *)

template<typename A, typename F, typename G> static void matrix_skeletons::reduce (  const F &  oplus, const G &  otimes, const dist_matrix< A > *  mat, A *  res )  [static]

The reduce skeleton. This skeleton reduces the matrix into a value with two binary operators. The matrices must be row-wise. Parameters: oplus  a function taking two arguments x and y, returning result z, i.e. z = x oplus y, and must be abiding with otimes. oplus should have the member void operator()(const A&, const A&, A*) const. The function object oplus should inherit skeleton::binary_function. A sample of function object is as follows: (Max) class Max : public skeleton::binary_function <int, int, int> { public: void operator()(const int &i, const int &j, int *r) const { *r = (i > j) ? i : j; } }; oplus should be associative. otimes  a function taking two arguments x and y, returning result z, i.e. z = x otimes y, and must be abiding with oplus. The function otimes oplus should inherit skeleton::binary_function. otimes should be associative. Associative and commutative operator has abiding property with itself. mat  a matrix to which the reduce is applied. res  resulting reduced value. See also: matrix_skeletons::reduce(const F &, const G &, const dist_matrix<A> *)

template<typename A, typename F, typename G> static A* matrix_skeletons::reduceB (  const F &  oplus, const G &  otimes, const dist_matrix< A > *  mat )  [static]

The reduce with broadcast. Broadcasting after reduction. Parameters: oplus  a function taking two arguments x and y, returning result z, i.e. z = x oplus y, and must be abiding with otimes. oplus should have the member void operator()(const A&, const A&, A*) const. The function object oplus should inherit skeleton::binary_function. A sample of function object is as follows: (Max) class Max : public skeleton::binary_function <int, int, int> { public: void operator()(const int &i, const int &j, int *r) const { *r = (i > j) ? i : j; } }; oplus should be associative. otimes  a function taking two arguments x and y, returning result z, i.e. z = x otimes y, and must be abiding with oplus. The function otimes oplus should inherit skeleton::binary_function. otimes should be associative. Associative and commutative operator has abiding property with itself. mat  a matrix to which the reduce is applied. Returns: Resulting reduced value. See also: matrix_skeletons::reduce(const F &, const G &, const dist_matrix<A> *) dist_matrix::bcast(B &, const dist_matrix< A > *)

template<typename A, typename F, typename G> static void matrix_skeletons::reduceB (  const F &  oplus, const G &  otimes, const dist_matrix< A > *  mat, A *  res )  [static]

The reduce with broadcast. Broadcasting after reduction. Parameters: oplus  a function taking two arguments x and y, returning result z, i.e. z = x oplus y, and must be abiding with otimes. oplus should have the member void operator()(const A&, const A&, *A) const. The function object oplus should inherit skeleton::binary_function. A sample of function object is as follows: (Max) class Max : public skeleton::binary_function <int, int, int> { public: void operator()(const int &i, const int &j, int *r) const { *r = (i > j) ? i : j; } }; oplus should be associative. otimes  a function taking two arguments x and y, returning result z, i.e. z = x otimes y, and must be abiding with oplus. The function otimes oplus should inherit skeleton::binary_function. otimes should be associative. Associative and commutative operator has abiding property with itself. mat  a matrix to which the reduce is applied. res  resulting reduced value. See also: matrix_skeletons::reduceB(const F &, const G &, const dist_matrix<A> *) matrix_skeletons::reduce(const F &, const G &, const dist_matrix<A> *) dist_matrix::bcast(B &, const dist_matrix< A > *)

template<typename A, typename F, typename G> static A* matrix_skeletons::reduceDC (  const F &  oplus, const G &  otimes, const dist_matrix< A > *  mat )  [static]

The reduce skeleton (create new value, with divide and conquer local computation). This skeleton reduces the matrix into a value with two binary operators. Definition (in Haskell) reduce :: (a->a->a, a->a->a) -> Matrix a -> a reduce (oplus, otimes) (Sing a) = a reduce (oplus, otimes) (Abv x y) = oplus ( reduce (oplus, otimes) x) ( reduce (oplus, otimes) y) reduce (oplus, otimes) (Bsd x y) = otimes ( reduce (oplus, otimes) x) ( reduce (oplus, otimes) y) Two operators should have abiding property. Sample: < Haskell code > r = reduce ((+), (+)) m < C++ code > r = matrix_skeletons::reduce( Add(), Add(), m); The matrices must be row-wise. Parameters: oplus  a function taking two arguments x and y, returning result z, i.e. z = x oplus y, and must be abiding with otimes. oplus should have the member void operator()(const A&, const A&, A*) const. The function object oplus should inherit skeleton::binary_function. A sample of function object is as follows: (Addition) class Add : public skeleton::binary_function <int, int, int> { public: void operator()(const int &i, const int &j, int *r) const { *r = i + j; } }; oplus should be associative. otimes  a function taking two arguments x and y, returning result z, i.e. z = x otimes y, and must be abiding with oplus. The function otimes oplus should inherit skeleton::binary_function. otimes should be associative. Associative and commutative operator has abiding property with itself. mat  a matrix to which the reduce is applied. Returns: Resulting reduced value. User should free it. See also: m_skeletons::reduce(const F &, const G &, const matrix<A> *)

template<typename A, typename F, typename G> static void matrix_skeletons::reduceDC (  const F &  oplus, const G &  otimes, const dist_matrix< A > *  mat, A *  res )  [static]

The reduce skeleton(with divide and conquer local computation). This skeleton reduces the matrix into a value with two binary operators. The matrices must be row-wise. Parameters: oplus  a function taking two arguments x and y, returning result z, i.e. z = x oplus y, and must be abiding with otimes. oplus should have the member void operator()(const A&, const A&, A*) const. The function object oplus should inherit skeleton::binary_function. A sample of function object is as follows: (Max) class Max : public skeleton::binary_function <int, int, int> { public: void operator()(const int &i, const int &j, int *r) const { *r = (i > j) ? i : j; } }; oplus should be associative. otimes  a function taking two arguments x and y, returning result z, i.e. z = x otimes y, and must be abiding with oplus. The function otimes oplus should inherit skeleton::binary_function. otimes should be associative. Associative and commutative operator has abiding property with itself. mat  a matrix to which the reduce is applied. res  resulting reduced value. See also: matrix_skeletons::reduce(const F &, const G &, const dist_matrix<A> *)

template<typename A, typename F, typename G> static A* matrix_skeletons::reduceDCN (  const F &  oplus, const G &  otimes, const dist_matrix< A > *  mat )  [static]

The reduce skeleton (create new value, with divide and conquer local computation, nested parallelism). This skeleton reduces the matrix into a value with two binary operators. Definition (in Haskell) reduce :: (a->a->a, a->a->a) -> Matrix a -> a reduce (oplus, otimes) (Sing a) = a reduce (oplus, otimes) (Abv x y) = oplus ( reduce (oplus, otimes) x) ( reduce (oplus, otimes) y) reduce (oplus, otimes) (Bsd x y) = otimes ( reduce (oplus, otimes) x) ( reduce (oplus, otimes) y) Two operators should have abiding property. Sample: < Haskell code > r = reduce ((+), (+)) m < C++ code > r = matrix_skeletons::reduce( Add(), Add(), m); The matrices must be row-wise. Parameters: oplus  a function taking two arguments x and y, returning result z, i.e. z = x oplus y, and must be abiding with otimes. oplus should have the member void operator()(const A&, const A&, A*) const. The function object oplus should inherit skeleton::binary_function. A sample of function object is as follows: (Addition) class Add : public skeleton::binary_function <int, int, int> { public: void operator()(const int &i, const int &j, int *r) const { *r = i + j; } }; oplus should be associative. otimes  a function taking two arguments x and y, returning result z, i.e. z = x otimes y, and must be abiding with oplus. The function otimes oplus should inherit skeleton::binary_function. otimes should be associative. Associative and commutative operator has abiding property with itself. mat  a matrix to which the reduce is applied. Returns: Resulting reduced value. User should free it. See also: m_skeletons::reduce(const F &, const G &, const matrix<A> *)

template<typename A, typename F, typename G> static void matrix_skeletons::reduceDCN (  const F &  oplus, const G &  otimes, const dist_matrix< A > *  mat, A *  res )  [static]

The reduce skeleton(with divide and conquer local computation, nested parallelism). This skeleton reduces the matrix into a value with two binary operators. The matrices must be row-wise. Parameters: oplus  a function taking two arguments x and y, returning result z, i.e. z = x oplus y, and must be abiding with otimes. oplus should have the member void operator()(const A&, const A&, A*) const. The function object oplus should inherit skeleton::binary_function. A sample of function object is as follows: (Max) class Max : public skeleton::binary_function <int, int, int> { public: void operator()(const int &i, const int &j, int *r) const { *r = (i > j) ? i : j; } }; oplus should be associative. otimes  a function taking two arguments x and y, returning result z, i.e. z = x otimes y, and must be abiding with oplus. The function otimes oplus should inherit skeleton::binary_function. otimes should be associative. Associative and commutative operator has abiding property with itself. mat  a matrix to which the reduce is applied. res  resulting reduced value. See also: matrix_skeletons::reduce(const F &, const G &, const dist_matrix<A> *)

template<typename A, typename F, typename G> static A* matrix_skeletons::reduceDCN2 (  const F &  oplus, const G &  otimes, const dist_matrix< A > *  mat )  [static]

The reduce skeleton (create new value, with divide and conquer local computation, nested parallelism, broadcasting operands for each operator). This skeleton reduces the matrix into a value with two binary operators. Definition (in Haskell) reduce :: (a->a->a, a->a->a) -> Matrix a -> a reduce (oplus, otimes) (Sing a) = a reduce (oplus, otimes) (Abv x y) = oplus ( reduce (oplus, otimes) x) ( reduce (oplus, otimes) y) reduce (oplus, otimes) (Bsd x y) = otimes ( reduce (oplus, otimes) x) ( reduce (oplus, otimes) y) Two operators should have abiding property. Sample: < Haskell code > r = reduce ((+), (+)) m < C++ code > r = matrix_skeletons::reduce( Add(), Add(), m); The matrices must be row-wise. Parameters: oplus  a function taking two arguments x and y, returning result z, i.e. z = x oplus y, and must be abiding with otimes. oplus should have the member void operator()(const A&, const A&, A*) const. The function object oplus should inherit skeleton::binary_function. A sample of function object is as follows: (Addition) class Add : public skeleton::binary_function <int, int, int> { public: void operator()(const int &i, const int &j, int *r) const { *r = i + j; } }; oplus should be associative. otimes  a function taking two arguments x and y, returning result z, i.e. z = x otimes y, and must be abiding with oplus. The function otimes oplus should inherit skeleton::binary_function. otimes should be associative. Associative and commutative operator has abiding property with itself. mat  a matrix to which the reduce is applied. Returns: Resulting reduced value. User should free it. See also: m_skeletons::reduce(const F &, const G &, const matrix<A> *)

template<typename A, typename F, typename G> static void matrix_skeletons::reduceDCN2 (  const F &  oplus, const G &  otimes, const dist_matrix< A > *  mat, A *  res )  [static]

The reduce skeleton(with divide and conquer local computation, nested parallelism, broadcasting operands for each operator). This skeleton reduces the matrix into a value with two binary operators. The matrices must be row-wise. Parameters: oplus  a function taking two arguments x and y, returning result z, i.e. z = x oplus y, and must be abiding with otimes. oplus should have the member void operator()(const A&, const A&, A*) const. The function object oplus should inherit skeleton::binary_function. A sample of function object is as follows: (Max) class Max : public skeleton::binary_function <int, int, int> { public: void operator()(const int &i, const int &j, int *r) const { *r = (i > j) ? i : j; } }; oplus should be associative. otimes  a function taking two arguments x and y, returning result z, i.e. z = x otimes y, and must be abiding with oplus. The function otimes oplus should inherit skeleton::binary_function. otimes should be associative. Associative and commutative operator has abiding property with itself. mat  a matrix to which the reduce is applied. res  resulting reduced value. See also: matrix_skeletons::reduce(const F &, const G &, const dist_matrix<A> *)

template<typename A, typename F> static void matrix_skeletons::rotateCols (  const F &  f, dist_matrix< A > *  mat )  [static]

Rotate column-blocks by f(row-position). Parameters: f  a function object taking row position, returning shift-value f should have int operator()(int a) const. A sample of function object is as follows: (i-th col is shifted by i to the bottom) class ShiftLinear { public: int operator()(int i) const { return i; } }; mat  a dist_matrix to which the skeleton is applied.

template<typename A> static void matrix_skeletons::rotateColsConst (  int  s, dist_matrix< A > *  mat )  [static]

Rotate column-blocks by s. Parameters: s  shift. mat  a dist_matrix to which the skeleton is applied.

template<typename A, typename F> static void matrix_skeletons::rotateRows (  const F &  f, dist_matrix< A > *  mat )  [static]

Rotate row-blocks by f(col-position). Parameters: f  a function object taking column position, returning shift-value f should have int operator()(int a) const. A sample of function object is as follows: (i-th row is shifted by i to the left) class ShiftLinear { public: int operator()(int i) const { return i; } }; mat  a dist_matrix to which the skeleton is applied.

template<typename A> static void matrix_skeletons::rotateRowsConst (  int  s, dist_matrix< A > *  mat )  [static]

Rotate row-blocks by s. Parameters: s  shift. mat  a dist_matrix to which the skeleton is applied.

template<typename A, typename F, typename G> static dist_matrix<A>* matrix_skeletons::scan (  const F &  oplus, const G &  otimes, const dist_matrix< A > *  dma )  [static]

The scan skeleton. This skeleton stores every process of reduction of a matrix into a value with two binary operators. The matrices must be row-wise. Definition (in Haskell) scan :: (a->a->a, a->a->a) -> Matrix a -> Matrix a scan (oplus, otimes) (Sing a) = (Sing a) scan (oplus, otimes) (Abv x y) = oplus' ( scan (oplus, otimes) x) ( scan (oplus, otimes) y) where oplus' sx sy = Abv sx sy' where sy' = mapr (zipwith oplus (bottom sx)) sy scan (oplus, otimes) (Bsd x y) = otimes' ( scan (oplus, otimes) x) ( scan (oplus, otimes) y) where otimes' sx sy = Bsd sx sy' where sy' = mapc (zipwith otimes (right sx)) sy Two operators should have abiding property. Sample: < Haskell code > m2 = scan ((+), (+)) m1 < C++ code > m2 = matrix_skeletons::scan( Add(), Add(), m1); Parameters: oplus  a function taking two arguments x and y, returning result z, i.e. z = x oplus y, and must be abiding with otimes. oplus should have the member void operator()(const A&, const A&, A*) const. The function object oplus should inherit skeleton::binary_function. A sample of function object is as follows: (Addition) class Add : public skeleton::binary_function <int, int, int> { public: void operator()(const int &i, const int &j, int *r) const { *r = i+j; } }; oplus should be associative. otimes  a function taking two arguments x and y, returning result z, i.e. z = x otimes y, and must be abiding with oplus. The function otimes oplus should inherit skeleton::binary_function. otimes should be associative. Associative and commutative operator has abiding property with itself. dma  a matrix to which the reduce is applied. Returns: Resulting matrix of all reduction values. User should free it. See also: matrix_skeletons::reduce(const F &, const G &, const dist_matrix<A> *) matrix_skeletons::zipwith(const F &, const dist_matrix<A>*, const dist_matrix<B>*) m_skeletons::scan(const F &, const G &, const matrix<A> *) m_skeletons::right(const matrix<A> *) m_skeletons::bottom(const matrix<A> *) m_skeletons::mapr(const F &, const matrix<A> *) m_skeletons::mapc(const F &, const matrix<A> *)

template<typename A, typename F, typename G> static void matrix_skeletons::scan (  const F &  oplus, const G &  otimes, const dist_matrix< A > *  dma, dist_matrix< A > *  dmb )  [static]

The scan skeleton. This skeleton stores every process of reduction of a matrix into a value with two binary operators. The matrices must be row-wise. Parameters: oplus  a function taking two arguments x and y, returning result z, i.e. z = x oplus y, and must be abiding with otimes. oplus should have the member void operator()(const A&, const A&, A*) const. The function object oplus should inherit skeleton::binary_function. A sample of function object is as follows: (Max) class Max : public skeleton::binary_function <int, int, int> { public: void operator()(const int &i, const int &j, int *r) const { *r = (i > j) ? i : j; } }; oplus should be associative. otimes  a function taking two arguments x and y, returning result z, i.e. z = x otimes y, and must be abiding with oplus. The function otimes oplus should inherit skeleton::binary_function. otimes should be associative. Associative and commutative operator has abiding property with itself. dma  a matrix to which the reduce is applied. dmb  resulting matrix of all reduction values. See also: matrix_skeletons::scan(const F &, const G &, const dist_matrix<A> *)

template<typename A, typename F, typename G> static dist_matrix<A>* matrix_skeletons::scan2 (  const F &  oplus, const G &  otimes, const dist_matrix< A > *  dma )  [static]

template<typename A, typename F, typename G> static void matrix_skeletons::scan2 (  const F &  oplus, const G &  otimes, const dist_matrix< A > *  dma, dist_matrix< A > *  dmb )  [static]

template<typename A, typename F, typename G> static dist_matrix<A>* matrix_skeletons::scanr (  const F &  oplus, const G &  otimes, const dist_matrix< A > *  dma )  [static]

The reverse-scan skeleton. This skeleton stores every process of reverse reduction of a matrix into a value with two binary operators. The matrices must be row-wise. Definition (in Haskell) scanr :: (a->a->a, a->a->a) -> Matrix a -> Matrix a scanr (oplus, otimes) = rev . scan (binrev oplus, binrev otimes) . rev where rev = reduce (binrev Abv, binrev Bsd) . map Sing binrev f a b = f b a Two operators should have abiding property. Sample: < Haskell code > m2 = scanr ((+), (+)) m1 < C++ code > m2 = matrix_skeletons::scanr( Add(), Add(), m1); Parameters: oplus  a function taking two arguments x and y, returning result z, i.e. z = x oplus y, and must be abiding with otimes. oplus should have the member void operator()(const A&, const A&, A*) const. The function object oplus should inherit skeleton::binary_function. A sample of function object is as follows: (Addition) class Add : public skeleton::binary_function <int, int, int> { public: void operator()(const int &i, const int &j, int *r) const { *r = i+j; } }; oplus should be associative. otimes  a function taking two arguments x and y, returning result z, i.e. z = x otimes y, and must be abiding with oplus. The function otimes oplus should inherit skeleton::binary_function. otimes should be associative. Associative and commutative operator has abiding property with itself. dma  a matrix to which the reduce is applied. Returns: Resulting matrix of all reduction values. User should free it. See also: matrix_skeletons::scan(const F &, const G &, const dist_matrix<A> *) matrix_skeletons::reduce(const F &, const G &, const dist_matrix<A> *) matrix_skeletons::map(const F &, const dist_matrix<A> *) m_skeletons::scanr(const F &, const G &, const matrix<A> *)

template<typename A, typename F, typename G> static void matrix_skeletons::scanr (  const F &  oplus, const G &  otimes, const dist_matrix< A > *  dma, dist_matrix< A > *  dmb )  [static]

The reverse-scan skeleton. This skeleton stores every process of reverse reduction of a matrix into a value with two binary operators. The matrices must be row-wise. Parameters: oplus  a function taking two arguments x and y, returning result z, i.e. z = x oplus y, and must be abiding with otimes. oplus should have the member void operator()(const A&, const A&, A*) const. The function object oplus should inherit skeleton::binary_function. A sample of function object is as follows: (Addition) class Add : public skeleton::binary_function <int, int, int> { public: void operator()(const int &i, const int &j, int *r) const { *r = i+j; } }; oplus should be associative. otimes  a function taking two arguments x and y, returning result z, i.e. z = x otimes y, and must be abiding with oplus. The function otimes oplus should inherit skeleton::binary_function. otimes should be associative. Associative and commutative operator has abiding property with itself. dma  a matrix to which the reduce is applied. dmb  resulting matrix of all reduction values. User should free it. See also: matrix_skeletons::scanr(const F &, const G &, const dist_matrix<A> *)

int matrix_skeletons::setDistributionPolicy (  int  p  )  [static]

Set the distribution policy. Parameters: p  new policy. Returns: Old policy. See also: DPOLICY_RECTANGLE DPOLICY_SQUARE DPOLICY_ROW DPOLICY_COLUMN Definition at line 137 of file sketo.cpp. References distributionPolicy.

template<typename A, typename B> static dist_matrix< std::pair<A,B> >* matrix_skeletons::zip (  const dist_matrix< A > *  dma, const dist_matrix< B > *  dmb )  [static]

The zip skeleton which is a specialization of zipwith. Definition (in Haskell) zip :: (Matrix a, Matrix b) -> Matrix (a, b) zip (u, v) = zipwith (\ x y -> (x, y)) u v Parameters: dma  matrix to be zipped with. dmb  matrix to be zipped with Returns: A matrix consisting of pairs of corresponding elements of the matrices. See also: matrix_skeletons::zipwith(const F &, const dist_matrix<A>*, const dist_matrix<B>*) m_skeletons::zip(const matrix<A>*, const matrix<B>*)

template<typename A, typename B, typename F> static dist_matrix<typename F::result_type>* matrix_skeletons::zipwith (  const F &  f, const dist_matrix< A > *  dma, const dist_matrix< B > *  dmb )  [static]

The zipwith skeleton(creates a new matrix). This function applies the function to the pair of corresponding elements of the matrices. Definition (in Haskell) zipwith :: (a->b->c) -> Matrix a -> Matrix b -> Matrix c zipwith f (Sing a) (Sing b) = Sing (f a b) zipwith f (Abv x y) (Abv u v) = Abv (zipwith f x u) (zipwith f y v) zipwith f (Bsd x y) (Bsd u v) = Bsd (zipwith f x u) (zipwith f y v) Sample: < Haskell code > m3 = zipwith f m1 m2 < C++ code > m3 = matrix_skeletons::zipwith( f, m1, m2 ); Parameters: f  a function taking A and B, writing result into C f should have the member void operator()(const A*, const B*, C*) const. The function object f should inherit skeleton::binary_function. A sample of function object is as follows: (ratio of two arguments) class Ratio : public skeleton::binary_function <int, int, double> { public: void operator()(const int &i, const int &j, double *r) const { *r = i / (double)j; } }; dma  matrix to be zipped with. dmb  matrix to be zipped with. Returns: A matrix to which the result is stored. See also: m_skeletons::zipwith(const F &, const matrix<A>*, const matrix<B>*)

template<typename C, typename A, typename B, typename F> static void matrix_skeletons::zipwith (  const F &  f, const dist_matrix< A > *  dma, const dist_matrix< B > *  dmb, dist_matrix< C > *  dmc )  [static]

The zipwith skeleton(crates a new matrix). This function applies the function to the pair of corresponding elements of the matrices. Parameters: f  a function taking A and B, writing result into C f should have the member void operator()(const A&, const B&, C*) const. The function object f should inherit skeleton::binary_function. A sample of function object is as follows: (ratio of two arguments) class Ratio : public skeleton::binary_function <int, int, double> { public: void operator()(const int &i, const int &j, double *r) const { *r = i / (double)j; } }; dma  matrix to be zipped with. dmb  matrix to be zipped with. dmc  matrix to which result is stored See also: matrix_skeletons::zipwith(const F &, const dist_matrix<A>*, const dist_matrix<B>*)

---

Member Data Documentation

int matrix_skeletons::distributionPolicy = matrix_skeletons::DPOLICY_RECTANGLE [static]

Policy of implicit distribution by constructors. This policy is used when user uses constructors without specifying distribution (the number of division of the matrix) explicitly. Default policy is DPOLICY_RECTANGLE. Todo: This variable should be a member of matrix_skeletons... Definition at line 84 of file matrix_skeletons.h. Referenced by calcDivision(), getDistributionPolicy(), and setDistributionPolicy().

const int matrix_skeletons::DPOLICY_COLUMN = 3 [static]

Distribute policy COLUMN. The matrix is distributed in column-direction. Distributed matrix can be seen as a (1, c) matrix (vector) of matrices. c = processors, where c is division in column-direction. Definition at line 118 of file matrix_skeletons.h. Referenced by calcDivision().

const int matrix_skeletons::DPOLICY_RECTANGLE = 0 [static]

Distribute policy RECTANGLE. Using all processors to distribute the matrix. Distributed matrix can be seen as a (r, c) matrix of matrices. r*c = processors, where r is division in row-direction, and c is division in column-direction. Definition at line 93 of file matrix_skeletons.h. Referenced by calcDivision().

const int matrix_skeletons::DPOLICY_ROW = 2 [static]

Distribute policy ROW. The matrix is distributed in row-direction. Distributed matrix can be seen as a (r, 1) matrix (vector) of matrices. r = processors, where r is division in row-direction. Definition at line 110 of file matrix_skeletons.h. Referenced by calcDivision().

const int matrix_skeletons::DPOLICY_SQUARE = 1 [static]

Distribute policy SQUARE. The matrix is distributed symmetrically in row- and column-direction. Distributed matrix can be seen as a (r, r) square matrix of matrices. r*r =< processors, where r is division in each-direction and (r+1) * (r+1) > processors. Definition at line 102 of file matrix_skeletons.h. Referenced by calcDivision().

---

The documentation for this class was generated from the following files:

• libraries/matrix/matrix_skeletons.h
• libraries/util/sketo.cpp

---