← Back to branch summary

~ubuntu-branches/ubuntu/trusty/rheolef/trusty

« back to all changes in this revision

Viewing changes to skit/plib2/vec.h

  • Committer: Package Import Robot
  • Author(s): Pierre Saramito
  • Date: 2012-04-06 09:12:21 UTC
  • mfrom: (1.1.5)
  • Revision ID: package-import@ubuntu.com-20120406091221-m58me99p1nxqui49
Tags: 6.0-1
http://bugs.debian.org/667356
http://bugs.debian.org/661689
* New upstream release 6.0 (major changes):
  - massively distributed and parallel support
  - full FEM characteristic method (Lagrange-Gakerkin method) support
  - enhanced users documentation 
  - source code supports g++-4.7 (closes: #667356)
* debian/control: dependencies for MPI distributed solvers added
* debian/rules: build commands simplified
* debian/librheolef-dev.install: man1/* to man9/* added
* debian/changelog: package description rewritted (closes: #661689)

Show diffs side-by-side

added added

removed removed

Lines of Context:
skit/plib2/vec.h
22
22
/// =========================================================================
23
23
 
24
24
# include "rheolef/array.h"
 
25
# include "boost/numeric/ublas/storage.hpp"
 
26
 
25
27
namespace rheolef {
26
28
 
 
29
// for vec[range]:
 
30
using boost::numeric::ublas::basic_range;
 
31
using boost::numeric::ublas::range;
 
32
template <class Expr>       struct vec_expr;
 
33
template <class T, class M> class vec_range;
 
34
template <class T, class M> class vec_range_const;
 
35
 
 
36
// for vec = {x,y};
 
37
template <class T, class M> class vec_concat_value;
 
38
 
27
39
/*Class:vec
28
 
NAME:  vec - vector in distributed environment (@PACKAGE@-@VERSION@)
 
40
NAME: @code{vec} - vector in distributed environment (@PACKAGE@-@VERSION@)
29
41
SYNOPSYS:       
30
42
 STL-like vector container for a sequential or
31
43
 distributed memory machine model.
36
48
     int main(int argc, char**argv) @{
37
49
        environment distributed(argc, argv);
38
50
        vec<double> x(100, 3.14);
39
 
        dcout << x << endl;
 
51
        dout << x << endl;
40
52
     @}
41
53
   @end example
42
54
IMPLEMENTATION NOTE:
55
67
// typedef:
56
68
 
57
69
    typedef array<T, M> base;
58
 
    typedef typename base::size_type       size_type;
59
 
    typedef typename base::iterator        iterator;
60
 
    typedef typename base::const_iterator  const_iterator;
 
70
    typedef typename base::size_type                         size_type;
 
71
    typedef std::ptrdiff_t                                   difference_type;
 
72
#ifdef TODO
 
73
    // pb compile avec boost sur foehn:
 
74
    typedef typename base::difference_type                   difference_type;
 
75
#endif // TODO
 
76
    typedef basic_range<size_type, difference_type>          range_type;
 
77
    typedef typename base::reference                         reference;
 
78
    typedef typename base::const_reference                   const_reference;
 
79
    typedef typename base::iterator                          iterator;
 
80
    typedef typename base::const_iterator                    const_iterator;
61
81
 
62
82
// allocator/deallocator:
63
83
 
75
95
        size_type size = 0,
76
96
        const T&  init_val = std::numeric_limits<T>::max());
77
97
 
 
98
// accessors:
 
99
 
 
100
    const_reference operator[] (size_type i) const;
 
101
    reference       operator[] (size_type i);
 
102
 
 
103
    T max_abs () const;
 
104
 
 
105
// range:
 
106
 
 
107
    vec(const vec_range<T,M>& vr);
 
108
    vec(const vec_range_const<T,M>& vr);
 
109
    vec<T,M>& operator= (const vec_range<T,M>& vr);
 
110
    vec<T,M>& operator= (const vec_range_const<T,M>& vr);
 
111
 
 
112
    vec_range_const<T,M> operator[] (const range_type& r) const;
 
113
    vec_range<T,M>       operator[] (const range_type& r);
 
114
 
 
115
// assignment to a constant:
 
116
 
 
117
    vec<T,M>& operator= (const int& expr);
 
118
    vec<T,M>& operator= (const T& expr);
 
119
 
78
120
// expression template:
79
121
 
80
122
    template<typename Expr>
81
123
    vec (const Expr& expr);
82
124
 
83
125
    template<typename Expr>
84
 
    vec<T,M>& operator= (const Expr& expr);
 
126
    vec<T,M>& operator= (const vec_expr<Expr>& expr);
85
127
 
86
128
    template<typename Expr>
87
129
    vec<T,M>& operator+= (const Expr& expr);
88
130
 
89
131
    template<typename Expr>
90
132
    vec<T,M>& operator-= (const Expr& expr);
 
133
 
 
134
// initializer list (c++ 2011):
 
135
 
 
136
#ifdef _RHEOLEF_HAVE_STD_INITIALIZER_LIST
 
137
    vec (const std::initializer_list<vec_concat_value<T,M> >& init_list);
 
138
    vec<T,M>& operator= (const std::initializer_list<vec_concat_value<T,M> >& init_list);
 
139
#endif // _RHEOLEF_HAVE_STD_INITIALIZER_LIST
91
140
};
92
141
//>vec:
93
142
 
117
166
        const distributor& ownership,
118
167
        const T&  init_val)
119
168
{
120
 
    array<T,M>::resize (ownership, init_val);
 
169
    base::resize (ownership, init_val);
121
170
}
122
171
template <class T, class M>
123
172
inline
126
175
        size_type dis_size,
127
176
        const T&  init_val)
128
177
{
129
 
    array<T,M>::resize (dis_size, init_val);
 
178
    base::resize (dis_size, init_val);
 
179
}
 
180
template <class T, class M>
 
181
inline
 
182
vec<T,M>&
 
183
vec<T,M>::operator= (const int& expr)
 
184
{
 
185
    std::fill (array<T,M>::begin(), array<T,M>::end(), expr);
 
186
    return *this;
 
187
}
 
188
template <class T, class M>
 
189
inline
 
190
vec<T,M>&
 
191
vec<T,M>::operator= (const T& expr)
 
192
{
 
193
    std::fill (array<T,M>::begin(), array<T,M>::end(), expr);
 
194
    return *this;
 
195
}
 
196
template <class T, class M>
 
197
inline
 
198
vec<T,M>&
 
199
vec<T,M>::operator= (const vec_range_const<T,M>& vr)
 
200
{
 
201
    distributor ownership (distributor::decide, vr._u.comm(), vr._r.size());
 
202
    resize (ownership);
 
203
    std::copy (vr.begin(), vr.end(), base::begin());
 
204
    return *this;
 
205
}
 
206
template <class T, class M>
 
207
inline
 
208
vec<T,M>&
 
209
vec<T,M>::operator= (const vec_range<T,M>& vr)
 
210
{
 
211
    operator= (vec_range_const<T,M>(vr));
 
212
    return *this;
 
213
}
 
214
template <class T, class M>
 
215
inline
 
216
vec<T,M>::vec(const vec_range<T,M>& vr)
 
217
  : array<T,M>()
 
218
{
 
219
    operator= (vr);
 
220
}
 
221
template <class T, class M>
 
222
inline
 
223
vec<T,M>::vec(const vec_range_const<T,M>& vr)
 
224
  : array<T,M>()
 
225
{
 
226
    operator= (vr);
 
227
}
 
228
template <class T, class M>
 
229
inline
 
230
typename vec<T,M>::const_reference
 
231
vec<T,M>::operator[] (size_type i) const
 
232
{
 
233
    return base::operator[] (i);
 
234
}
 
235
template <class T, class M>
 
236
inline
 
237
typename vec<T,M>::reference
 
238
vec<T,M>::operator[] (size_type i)
 
239
{
 
240
    return base::operator[] (i);
 
241
}
 
242
template <class T, class M>
 
243
inline
 
244
vec_range<T,M>
 
245
vec<T,M>::operator[] (const range_type& r)
 
246
{
 
247
    return vec_range<T,M> (*this, r);
 
248
}
 
249
template <class T, class M>
 
250
inline
 
251
vec_range_const<T,M>
 
252
vec<T,M>::operator[] (const range_type& r) const
 
253
{
 
254
    return vec_range_const<T,M> (*this, r);
 
255
}
 
256
template <class T, class M>
 
257
inline
 
258
T
 
259
vec<T,M>::max_abs () const
 
260
{
 
261
    T val = 0;
 
262
    for (const_iterator iter = base::begin(), last = base::end(); iter != last; iter++) {
 
263
      val = std::max(val, abs(*iter));
 
264
    }
 
265
#ifdef _RHEOLEF_HAVE_MPI
 
266
    val = mpi::all_reduce (base::comm(), val, mpi::maximum<T>());
 
267
#endif // _RHEOLEF_HAVE_MPI
 
268
    return val;
130
269
}
131
270
template <class T>
132
271
inline