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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 478 - (show annotations)
Tue Jan 31 02:21:49 2006 UTC (13 years, 7 months ago) by jgs
File MIME type: text/plain
File size: 8585 byte(s)
rationalise #includes

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

Properties

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

  ViewVC Help
Powered by ViewVC 1.1.26