Loading...
Searching...
No Matches
disarray.h
Go to the documentation of this file.
#ifndef _RHEO_DISARRAY_H
#define _RHEO_DISARRAY_H
//
// This file is part of Rheolef.
//
// Copyright (C) 2000-2009 Pierre Saramito <Pierre.Saramito@imag.fr>
//
// Rheolef is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Rheolef is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Rheolef; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// =========================================================================
namespace rheolef {
} // namespace rheolef
/*
Misc notes:
"scatter" via "get_dis_entry".
"gather" via "dis_entry(dis_i) = value"
or "dis_entry(dis_i) += value". Note that += applies when T=idx_set where
idx_set is a wrapper class of std::set<size_t> ; the += operator represents the
union of a set. The operator= is used when T=double or others simple T types
without algebra. If there is a conflict, i.e. several processes set the dis_i
index, then the result of operator+= depends upon the order of the process at
each run and is not deterministic. Such ambiguous behavior is not detected
yet at run time.
*/
#include "rheolef/communicator.h"
#include "rheolef/distributor.h"
#include "rheolef/diststream.h"
#include "rheolef/heap_allocator.h"
#include "rheolef/msg_util.h"
#ifdef _RHEOLEF_HAVE_MPI
#include "rheolef/mpi_pair_datatype.h"
#endif // _RHEOLEF_HAVE_MPI
namespace rheolef {
template <class T>
struct _disarray_put_element_type {
std::ostream& operator() (std::ostream& os, const T& x) const { return os << x; }
};
template <class T>
struct _disarray_put_matlab_type {
std::ostream& operator() (std::ostream& os, const T& x) const { return os << x << ";"; }
};
template <class T>
struct _disarray_get_element_type {
std::istream& operator() (std::istream& is, T& x) const { return is >> x; }
};
} // namespace rheolef
// -------------------------------------------------------------
// the sequential representation
// -------------------------------------------------------------
namespace rheolef {
template <class T, class M, class A> class disarray_rep {};
template <class T, class A>
class disarray_rep<T,sequential,A> : public std::vector<T> { // TODO: vector<T,A> for heap_alloc
public:
typedef T value_type;
typedef A allocator_type;
typedef typename A::difference_type difference_type;
typedef std::vector<T> base; // TODO: vector<T,A> for heap_alloc
typedef typename base::size_type size_type;
typedef typename base::iterator iterator;
typedef typename base::const_iterator const_iterator;
typedef typename base::const_reference const_reference;
typedef typename base::reference reference;
typedef reference dis_reference;
typedef distributor::communicator_type communicator_type;
typedef sequential memory_type;
explicit disarray_rep (const A& alloc = A());
disarray_rep (const distributor& ownership, const T& init_val = T(), const A& alloc = A());
void resize (const distributor& ownership, const T& init_val = T());
disarray_rep (size_type loc_size = 0, const T& init_val = T(), const A& alloc = A());
void resize (size_type loc_size = 0, const T& init_val = T());
disarray_rep (const disarray_rep<T,sequential,A>& x);
A get_allocator() const { return base::get_allocator(); }
size_type size() const { return base::size(); }
iterator begin() { return base::begin(); }
const_iterator begin() const { return base::begin(); }
iterator end() { return base::end(); }
const_iterator end() const { return base::end(); }
const distributor& ownership() const { return _ownership; }
reference operator[] (size_type i) { return base::operator[] (i); }
const_reference operator[] (size_type i) const { return base::operator[] (i); }
const_reference dis_at (size_type dis_i) const { return operator[] (dis_i); }
size_type dis_size () const { return base::size(); }
size_type first_index () const { return 0; }
size_type last_index () const { return base::size(); }
reference dis_entry (size_type dis_i) { return operator[](dis_i); }
void get_dis_indexes (std::set<size_type>& ext_idx_set) const;
void reset_dis_indexes() const {}
template<class SetOp = typename details::default_set_op_traits<T>::type>
void dis_entry_assembly_begin (SetOp = SetOp()) {}
template<class SetOp = typename details::default_set_op_traits<T>::type>
void dis_entry_assembly_end (SetOp = SetOp()) {}
void repartition ( // old_numbering for *this
const disarray_rep<size_type,sequential,A>& partition, // old_ownership
disarray_rep<T,sequential,A>& new_disarray, // new_ownership (created)
disarray_rep<size_type,sequential,A>& old_numbering, // new_ownership
disarray_rep<size_type,sequential,A>& new_numbering) const // old_ownership
{
error_macro ("not yet");
}
template<class A2>
void reverse_permutation ( // old_ownership for *this=iold2dis_inew
disarray_rep<size_type,sequential,A2>& inew2dis_iold) const; // new_ownership
idiststream& get_values (idiststream& s);
odiststream& put_values (odiststream& s) const;
odiststream& put_matlab (odiststream& s) const;
template <class GetFunction> idiststream& get_values (idiststream& ips, GetFunction get_element);
template <class PutFunction> odiststream& put_values (odiststream& ops, PutFunction put_element) const;
void dump (std::string name) const;
protected:
// data:
distributor _ownership;
};
// -------------------------------------------------------------
// the distributed representation
// -------------------------------------------------------------
#ifdef _RHEOLEF_HAVE_MPI
template <class T, class A> struct disarray_dis_reference;
template <class T, class A>
class disarray_rep<T,distributed,A> : public disarray_rep<T,sequential,A> {
public:
// typedefs:
using base = disarray_rep<T,sequential,A>;
using size_type = typename base::size_type;
using value_type = typename base::value_type;
using memory_type = distributed;
using iterator = typename base::iterator;
using const_iterator = typename base::const_iterator;
using reference = typename base::reference;
using const_reference = typename base::const_reference;
using difference_type = typename base::difference_type;
using communicator_type = distributor::communicator_type;
using scatter_map_type = std::map <size_type, T>; // TODO: map<T,A> for heap_alloc
using dis_reference = disarray_dis_reference<T,A>;
// allocators:
disarray_rep (const distributor& ownership, const T& init_val = T(), const A& alloc = A());
void resize (const distributor& ownership, const T& init_val = T());
disarray_rep (const disarray_rep<T,distributed,A>& x);
A get_allocator() const { return base::get_allocator(); }
size_type size() const { return base::size(); }
const_iterator begin() const { return base::begin(); }
const_iterator end() const { return base::end(); }
iterator begin() { return base::begin(); }
iterator end() { return base::end(); }
const distributor& ownership() const { return base::_ownership; }
const mpi::communicator& comm() const { return ownership().comm(); }
size_type first_index () const { return ownership().first_index(); }
size_type last_index () const { return ownership().last_index(); }
size_type dis_size () const { return ownership().dis_size(); }
dis_reference dis_entry (size_type dis_i) { return dis_reference (*this, dis_i); }
template<class SetOp = typename details::default_set_op_traits<T>::type>
void dis_entry_assembly_begin (SetOp my_set_op = SetOp());
template<class SetOp = typename details::default_set_op_traits<T>::type>
void dis_entry_assembly_end (SetOp my_set_op = SetOp());
template<class SetOp = typename details::default_set_op_traits<T>::type>
void dis_entry_assembly (SetOp my_set_op = SetOp())
{ dis_entry_assembly_begin (my_set_op); dis_entry_assembly_end (my_set_op); }
template<class Set, class Map>
void append_dis_entry (const Set& ext_idx_set, Map& ext_idx_map) const;
template<class Set, class Map>
void get_dis_entry (const Set& ext_idx_set, Map& ext_idx_map) const {
ext_idx_map.clear();
append_dis_entry (ext_idx_set, ext_idx_map);
}
template<class Set>
void append_dis_indexes (const Set& ext_idx_set) const { append_dis_entry (ext_idx_set, _ext_x); }
template<class Set>
void set_dis_indexes (const Set& ext_idx_set) const { get_dis_entry (ext_idx_set, _ext_x); }
void get_dis_indexes (std::set<size_type>& ext_idx_set) const;
void reset_dis_indexes() const;
const_reference dis_at (size_type dis_i) const;
// get all external pairs (dis_i, values):
const scatter_map_type& get_dis_map_entries() const { return _ext_x; }
template<class A2>
void repartition ( // old_numbering for *this
const disarray_rep<size_type,distributed,A2>& partition, // old_ownership
disarray_rep<T,distributed,A>& new_disarray, // new_ownership (created)
disarray_rep<size_type,distributed,A2>& old_numbering, // new_ownership
disarray_rep<size_type,distributed,A2>& new_numbering) const; // old_ownership
template<class A2>
void permutation_apply ( // old_numbering for *this
const disarray_rep<size_type,distributed,A2>& new_numbering, // old_ownership
disarray_rep<T,distributed,A>& new_disarray) const; // new_ownership (already allocated)
template<class A2>
void reverse_permutation ( // old_ownership for *this=iold2dis_inew
disarray_rep<size_type,distributed,A2>& inew2dis_iold) const; // new_ownership
idiststream& get_values (idiststream& s);
odiststream& put_values (odiststream& s) const;
odiststream& put_matlab (odiststream& s) const;
template <class GetFunction> idiststream& get_values (idiststream& ips, GetFunction get_element);
template <class PutFunction> odiststream& put_values (odiststream& ops, PutFunction put_element) const;
template <class PutFunction, class A2> odiststream& permuted_put_values (odiststream& ops, const disarray_rep<size_type,distributed,A2>& perm,
PutFunction put_element) const;
void dump (std::string name) const;
//protected:
template<class U, class SetOp>
void set_dis_entry (size_type dis_i, const U& val, const SetOp& set_op);
#ifdef TO_CLEAN
template<class U, class SetOp>
void set_plus_dis_entry (size_type dis_i, const U& val, const SetOp& set_op);
template<class U, class SetOp>
void set_minus_dis_entry (size_type dis_i, const U& val, const SetOp& set_op);
#endif // TO_CLEAN
// typedefs:
template<class Pair>
struct remove_const_in_pair {
typedef Pair type;
};
template<class T1, class T2>
struct remove_const_in_pair<std::pair<T1,T2> > {
typedef std::pair<typename std::decay<T1>::type,
typename std::decay<T2>::type> type;
};
template<class U, class IsContainer> struct stash_traits {};
template<class U>
struct stash_traits<U,std::false_type> {
typedef U mapped_type;
typedef std::map <size_type, U> map_type; // TODO: map<T,A> for heap_alloc
};
template<class U>
struct stash_traits<U,std::true_type> {
typedef typename remove_const_in_pair<typename U::value_type>::type mapped_type;
typedef std::multimap <size_type, mapped_type> map_type; // TODO: map<T,A> for heap_alloc
};
typedef typename details::is_container_of_mpi_datatype<T>::type is_container;
typedef typename stash_traits<T,is_container>::mapped_type stash_value;
typedef typename stash_traits<T,is_container>::map_type stash_map_type;
struct message_type {
std::list<std::pair<size_type,mpi::request> > waits; // TODO: list<T,A> for heap_alloc
std::vector<std::pair<size_type,stash_value> > data; // TODO: vector<T,A> for heap_alloc
message_type() : waits(), data() {}
};
template<class Set, class Map>
void append_dis_entry (const Set& ext_idx_set, Map& ext_idx_map, std::true_type) const;
template<class Set, class Map>
void append_dis_entry (const Set& ext_idx_set, Map& ext_idx_map, std::false_type) const;
// data:
stash_map_type _stash; // for assembly msgs:
message_type _send;
message_type _receive;
size_type _receive_max_size;
mutable scatter_map_type _ext_x; // for ext values (scatter)
};
// custom reference that interacts with stach
// for ext values on others partitions
template <class T, class A>
struct disarray_dis_reference
{
using size_type = typename disarray_rep<T,distributed,A>::size_type;
disarray_dis_reference (disarray_rep<T,distributed,A>& x, size_type dis_i)
: _x(x), _dis_i(dis_i) {}
#ifndef TO_CLEAN // not usefull: default behavior
disarray_dis_reference (const disarray_dis_reference<T,A>& r)
: _x(r._x), _dis_i(r._dis_i) {}
disarray_dis_reference<T,A>&
operator= (const disarray_dis_reference<T,A>& r) {
_x = r._x; _dis_i = r._dis_i; return *this; }
#endif // TO_CLEAN
disarray_dis_reference<T,A>&
operator= (const T& value) {
trace_macro("_x.set_dis_entry (dis_i="<<_dis_i<<", value="<<value<<", op=)");
_x.set_dis_entry (_dis_i, value, details::generic_set_op());
return *this;
}
template<class U>
disarray_dis_reference<T,A>&
operator+= (const U& value) {
trace_macro("_x.set_dis_entry (dis_i="<<_dis_i<<", value="<<value<<", op+=)");
_x.set_dis_entry (_dis_i, value, details::generic_set_plus_op());
return *this;
}
template<class U>
disarray_dis_reference<T,A>&
operator-= (const U& value) {
trace_macro("_x.set_dis_entry (dis_i="<<_dis_i<<", value="<<value<<", op-=)");
_x.set_dis_entry (_dis_i, value, details::generic_set_minus_op());
return *this;
}
// data:
protected:
disarray_rep<T,distributed,A>& _x;
size_type _dis_i;
};
namespace details {
template <class T, class A>
struct is_class_reference<disarray_dis_reference<T,A>> : std::true_type {};
} // namespace details
#endif // _RHEOLEF_HAVE_MPI
// -------------------------------------------------------------
// the basic class with a smart pointer to representation
// the user-level class with memory-model parameter
// -------------------------------------------------------------
template <class T, class M = rheo_default_memory_model, class A = std::allocator<T> >
class disarray {
public:
typedef M memory_type;
typedef disarray_rep<T,sequential,A> rep;
typedef typename rep::base::size_type size_type;
typedef typename rep::base::iterator iterator;
typedef typename rep::base::const_iterator const_iterator;
};
template <class T, class A>
class disarray<T,sequential,A> : public smart_pointer<disarray_rep<T,sequential,A> > {
public:
// typedefs:
typedef disarray_rep<T,sequential,A> rep;
typedef smart_pointer<rep> base;
typedef sequential memory_type;
typedef typename rep::size_type size_type;
typedef typename rep::difference_type difference_type;
typedef typename rep::value_type value_type;
typedef typename rep::reference reference;
typedef typename rep::dis_reference dis_reference;
typedef typename rep::iterator iterator;
typedef typename rep::const_reference const_reference;
typedef typename rep::const_iterator const_iterator;
// allocators:
disarray (size_type loc_size = 0, const T& init_val = T(), const A& alloc = A());
void resize (size_type loc_size = 0, const T& init_val = T());
disarray (const distributor& ownership, const T& init_val = T(), const A& alloc = A());
void resize (const distributor& ownership, const T& init_val = T());
// local accessors & modifiers:
A get_allocator() const { return base::data().get_allocator(); }
size_type size () const { return base::data().size(); }
size_type dis_size () const { return base::data().dis_size(); }
const distributor& ownership() const { return base::data().ownership(); }
const communicator& comm() const { return ownership().comm(); }
reference operator[] (size_type i) { return base::data().operator[] (i); }
const_reference operator[] (size_type i) const { return base::data().operator[] (i); }
reference operator() (size_type i) { return base::data().operator[] (i); }
const_reference operator() (size_type i) const { return base::data().operator[] (i); }
const_reference dis_at (size_type dis_i) const { return operator[] (dis_i); }
iterator begin() { return base::data().begin(); }
const_iterator begin() const { return base::data().begin(); }
iterator end() { return base::data().end(); }
const_iterator end() const { return base::data().end(); }
// global modifiers (for compatibility with distributed interface):
dis_reference dis_entry (size_type dis_i) { return base::data().dis_entry(dis_i); }
template<class SetOp = typename details::default_set_op_traits<T>::type>
void dis_entry_assembly (SetOp my_set_op = SetOp()) {}
template<class SetOp = typename details::default_set_op_traits<T>::type>
void dis_entry_assembly_begin (SetOp my_set_op = SetOp()) {}
template<class SetOp = typename details::default_set_op_traits<T>::type>
void dis_entry_assembly_end (SetOp my_set_op = SetOp()) {}
void dis_entry_assembly_begin() {}
void dis_entry_assembly_end() {}
void dis_entry_assembly() {}
void get_dis_indexes (std::set<size_type>& ext_idx_set) const { base::data().get_dis_indexes (ext_idx_set); }
void reset_dis_indexes() const {}
template<class Set> void set_dis_indexes (const Set& ext_idx_set) const {}
template<class Set> void append_dis_indexes (const Set& ext_idx_set) const {}
template<class Set, class Map> void append_dis_entry (const Set& ext_idx_set, Map& ext_idx_map) const {}
template<class Set, class Map> void get_dis_entry (const Set& ext_idx_set, Map& ext_idx_map) const {}
// apply a partition:
template<class RepSize>
void repartition ( // old_numbering for *this
const RepSize& partition, // old_ownership
disarray<T,sequential,A>& new_disarray, // new_ownership (created)
RepSize& old_numbering, // new_ownership
RepSize& new_numbering) const // old_ownership
{ return base::data().repartition (partition, new_disarray, old_numbering, new_numbering); }
template<class RepSize>
void permutation_apply ( // old_numbering for *this
const RepSize& new_numbering, // old_ownership
disarray<T,sequential,A>& new_disarray) const // new_ownership (already allocated)
{ return base::data().permutation_apply (new_numbering, new_disarray); }
void reverse_permutation ( // old_ownership for *this=iold2dis_inew
disarray<size_type,sequential,A>& inew2dis_iold) const // new_ownership
{ base::data().reverse_permutation (inew2dis_iold.data()); }
// i/o:
odiststream& put_values (odiststream& ops) const { return base::data().put_values(ops); }
idiststream& get_values (idiststream& ips) { return base::data().get_values(ips); }
template <class GetFunction>
idiststream& get_values (idiststream& ips, GetFunction get_element) { return base::data().get_values(ips, get_element); }
template <class PutFunction>
odiststream& put_values (odiststream& ops, PutFunction put_element) const { return base::data().put_values(ops, put_element); }
void dump (std::string name) const { return base::data().dump(name); }
};
template <class T, class A>
inline
disarray<T,sequential,A>::disarray (
size_type loc_size,
const T& init_val,
const A& alloc)
: base(new_macro(rep(loc_size,init_val,alloc)))
{
}
template <class T, class A>
inline
disarray<T,sequential,A>::disarray (
const distributor& ownership,
const T& init_val,
const A& alloc)
: base(new_macro(rep(ownership,init_val,alloc)))
{
}
template <class T, class A>
inline
void
disarray<T,sequential,A>::resize (
size_type loc_size,
const T& init_val)
{
base::data().resize (loc_size,init_val);
}
template <class T, class A>
inline
void
disarray<T,sequential,A>::resize (
const distributor& ownership,
const T& init_val)
{
base::data().resize (ownership,init_val);
}
#ifdef _RHEOLEF_HAVE_MPI
// [verbatim_disarray]
template <class T, class A>
class disarray<T,distributed,A> : public smart_pointer<disarray_rep<T,distributed,A> > {
public:
// typedefs:
typedef disarray_rep<T,distributed,A> rep;
typedef smart_pointer<rep> base;
typedef distributed memory_type;
typedef typename rep::size_type size_type;
typedef typename rep::difference_type difference_type;
typedef typename rep::value_type value_type;
typedef typename rep::reference reference;
typedef typename rep::dis_reference dis_reference;
typedef typename rep::iterator iterator;
typedef typename rep::const_reference const_reference;
typedef typename rep::const_iterator const_iterator;
typedef typename rep::scatter_map_type scatter_map_type;
// allocators:
disarray (const distributor& ownership = distributor(), const T& init_val = T(), const A& alloc = A());
void resize (const distributor& ownership = distributor(), const T& init_val = T());
// local accessors & modifiers:
A get_allocator() const { return base::data().get_allocator(); }
size_type size () const { return base::data().size(); }
size_type dis_size () const { return base::data().dis_size(); }
const distributor& ownership() const { return base::data().ownership(); }
const communicator& comm() const { return base::data().comm(); }
reference operator[] (size_type i) { return base::data().operator[] (i); }
const_reference operator[] (size_type i) const { return base::data().operator[] (i); }
reference operator() (size_type i) { return base::data().operator[] (i); }
const_reference operator() (size_type i) const { return base::data().operator[] (i); }
iterator begin() { return base::data().begin(); }
const_iterator begin() const { return base::data().begin(); }
iterator end() { return base::data().end(); }
const_iterator end() const { return base::data().end(); }
// global accessor:
template<class Set, class Map>
void append_dis_entry (const Set& ext_idx_set, Map& ext_idx_map) const { base::data().append_dis_entry (ext_idx_set, ext_idx_map); }
template<class Set, class Map>
void get_dis_entry (const Set& ext_idx_set, Map& ext_idx_map) const { base::data().get_dis_entry (ext_idx_set, ext_idx_map); }
template<class Set>
void append_dis_indexes (const Set& ext_idx_set) const { base::data().append_dis_indexes (ext_idx_set); }
void reset_dis_indexes() const { base::data().reset_dis_indexes(); }
void get_dis_indexes (std::set<size_type>& ext_idx_set) const { base::data().get_dis_indexes (ext_idx_set); }
template<class Set>
void set_dis_indexes (const Set& ext_idx_set) const { base::data().set_dis_indexes (ext_idx_set); }
const T& dis_at (size_type dis_i) const { return base::data().dis_at (dis_i); }
// get all external pairs (dis_i, values):
const scatter_map_type& get_dis_map_entries() const { return base::data().get_dis_map_entries(); }
// global modifiers (for compatibility with distributed interface):
dis_reference dis_entry (size_type dis_i) { return base::data().dis_entry(dis_i); }
template<class SetOp = typename details::default_set_op_traits<T>::type>
void dis_entry_assembly_begin (SetOp my_set_op = SetOp()) { base::data().dis_entry_assembly_begin (my_set_op); }
template<class SetOp = typename details::default_set_op_traits<T>::type>
void dis_entry_assembly_end (SetOp my_set_op = SetOp()) { base::data().dis_entry_assembly_end (my_set_op); }
template<class SetOp = typename details::default_set_op_traits<T>::type>
void dis_entry_assembly (SetOp my_set_op = SetOp()) { base::data().dis_entry_assembly (my_set_op); }
void dis_entry_assembly_begin() { base::data().template dis_entry_assembly_begin<typename details::default_set_op_traits<T>::type>(); }
void dis_entry_assembly_end() { base::data().template dis_entry_assembly_end<typename details::default_set_op_traits<T>::type>(); }
void dis_entry_assembly() { dis_entry_assembly_begin(); dis_entry_assembly_end(); }
// apply a partition:
template<class RepSize>
void repartition ( // old_numbering for *this
const RepSize& partition, // old_ownership
disarray<T,distributed>& new_disarray, // new_ownership (created)
RepSize& old_numbering, // new_ownership
RepSize& new_numbering) const // old_ownership
{ return base::data().repartition (partition.data(), new_disarray.data(), old_numbering.data(), new_numbering.data()); }
template<class RepSize>
void permutation_apply ( // old_numbering for *this
const RepSize& new_numbering, // old_ownership
disarray<T,distributed,A>& new_disarray) const // new_ownership (already allocated)
{ base::data().permutation_apply (new_numbering.data(), new_disarray.data()); }
void reverse_permutation ( // old_ownership for *this=iold2dis_inew
disarray<size_type,distributed,A>& inew2dis_iold) const // new_ownership
{ base::data().reverse_permutation (inew2dis_iold.data()); }
// i/o:
odiststream& put_values (odiststream& ops) const { return base::data().put_values(ops); }
idiststream& get_values (idiststream& ips) { return base::data().get_values(ips); }
void dump (std::string name) const { return base::data().dump(name); }
template <class GetFunction>
idiststream& get_values (idiststream& ips, GetFunction get_element) { return base::data().get_values(ips, get_element); }
template <class PutFunction>
odiststream& put_values (odiststream& ops, PutFunction put_element) const { return base::data().put_values(ops, put_element); }
template <class PutFunction, class A2> odiststream& permuted_put_values (
odiststream& ops, const disarray<size_type,distributed,A2>& perm, PutFunction put_element) const
{ return base::data().permuted_put_values (ops, perm.data(), put_element); }
};
// [verbatim_disarray]
template <class T, class A>
inline
disarray<T,distributed,A>::disarray (
const distributor& ownership,
const T& init_val,
const A& alloc)
: base(new_macro(rep(ownership,init_val,alloc)))
{
}
template <class T, class A>
inline
void
disarray<T,distributed,A>::resize (
const distributor& ownership,
const T & init_val)
{
base::data().resize (ownership,init_val);
}
#endif // _RHEOLEF_HAVE_MPI
// -------------------------------------------------------------
// i/o with operator<< & >>
// -------------------------------------------------------------
template <class T, class A>
inline
idiststream&
operator >> (idiststream& ips, disarray<T,sequential,A>& x)
{
return x.get_values(ips);
}
template <class T, class A>
inline
odiststream&
operator << (odiststream& ops, const disarray<T,sequential,A>& x)
{
return x.put_values(ops);
}
#ifdef _RHEOLEF_HAVE_MPI
template <class T, class A>
inline
idiststream&
operator >> (idiststream& ips, disarray<T,distributed,A>& x)
{
return x.get_values(ips);
}
template <class T, class A>
inline
odiststream&
operator << (odiststream& ops, const disarray<T,distributed,A>& x)
{
return x.put_values(ops);
}
#endif // _RHEOLEF_HAVE_MPI
} // namespace rheolef
// -------------------------------------------------------------
// not inlined : longer code
// -------------------------------------------------------------
#include "rheolef/disarray_seq.icc"
#include "rheolef/disarray_mpi.icc"
#endif // _RHEO_DISARRAY_H
communicator
see the communicator page for the full documentation
rheolef::disarray< T, distributed, A >::dis_entry_assembly_end
void dis_entry_assembly_end()
Definition disarray.h:716
rheolef::disarray< T, distributed, A >::resize
void resize(const distributor &ownership=distributor(), const T &init_val=T())
Definition disarray.h:766
rheolef::disarray< T, distributed, A >::const_iterator
rep::const_iterator const_iterator
Definition disarray.h:657
rheolef::disarray< T, distributed, A >::get_dis_entry
void get_dis_entry(const Set &ext_idx_set, Map &ext_idx_map) const
Definition disarray.h:689
rheolef::disarray< T, distributed, A >::set_dis_indexes
void set_dis_indexes(const Set &ext_idx_set) const
Definition disarray.h:697
rheolef::disarray< T, distributed, A >::scatter_map_type
rep::scatter_map_type scatter_map_type
Definition disarray.h:658
rheolef::disarray< T, distributed, A >::dis_reference
rep::dis_reference dis_reference
Definition disarray.h:654
rheolef::disarray< T, distributed, A >::get_dis_map_entries
const scatter_map_type & get_dis_map_entries() const
Definition disarray.h:702
rheolef::disarray< T, distributed, A >::begin
const_iterator begin() const
Definition disarray.h:679
rheolef::disarray< T, distributed, A >::dis_size
size_type dis_size() const
Definition disarray.h:669
rheolef::disarray< T, distributed, A >::dis_entry_assembly
void dis_entry_assembly()
Definition disarray.h:717
rheolef::disarray< T, distributed, A >::reset_dis_indexes
void reset_dis_indexes() const
Definition disarray.h:693
rheolef::disarray< T, distributed, A >::put_values
odiststream & put_values(odiststream &ops) const
Definition disarray.h:741
rheolef::disarray< T, distributed, A >::dis_entry
dis_reference dis_entry(size_type dis_i)
Definition disarray.h:706
rheolef::disarray< T, distributed, A >::dis_at
const T & dis_at(size_type dis_i) const
Definition disarray.h:699
rheolef::disarray< T, distributed, A >::difference_type
rep::difference_type difference_type
Definition disarray.h:651
rheolef::disarray< T, distributed, A >::dis_entry_assembly_begin
void dis_entry_assembly_begin()
Definition disarray.h:715
rheolef::disarray< T, distributed, A >::value_type
rep::value_type value_type
Definition disarray.h:652
rheolef::disarray< T, distributed, A >::rep
disarray_rep< T, distributed, A > rep
Definition disarray.h:646
rheolef::disarray< T, distributed, A >::size
size_type size() const
Definition disarray.h:668
rheolef::disarray< T, distributed, A >::permuted_put_values
odiststream & permuted_put_values(odiststream &ops, const disarray< size_type, distributed, A2 > &perm, PutFunction put_element) const
Definition disarray.h:749
rheolef::disarray< T, distributed, A >::disarray
disarray(const distributor &ownership=distributor(), const T &init_val=T(), const A &alloc=A())
Definition disarray.h:756
rheolef::disarray< T, distributed, A >::repartition
void repartition(const RepSize &partition, disarray< T, distributed > &new_disarray, RepSize &old_numbering, RepSize &new_numbering) const
Definition disarray.h:722
rheolef::disarray< T, distributed, A >::reference
rep::reference reference
Definition disarray.h:653
rheolef::disarray< T, distributed, A >::append_dis_indexes
void append_dis_indexes(const Set &ext_idx_set) const
Definition disarray.h:692
rheolef::disarray< T, distributed, A >::put_values
odiststream & put_values(odiststream &ops, PutFunction put_element) const
Definition disarray.h:748
rheolef::disarray< T, distributed, A >::dis_entry_assembly_begin
void dis_entry_assembly_begin(SetOp my_set_op=SetOp())
Definition disarray.h:709
rheolef::disarray< T, distributed, A >::permutation_apply
void permutation_apply(const RepSize &new_numbering, disarray< T, distributed, A > &new_disarray) const
Definition disarray.h:730
rheolef::disarray< T, distributed, A >::iterator
rep::iterator iterator
Definition disarray.h:655
rheolef::disarray< T, distributed, A >::base
smart_pointer< rep > base
Definition disarray.h:647
rheolef::disarray< T, distributed, A >::const_reference
rep::const_reference const_reference
Definition disarray.h:656
rheolef::disarray< T, distributed, A >::get_allocator
A get_allocator() const
Definition disarray.h:667
rheolef::disarray< T, distributed, A >::dis_entry_assembly_end
void dis_entry_assembly_end(SetOp my_set_op=SetOp())
Definition disarray.h:711
rheolef::disarray< T, distributed, A >::get_dis_indexes
void get_dis_indexes(std::set< size_type > &ext_idx_set) const
Definition disarray.h:694
rheolef::disarray< T, distributed, A >::dis_entry_assembly
void dis_entry_assembly(SetOp my_set_op=SetOp())
Definition disarray.h:713
rheolef::disarray< T, distributed, A >::reverse_permutation
void reverse_permutation(disarray< size_type, distributed, A > &inew2dis_iold) const
Definition disarray.h:735
rheolef::disarray< T, distributed, A >::dump
void dump(std::string name) const
Definition disarray.h:743
rheolef::disarray< T, distributed, A >::size_type
rep::size_type size_type
Definition disarray.h:650
rheolef::disarray< T, distributed, A >::end
iterator end()
Definition disarray.h:680
rheolef::disarray< T, distributed, A >::end
const_iterator end() const
Definition disarray.h:681
rheolef::disarray< T, distributed, A >::begin
iterator begin()
Definition disarray.h:678
rheolef::disarray< T, distributed, A >::append_dis_entry
void append_dis_entry(const Set &ext_idx_set, Map &ext_idx_map) const
Definition disarray.h:686
rheolef::disarray< T, distributed, A >::ownership
const distributor & ownership() const
Definition disarray.h:670
rheolef::disarray< T, distributed, A >::get_values
idiststream & get_values(idiststream &ips, GetFunction get_element)
Definition disarray.h:746
rheolef::disarray< T, distributed, A >::memory_type
distributed memory_type
Definition disarray.h:649
rheolef::disarray< T, distributed, A >::comm
const communicator & comm() const
Definition disarray.h:671
rheolef::disarray< T, distributed, A >::get_values
idiststream & get_values(idiststream &ips)
Definition disarray.h:742
rheolef::disarray< T, sequential, A >::dis_entry_assembly_end
void dis_entry_assembly_end()
Definition disarray.h:562
rheolef::disarray< T, sequential, A >::reverse_permutation
void reverse_permutation(disarray< size_type, sequential, A > &inew2dis_iold) const
Definition disarray.h:588
rheolef::disarray< T, sequential, A >::const_iterator
rep::const_iterator const_iterator
Definition disarray.h:522
rheolef::disarray< T, sequential, A >::get_dis_entry
void get_dis_entry(const Set &ext_idx_set, Map &ext_idx_map) const
Definition disarray.h:570
rheolef::disarray< T, sequential, A >::dis_at
const_reference dis_at(size_type dis_i) const
Definition disarray.h:544
rheolef::disarray< T, sequential, A >::resize
void resize(size_type loc_size=0, const T &init_val=T())
Definition disarray.h:623
rheolef::disarray< T, sequential, A >::set_dis_indexes
void set_dis_indexes(const Set &ext_idx_set) const
Definition disarray.h:567
rheolef::disarray< T, sequential, A >::dis_reference
rep::dis_reference dis_reference
Definition disarray.h:519
rheolef::disarray< T, sequential, A >::rep
disarray_rep< T, sequential, A > rep
Definition disarray.h:511
rheolef::disarray< T, sequential, A >::begin
const_iterator begin() const
Definition disarray.h:547
rheolef::disarray< T, sequential, A >::dis_size
size_type dis_size() const
Definition disarray.h:536
rheolef::disarray< T, sequential, A >::dis_entry_assembly
void dis_entry_assembly()
Definition disarray.h:563
rheolef::disarray< T, sequential, A >::reset_dis_indexes
void reset_dis_indexes() const
Definition disarray.h:566
rheolef::disarray< T, sequential, A >::put_values
odiststream & put_values(odiststream &ops) const
Definition disarray.h:594
rheolef::disarray< T, sequential, A >::dis_entry
dis_reference dis_entry(size_type dis_i)
Definition disarray.h:553
rheolef::disarray< T, sequential, A >::memory_type
sequential memory_type
Definition disarray.h:514
rheolef::disarray< T, sequential, A >::difference_type
rep::difference_type difference_type
Definition disarray.h:516
rheolef::disarray< T, sequential, A >::dis_entry_assembly_begin
void dis_entry_assembly_begin()
Definition disarray.h:561
rheolef::disarray< T, sequential, A >::value_type
rep::value_type value_type
Definition disarray.h:517
rheolef::disarray< T, sequential, A >::disarray
disarray(size_type loc_size=0, const T &init_val=T(), const A &alloc=A())
Definition disarray.h:604
rheolef::disarray< T, sequential, A >::size
size_type size() const
Definition disarray.h:535
rheolef::disarray< T, sequential, A >::reference
rep::reference reference
Definition disarray.h:518
rheolef::disarray< T, sequential, A >::append_dis_indexes
void append_dis_indexes(const Set &ext_idx_set) const
Definition disarray.h:568
rheolef::disarray< T, sequential, A >::repartition
void repartition(const RepSize &partition, disarray< T, sequential, A > &new_disarray, RepSize &old_numbering, RepSize &new_numbering) const
Definition disarray.h:575
rheolef::disarray< T, sequential, A >::put_values
odiststream & put_values(odiststream &ops, PutFunction put_element) const
Definition disarray.h:599
rheolef::disarray< T, sequential, A >::dis_entry_assembly_begin
void dis_entry_assembly_begin(SetOp my_set_op=SetOp())
Definition disarray.h:557
rheolef::disarray< T, sequential, A >::iterator
rep::iterator iterator
Definition disarray.h:520
rheolef::disarray< T, sequential, A >::permutation_apply
void permutation_apply(const RepSize &new_numbering, disarray< T, sequential, A > &new_disarray) const
Definition disarray.h:583
rheolef::disarray< T, sequential, A >::base
smart_pointer< rep > base
Definition disarray.h:512
rheolef::disarray< T, sequential, A >::const_reference
rep::const_reference const_reference
Definition disarray.h:521
rheolef::disarray< T, sequential, A >::get_allocator
A get_allocator() const
Definition disarray.h:534
rheolef::disarray< T, sequential, A >::dis_entry_assembly_end
void dis_entry_assembly_end(SetOp my_set_op=SetOp())
Definition disarray.h:559
rheolef::disarray< T, sequential, A >::get_dis_indexes
void get_dis_indexes(std::set< size_type > &ext_idx_set) const
Definition disarray.h:565
rheolef::disarray< T, sequential, A >::dis_entry_assembly
void dis_entry_assembly(SetOp my_set_op=SetOp())
Definition disarray.h:555
rheolef::disarray< T, sequential, A >::dump
void dump(std::string name) const
Definition disarray.h:600
rheolef::disarray< T, sequential, A >::size_type
rep::size_type size_type
Definition disarray.h:515
rheolef::disarray< T, sequential, A >::end
iterator end()
Definition disarray.h:548
rheolef::disarray< T, sequential, A >::end
const_iterator end() const
Definition disarray.h:549
rheolef::disarray< T, sequential, A >::begin
iterator begin()
Definition disarray.h:546
rheolef::disarray< T, sequential, A >::append_dis_entry
void append_dis_entry(const Set &ext_idx_set, Map &ext_idx_map) const
Definition disarray.h:569
rheolef::disarray< T, sequential, A >::ownership
const distributor & ownership() const
Definition disarray.h:537
rheolef::disarray< T, sequential, A >::get_values
idiststream & get_values(idiststream &ips, GetFunction get_element)
Definition disarray.h:597
rheolef::disarray< T, sequential, A >::comm
const communicator & comm() const
Definition disarray.h:538
rheolef::disarray< T, sequential, A >::get_values
idiststream & get_values(idiststream &ips)
Definition disarray.h:595
rheolef::disarray_rep< T, distributed, A >::value_type
typename base::value_type value_type
Definition disarray.h:297
rheolef::disarray_rep< T, distributed, A >::get_dis_entry
void get_dis_entry(const Set &ext_idx_set, Map &ext_idx_map) const
Definition disarray.h:341
rheolef::disarray_rep< T, distributed, A >::set_dis_indexes
void set_dis_indexes(const Set &ext_idx_set) const
Definition disarray.h:350
rheolef::disarray_rep< T, distributed, A >::const_reference
typename base::const_reference const_reference
Definition disarray.h:302
rheolef::disarray_rep< T, distributed, A >::get_dis_map_entries
const scatter_map_type & get_dis_map_entries() const
Definition disarray.h:357
rheolef::disarray_rep< T, distributed, A >::reference
typename base::reference reference
Definition disarray.h:301
rheolef::disarray_rep< T, distributed, A >::begin
const_iterator begin() const
Definition disarray.h:316
rheolef::disarray_rep< T, distributed, A >::dis_size
size_type dis_size() const
Definition disarray.h:325
rheolef::disarray_rep< T, distributed, A >::dis_entry
dis_reference dis_entry(size_type dis_i)
Definition disarray.h:327
rheolef::disarray_rep< T, distributed, A >::_stash
stash_map_type _stash
Definition disarray.h:435
rheolef::disarray_rep< T, distributed, A >::stash_value
stash_traits< T, is_container >::mapped_type stash_value
Definition disarray.h:417
rheolef::disarray_rep< T, distributed, A >::scatter_map_type
std::map< size_type, T > scatter_map_type
Definition disarray.h:305
rheolef::disarray_rep< T, distributed, A >::first_index
size_type first_index() const
Definition disarray.h:323
rheolef::disarray_rep< T, distributed, A >::size
size_type size() const
Definition disarray.h:315
rheolef::disarray_rep< T, distributed, A >::dis_reference
disarray_dis_reference< T, A > dis_reference
Definition disarray.h:306
rheolef::disarray_rep< T, distributed, A >::is_container
details::is_container_of_mpi_datatype< T >::type is_container
Definition disarray.h:416
rheolef::disarray_rep< T, distributed, A >::memory_type
distributed memory_type
Definition disarray.h:298
rheolef::disarray_rep< T, distributed, A >::append_dis_indexes
void append_dis_indexes(const Set &ext_idx_set) const
Definition disarray.h:347
rheolef::disarray_rep< T, distributed, A >::_receive_max_size
size_type _receive_max_size
Definition disarray.h:438
rheolef::disarray_rep< T, distributed, A >::comm
const mpi::communicator & comm() const
Definition disarray.h:322
rheolef::disarray_rep< T, distributed, A >::dis_entry_assembly_begin
void dis_entry_assembly_begin(SetOp my_set_op=SetOp())
Definition disarray_mpi.icc:220
rheolef::disarray_rep< T, distributed, A >::base
disarray_rep< T, sequential, A > base
Definition disarray.h:295
rheolef::disarray_rep< T, distributed, A >::get_allocator
A get_allocator() const
Definition disarray.h:314
rheolef::disarray_rep< T, distributed, A >::communicator_type
distributor::communicator_type communicator_type
Definition disarray.h:304
rheolef::disarray_rep< T, distributed, A >::difference_type
typename base::difference_type difference_type
Definition disarray.h:303
rheolef::disarray_rep< T, distributed, A >::_ext_x
scatter_map_type _ext_x
Definition disarray.h:439
rheolef::disarray_rep< T, distributed, A >::size_type
typename base::size_type size_type
Definition disarray.h:296
rheolef::disarray_rep< T, distributed, A >::dis_entry_assembly_end
void dis_entry_assembly_end(SetOp my_set_op=SetOp())
Definition disarray_mpi.icc:235
rheolef::disarray_rep< T, distributed, A >::const_iterator
typename base::const_iterator const_iterator
Definition disarray.h:300
rheolef::disarray_rep< T, distributed, A >::_receive
message_type _receive
Definition disarray.h:437
rheolef::disarray_rep< T, distributed, A >::dis_entry_assembly
void dis_entry_assembly(SetOp my_set_op=SetOp())
Definition disarray.h:334
rheolef::disarray_rep< T, distributed, A >::end
iterator end()
Definition disarray.h:319
rheolef::disarray_rep< T, distributed, A >::end
const_iterator end() const
Definition disarray.h:317
rheolef::disarray_rep< T, distributed, A >::begin
iterator begin()
Definition disarray.h:318
rheolef::disarray_rep< T, distributed, A >::iterator
typename base::iterator iterator
Definition disarray.h:299
rheolef::disarray_rep< T, distributed, A >::_send
message_type _send
Definition disarray.h:436
rheolef::disarray_rep< T, distributed, A >::resize
void resize(const distributor &ownership, const T &init_val=T())
Definition disarray_mpi.icc:69
rheolef::disarray_rep< T, distributed, A >::disarray_rep
disarray_rep(const distributor &ownership, const T &init_val=T(), const A &alloc=A())
Definition disarray_mpi.icc:55
rheolef::disarray_rep< T, distributed, A >::append_dis_entry
void append_dis_entry(const Set &ext_idx_set, Map &ext_idx_map) const
get values from ext_idx_set, that are managed by another proc
Definition disarray_mpi.icc:509
rheolef::disarray_rep< T, distributed, A >::ownership
const distributor & ownership() const
Definition disarray.h:321
rheolef::disarray_rep< T, distributed, A >::last_index
size_type last_index() const
Definition disarray.h:324
rheolef::disarray_rep< T, distributed, A >::stash_map_type
stash_traits< T, is_container >::map_type stash_map_type
Definition disarray.h:418
rheolef::disarray_rep< T, sequential, A >::operator[]
reference operator[](size_type i)
Definition disarray.h:247
rheolef::disarray_rep< T, sequential, A >::dis_at
const_reference dis_at(size_type dis_i) const
Definition disarray.h:249
rheolef::disarray_rep< T, sequential, A >::value_type
T value_type
Definition disarray.h:219
rheolef::disarray_rep< T, sequential, A >::communicator_type
distributor::communicator_type communicator_type
Definition disarray.h:229
rheolef::disarray_rep< T, sequential, A >::begin
const_iterator begin() const
Definition disarray.h:242
rheolef::disarray_rep< T, sequential, A >::dis_size
size_type dis_size() const
Definition disarray.h:251
rheolef::disarray_rep< T, sequential, A >::dis_reference
reference dis_reference
Definition disarray.h:228
rheolef::disarray_rep< T, sequential, A >::reset_dis_indexes
void reset_dis_indexes() const
Definition disarray.h:256
rheolef::disarray_rep< T, sequential, A >::memory_type
sequential memory_type
Definition disarray.h:230
rheolef::disarray_rep< T, sequential, A >::iterator
base::iterator iterator
Definition disarray.h:224
rheolef::disarray_rep< T, sequential, A >::dis_entry_assembly_begin
void dis_entry_assembly_begin(SetOp=SetOp())
Definition disarray.h:258
rheolef::disarray_rep< T, sequential, A >::first_index
size_type first_index() const
Definition disarray.h:252
rheolef::disarray_rep< T, sequential, A >::size
size_type size() const
Definition disarray.h:240
rheolef::disarray_rep< T, sequential, A >::_ownership
distributor _ownership
Definition disarray.h:281
rheolef::disarray_rep< T, sequential, A >::size_type
base::size_type size_type
Definition disarray.h:223
rheolef::disarray_rep< T, sequential, A >::disarray_rep
disarray_rep(const A &alloc=A())
Definition disarray_seq.icc:28
rheolef::disarray_rep< T, sequential, A >::const_reference
base::const_reference const_reference
Definition disarray.h:226
rheolef::disarray_rep< T, sequential, A >::allocator_type
A allocator_type
Definition disarray.h:220
rheolef::disarray_rep< T, sequential, A >::get_allocator
A get_allocator() const
Definition disarray.h:239
rheolef::disarray_rep< T, sequential, A >::dis_entry_assembly_end
void dis_entry_assembly_end(SetOp=SetOp())
Definition disarray.h:260
rheolef::disarray_rep< T, sequential, A >::const_iterator
base::const_iterator const_iterator
Definition disarray.h:225
rheolef::disarray_rep< T, sequential, A >::difference_type
A::difference_type difference_type
Definition disarray.h:221
rheolef::disarray_rep< T, sequential, A >::end
iterator end()
Definition disarray.h:243
rheolef::disarray_rep< T, sequential, A >::end
const_iterator end() const
Definition disarray.h:244
rheolef::disarray_rep< T, sequential, A >::begin
iterator begin()
Definition disarray.h:241
rheolef::disarray_rep< T, sequential, A >::repartition
void repartition(const disarray_rep< size_type, sequential, A > &partition, disarray_rep< T, sequential, A > &new_disarray, disarray_rep< size_type, sequential, A > &old_numbering, disarray_rep< size_type, sequential, A > &new_numbering) const
Definition disarray.h:261
rheolef::disarray_rep< T, sequential, A >::reference
base::reference reference
Definition disarray.h:227
rheolef::disarray_rep< T, sequential, A >::resize
void resize(const distributor &ownership, const T &init_val=T())
Definition disarray_seq.icc:54
rheolef::disarray_rep< T, sequential, A >::base
std::vector< T > base
Definition disarray.h:222
rheolef::disarray_rep< T, sequential, A >::ownership
const distributor & ownership() const
Definition disarray.h:245
rheolef::disarray_rep< T, sequential, A >::last_index
size_type last_index() const
Definition disarray.h:253
rheolef::disarray_rep< T, sequential, A >::dis_entry
reference dis_entry(size_type dis_i)
Definition disarray.h:254
rheolef::disarray_rep
Definition disarray.h:214
rheolef::disarray
see the disarray page for the full documentation
Definition disarray.h:497
rheolef::disarray< row_type, M, A >::rep
disarray_rep< row_type, sequential, A > rep
Definition disarray.h:500
rheolef::disarray< row_type, M, A >::const_iterator
rep::base::const_iterator const_iterator
Definition disarray.h:503
rheolef::disarray< row_type, M, A >::memory_type
M memory_type
Definition disarray.h:499
rheolef::disarray< row_type, M, A >::iterator
rep::base::iterator iterator
Definition disarray.h:502
rheolef::disarray< row_type, M, A >::size_type
rep::base::size_type size_type
Definition disarray.h:501
rheolef::distributor
see the distributor page for the full documentation
Definition distributor.h:69
rheolef::distributor::communicator_type
communicator communicator_type
Definition distributor.h:79
rheolef::idiststream
idiststream: see the diststream page for the full documentation
Definition diststream.h:336
rheolef::odiststream
odiststream: see the diststream page for the full documentation
Definition diststream.h:137
rheolef::smart_pointer_base::data
const T & data() const
Definition smart_pointer.h:266
rheolef::smart_pointer< disarray_rep< T, sequential, A > >::smart_pointer
smart_pointer(T *p=0)
Definition smart_pointer.h:357
trace_macro
#define trace_macro(message)
Definition dis_macros.h:111
error_macro
#define error_macro(message)
Definition dis_macros.h:49
T
Expr1::float_type T
Definition field_expr.h:230
dump
verbose clean transpose logscale grid shrink ball stereo iso volume skipvtk deformation fastfieldload lattice reader_on_stdin color format format format format format format format format format format format format format format format format format format dump
Definition iorheo-members.h:119
rheolef::details
Definition compiler_eigen.h:39
rheolef
This file is part of Rheolef.
Definition compiler_eigen.h:39
rheolef::operator<<
std::ostream & operator<<(std::ostream &os, const catchmark &m)
Definition catchmark.h:99
rheolef::operator>>
std::istream & operator>>(std::istream &is, const catchmark &m)
Definition catchmark.h:88
rheolef::operator()
t operator()(const t &a, const t &b)
Definition space.cc:386
std
STL namespace.
A
Definition diffusion_isotropic.h:25
rheolef::_disarray_get_element_type
disarray element input helper
Definition disarray.h:205
rheolef::_disarray_get_element_type::operator()
std::istream & operator()(std::istream &is, T &x) const
Definition disarray.h:206
rheolef::_disarray_put_element_type
disarray element output helper
Definition disarray.h:196
rheolef::_disarray_put_element_type::operator()
std::ostream & operator()(std::ostream &os, const T &x) const
Definition disarray.h:197
rheolef::_disarray_put_matlab_type
Definition disarray.h:200
rheolef::_disarray_put_matlab_type::operator()
std::ostream & operator()(std::ostream &os, const T &x) const
Definition disarray.h:201
rheolef::details::is_class_reference
Definition msg_util.h:139
rheolef::details::is_container_of_mpi_datatype::type
std::false_type type
Definition msg_util.h:241
rheolef::disarray_dis_reference
Definition disarray.h:445
rheolef::disarray_dis_reference::_x
disarray_rep< T, distributed, A > & _x
Definition disarray.h:482
rheolef::disarray_dis_reference::operator-=
disarray_dis_reference< T, A > & operator-=(const U &value)
Definition disarray.h:475
rheolef::disarray_dis_reference::operator=
disarray_dis_reference< T, A > & operator=(const disarray_dis_reference< T, A > &r)
Definition disarray.h:456
rheolef::disarray_dis_reference::disarray_dis_reference
disarray_dis_reference(disarray_rep< T, distributed, A > &x, size_type dis_i)
Definition disarray.h:448
rheolef::disarray_dis_reference::size_type
typename disarray_rep< T, distributed, A >::size_type size_type
Definition disarray.h:446
rheolef::disarray_dis_reference::_dis_i
size_type _dis_i
Definition disarray.h:483
rheolef::disarray_dis_reference::operator+=
disarray_dis_reference< T, A > & operator+=(const U &value)
Definition disarray.h:468
rheolef::disarray_dis_reference::disarray_dis_reference
disarray_dis_reference(const disarray_dis_reference< T, A > &r)
Definition disarray.h:452
rheolef::disarray_rep< T, distributed, A >::message_type
Definition disarray.h:422
rheolef::disarray_rep< T, distributed, A >::message_type::data
std::vector< std::pair< size_type, stash_value > > data
Definition disarray.h:424
rheolef::disarray_rep< T, distributed, A >::message_type::waits
std::list< std::pair< size_type, mpi::request > > waits
Definition disarray.h:423
rheolef::disarray_rep< T, distributed, A >::message_type::message_type
message_type()
Definition disarray.h:425
rheolef::disarray_rep< T, distributed, A >::remove_const_in_pair< std::pair< T1, T2 > >::type
std::pair< typename std::decay< T1 >::type, typename std::decay< T2 >::type > type
Definition disarray.h:403
rheolef::disarray_rep< T, distributed, A >::remove_const_in_pair
Definition disarray.h:397
rheolef::disarray_rep< T, distributed, A >::remove_const_in_pair::type
Pair type
Definition disarray.h:398
rheolef::disarray_rep< T, distributed, A >::stash_traits< U, std::false_type >::map_type
std::map< size_type, U > map_type
Definition disarray.h:409
rheolef::disarray_rep< T, distributed, A >::stash_traits< U, std::false_type >::mapped_type
U mapped_type
Definition disarray.h:408
rheolef::disarray_rep< T, distributed, A >::stash_traits< U, std::true_type >::mapped_type
remove_const_in_pair< typenameU::value_type >::type mapped_type
Definition disarray.h:413
rheolef::disarray_rep< T, distributed, A >::stash_traits< U, std::true_type >::map_type
std::multimap< size_type, mapped_type > map_type
Definition disarray.h:414
rheolef::disarray_rep< T, distributed, A >::stash_traits
Definition disarray.h:405
rheolef::distributed
Definition communicator.h:128
rheolef::sequential
Definition communicator.h:62
M
Expr1::memory_type M
Definition vec_expr_v2.h:416