/[escript]/trunk/escript/src/DataAlgorithm.h
ViewVC logotype

Contents of /trunk/escript/src/DataAlgorithm.h

Parent Directory Parent Directory | Revision Log Revision Log


Revision 148 - (show annotations)
Tue Aug 23 01:24:31 2005 UTC (14 years, 1 month ago) by jgs
Original Path: trunk/esys2/escript/src/Data/DataAlgorithm.h
File MIME type: text/plain
File size: 8673 byte(s)
Merge of development branch dev-02 back to main trunk on 2005-08-23

1 // $Id$
2 /*
3 ******************************************************************************
4 * *
5 * COPYRIGHT ACcESS 2004 - All Rights Reserved *
6 * *
7 * This software is the property of ACcESS. No part of this code *
8 * may be copied in any form or by any means without the expressed written *
9 * consent of ACcESS. Copying, use or modification of this software *
10 * by any unauthorised person is illegal unless that person has a software *
11 * license agreement with ACcESS. *
12 * *
13 ******************************************************************************
14 */
15
16 #if !defined escript_DataAlgorithm_20040714_H
17 #define escript_DataAlgorithm_20040714_H
18
19 #include "escript/Data/DataExpanded.h"
20 #include "escript/Data/DataTagged.h"
21 #include "escript/Data/DataConstant.h"
22 #include "escript/Data/DataArrayView.h"
23
24 #include <iostream>
25 #include <algorithm>
26 #include <math.h>
27 #include <limits>
28 #include <vector>
29
30 namespace escript {
31
32 /**
33 \brief
34 Adapt binary algorithms so they may be used in DataArrayView reduction operations.
35
36 Description:
37 This functor adapts the given BinaryFunction operation by starting with the
38 given inital value applying this operation to successive values, storing the
39 rolling result in m_currentValue - which can be accessed or reset by getResult
40 and resetResult respectively.
41 */
42 template <class BinaryFunction>
43 class DataAlgorithmAdapter {
44 public:
45 DataAlgorithmAdapter(double initialValue):
46 m_initialValue(initialValue),
47 m_currentValue(initialValue)
48 {
49 }
50 DataAlgorithmAdapter(const DataAlgorithmAdapter& other):
51 m_initialValue(other.m_initialValue),
52 m_currentValue(other.m_initialValue),
53 operation(other.operation)
54 {
55 }
56 inline void operator()(double value)
57 {
58 m_currentValue=operation(m_currentValue,value);
59 return;
60 }
61 inline void resetResult()
62 {
63 m_currentValue=m_initialValue;
64 }
65 inline double getResult() const
66 {
67 return m_currentValue;
68 }
69 private:
70 //
71 // the initial operation value
72 double m_initialValue;
73 //
74 // the current operation value
75 double m_currentValue;
76 //
77 // The operation to perform
78 BinaryFunction operation;
79 };
80
81 /**
82 \brief
83 Return the maximum value of the two given values.
84 */
85 struct FMax : public std::binary_function<double,double,double>
86 {
87 inline double operator()(double x, double y) const
88 {
89 return std::max(x,y);
90 }
91 };
92
93 /**
94 \brief
95 Return the minimum value of the two given values.
96 */
97 struct FMin : public std::binary_function<double,double,double>
98 {
99 inline double operator()(double x, double y) const
100 {
101 return std::min(x,y);
102 }
103 };
104
105 /**
106 \brief
107 Return the absolute maximum value of the two given values.
108 */
109 struct AbsMax : public std::binary_function<double,double,double>
110 {
111 inline double operator()(double x, double y) const
112 {
113 return std::max(fabs(x),fabs(y));
114 }
115 };
116
117 /**
118 \brief
119 Return the absolute minimum value of the two given values.
120 */
121 struct AbsMin : public std::binary_function<double,double,double>
122 {
123 inline double operator()(double x, double y) const
124 {
125 return std::min(fabs(x),fabs(y));
126 }
127 };
128
129 /**
130 \brief
131 Return the length between the two given values.
132 */
133 struct Length : public std::binary_function<double,double,double>
134 {
135 inline double operator()(double x, double y) const
136 {
137 return std::sqrt(std::pow(x,2)+std::pow(y,2));
138 }
139 };
140
141 /**
142 \brief
143 Return the trace of the two given values.
144 */
145 struct Trace : public std::binary_function<double,double,double>
146 {
147 inline double operator()(double x, double y) const
148 {
149 return x+y;
150 }
151 };
152
153 /**
154 \brief
155 Perform the given operation upon all values in all data-points in the
156 given Data object and return the final result.
157
158 Calls DataArrayView::reductionOp
159 */
160 template <class BinaryFunction>
161 inline
162 double
163 algorithm(DataExpanded& data,
164 BinaryFunction operation,
165 double initial_value)
166 {
167 int i,j;
168 int numDPPSample=data.getNumDPPSample();
169 int numSamples=data.getNumSamples();
170 double global_current_value=initial_value;
171 double local_current_value;
172 DataArrayView dataView=data.getPointDataView();
173 // calculate the reduction operation value for each data point
174 // reducing the result for each data-point into the current_value variables
175 #pragma omp parallel private(local_current_value)
176 {
177 local_current_value=initial_value;
178 #pragma omp for private(i,j) schedule(static)
179 for (i=0;i<numSamples;i++) {
180 for (j=0;j<numDPPSample;j++) {
181 local_current_value=operation(local_current_value,dataView.reductionOp(data.getPointOffset(i,j),operation,initial_value));
182 }
183 }
184 #pragma omp critical
185 global_current_value=operation(global_current_value,local_current_value);
186 }
187 return global_current_value;
188 }
189
190 template <class BinaryFunction>
191 inline
192 double
193 algorithm(DataTagged& data,
194 BinaryFunction operation,
195 double initial_value)
196 {
197 const DataTagged::DataMapType& lookup=data.getTagLookup();
198 DataTagged::DataMapType::const_iterator i;
199 DataTagged::DataMapType::const_iterator lookupEnd=lookup.end();
200 DataArrayView& dataView=data.getPointDataView();
201 double current_value=initial_value;
202 // perform the operation on each tagged value
203 for (i=lookup.begin();i!=lookupEnd;i++) {
204 current_value=operation(current_value,dataView.reductionOp(i->second,operation,initial_value));
205 }
206 // perform the operation on the default value
207 current_value=operation(current_value,data.getDefaultValue().reductionOp(operation,initial_value));
208 return current_value;
209 }
210
211 template <class BinaryFunction>
212 inline
213 double
214 algorithm(DataConstant& data,
215 BinaryFunction operation,
216 double initial_value)
217 {
218 return data.getPointDataView().reductionOp(operation,initial_value);
219 }
220
221 /**
222 \brief
223 Perform the given data-point reduction operation on all data-points
224 in data, storing results in corresponding data-points of result.
225
226 Objects data and result must be of the same type, and have the same number
227 of data points, but where data has data points of rank n, result must have
228 data points of rank 0.
229
230 Calls DataArrayView::reductionOp
231 */
232 template <class BinaryFunction>
233 inline
234 void
235 dp_algorithm(DataExpanded& data,
236 DataExpanded& result,
237 BinaryFunction operation,
238 double initial_value)
239 {
240 int i,j;
241 int numSamples=data.getNumSamples();
242 int numDPPSample=data.getNumDPPSample();
243 DataArrayView dataView=data.getPointDataView();
244 DataArrayView resultView=result.getPointDataView();
245 // perform the operation on each data-point and assign
246 // this to the corresponding element in result
247 #pragma omp parallel for private(i,j) schedule(static)
248 for (i=0;i<numSamples;i++) {
249 for (j=0;j<numDPPSample;j++) {
250 resultView.getData(result.getPointOffset(i,j)) =
251 dataView.reductionOp(data.getPointOffset(i,j),operation,initial_value);
252 }
253 }
254 }
255
256 template <class BinaryFunction>
257 inline
258 void
259 dp_algorithm(DataTagged& data,
260 DataTagged& result,
261 BinaryFunction operation,
262 double initial_value)
263 {
264 const DataTagged::DataMapType& lookup=data.getTagLookup();
265 DataTagged::DataMapType::const_iterator i;
266 DataTagged::DataMapType::const_iterator lookupEnd=lookup.end();
267 DataArrayView dataView=data.getPointDataView();
268 DataArrayView resultView=result.getPointDataView();
269 // perform the operation on each tagged data value
270 // and assign this to the corresponding element in result
271 for (i=lookup.begin();i!=lookupEnd;i++) {
272 resultView.getData(i->second) =
273 dataView.reductionOp(i->second,operation,initial_value);
274 }
275 // perform the operation on the default data value
276 // and assign this to the default element in result
277 resultView.getData(0) =
278 data.getDefaultValue().reductionOp(operation,initial_value);
279 }
280
281 template <class BinaryFunction>
282 inline
283 void
284 dp_algorithm(DataConstant& data,
285 DataConstant& result,
286 BinaryFunction operation,
287 double initial_value)
288 {
289 // perform the operation on the data value
290 // and assign this to the element in result
291 result.getPointDataView().getData(0) =
292 data.getPointDataView().reductionOp(operation,initial_value);
293 }
294
295 } // end of namespace
296
297 #endif

Properties

Name Value
svn:eol-style native
svn:keywords Author Date Id Revision

  ViewVC Help
Powered by ViewVC 1.1.26