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

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

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

trunk/esys2/escript/src/Data/DataAlgorithm.h revision 121 by jgs, Fri May 6 04:26:16 2005 UTC trunk/escript/src/DataAlgorithm.h revision 478 by jgs, Tue Jan 31 02:21:49 2006 UTC
# Line 16  Line 16 
16  #if !defined escript_DataAlgorithm_20040714_H  #if !defined escript_DataAlgorithm_20040714_H
17  #define escript_DataAlgorithm_20040714_H  #define escript_DataAlgorithm_20040714_H
18    
19  #include "escript/Data/DataExpanded.h"  #include "DataArrayView.h"
20  #include "escript/Data/DataTagged.h"  #include "DataExpanded.h"
21  #include "escript/Data/DataConstant.h"  #include "DataTagged.h"
22  #include "escript/Data/DataArrayView.h"  #include "DataConstant.h"
23    
24  #include <iostream>  #include <iostream>
25  #include <algorithm>  #include <algorithm>
26  #include <math.h>  #include <math.h>
 #include <limits>  
 #include <vector>  
27    
28  namespace escript {  namespace escript {
29    
# Line 47  class DataAlgorithmAdapter { Line 45  class DataAlgorithmAdapter {
45        m_currentValue(initialValue)        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)      inline void operator()(double value)
55      {      {
56        m_currentValue=operation(m_currentValue,value);        m_currentValue=operation(m_currentValue,value);
# Line 151  struct Trace : public std::binary_functi Line 155  struct Trace : public std::binary_functi
155    
156     Calls DataArrayView::reductionOp     Calls DataArrayView::reductionOp
157  */  */
158  template <class UnaryFunction>  template <class BinaryFunction>
159  inline  inline
160  double  double
161  algorithm(DataExpanded& data,  algorithm(DataExpanded& data,
162            UnaryFunction operation)            BinaryFunction operation,
163          double initial_value)
164  {  {
165    int i,j;    int i,j;
166    int numDPPSample=data.getNumDPPSample();    int numDPPSample=data.getNumDPPSample();
167    int numSamples=data.getNumSamples();    int numSamples=data.getNumSamples();
168    int resultVectorLength=numDPPSample*numSamples;    double global_current_value=initial_value;
169    std::vector<double> resultVector(resultVectorLength);    double local_current_value;
170    DataArrayView dataView=data.getPointDataView();    DataArrayView dataView=data.getPointDataView();
171    // calculate the reduction operation value for each data point    // calculate the reduction operation value for each data point
172    // storing the result for each data-point in successive entries    // reducing the result for each data-point into the current_value variables
173    // in resultVector    #pragma omp parallel private(local_current_value)
174    {    {
175  #pragma omp for private(i,j) schedule(static)        local_current_value=initial_value;
176      for (i=0;i<numSamples;i++) {        #pragma omp for private(i,j) schedule(static)
177        for (j=0;j<numDPPSample;j++) {        for (i=0;i<numSamples;i++) {
178  #pragma omp critical (reductionOp)          for (j=0;j<numDPPSample;j++) {
179      resultVector[j*numSamples+i]=dataView.reductionOp(data.getPointOffset(i,j),operation);            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    // now calculate the reduction operation value across the results    return global_current_value;
   // for each data-point  
   operation.resetResult();  
   for (int l=0;l<resultVectorLength;l++) {  
     operation(resultVector[l]);  
   }  
   return operation.getResult();  
186  }  }
187    
188  template <class UnaryFunction>  template <class BinaryFunction>
189  inline  inline
190  double  double
191  algorithm(DataTagged& data,  algorithm(DataTagged& data,
192            UnaryFunction operation)            BinaryFunction operation,
193          double initial_value)
194  {  {
195    const DataTagged::DataMapType& lookup=data.getTagLookup();    const DataTagged::DataMapType& lookup=data.getTagLookup();
196    DataTagged::DataMapType::const_iterator i;    DataTagged::DataMapType::const_iterator i;
197    DataTagged::DataMapType::const_iterator lookupEnd=lookup.end();    DataTagged::DataMapType::const_iterator lookupEnd=lookup.end();
198    DataArrayView& dataView=data.getPointDataView();    DataArrayView& dataView=data.getPointDataView();
199    std::vector<double> resultVector;    double current_value=initial_value;
   int resultVectorLength;  
200    // perform the operation on each tagged value    // perform the operation on each tagged value
201    for (i=lookup.begin();i!=lookupEnd;i++) {    for (i=lookup.begin();i!=lookupEnd;i++) {
202      resultVector.push_back(dataView.reductionOp(i->second,operation));      current_value=operation(current_value,dataView.reductionOp(i->second,operation,initial_value));
203    }    }
204    // perform the operation on the default value    // perform the operation on the default value
205    resultVector.push_back(data.getDefaultValue().reductionOp(operation));    current_value=operation(current_value,data.getDefaultValue().reductionOp(operation,initial_value));
206    // now calculate the reduction operation value across the results    return current_value;
   // for each tagged value  
   resultVectorLength=resultVector.size();  
   operation.resetResult();  
   for (int l=0;l<resultVectorLength;l++) {  
     operation(resultVector[l]);  
   }  
   return operation.getResult();  
207  }  }
208    
209  template <class UnaryFunction>  template <class BinaryFunction>
210  inline  inline
211  double  double
212  algorithm(DataConstant& data,  algorithm(DataConstant& data,
213            UnaryFunction operation)            BinaryFunction operation,
214          double initial_value)
215  {  {
216    return data.getPointDataView().reductionOp(operation);    return data.getPointDataView().reductionOp(operation,initial_value);
217  }  }
218    
219  /**  /**
# Line 232  algorithm(DataConstant& data, Line 227  algorithm(DataConstant& data,
227    
228     Calls DataArrayView::reductionOp     Calls DataArrayView::reductionOp
229  */  */
230  template <class UnaryFunction>  template <class BinaryFunction>
231  inline  inline
232  void  void
233  dp_algorithm(DataExpanded& data,  dp_algorithm(DataExpanded& data,
234               DataExpanded& result,               DataExpanded& result,
235               UnaryFunction operation)               BinaryFunction operation,
236             double initial_value)
237  {  {
238    int i,j;    int i,j;
239    int numSamples=data.getNumSamples();    int numSamples=data.getNumSamples();
# Line 246  dp_algorithm(DataExpanded& data, Line 242  dp_algorithm(DataExpanded& data,
242    DataArrayView resultView=result.getPointDataView();    DataArrayView resultView=result.getPointDataView();
243    // perform the operation on each data-point and assign    // perform the operation on each data-point and assign
244    // this to the corresponding element in result    // this to the corresponding element in result
245    {    #pragma omp parallel for private(i,j) schedule(static)
246  #pragma omp for private(i,j) schedule(static)    for (i=0;i<numSamples;i++) {
247      for (i=0;i<numSamples;i++) {      for (j=0;j<numDPPSample;j++) {
248        for (j=0;j<numDPPSample;j++) {        resultView.getData(result.getPointOffset(i,j)) =
249  #pragma omp critical (reductionOp)          dataView.reductionOp(data.getPointOffset(i,j),operation,initial_value);
         resultView.getData(result.getPointOffset(i,j)) =  
           dataView.reductionOp(data.getPointOffset(i,j),operation);  
       }  
250      }      }
251    }    }
252  }  }
253    
254  template <class UnaryFunction>  template <class BinaryFunction>
255  inline  inline
256  void  void
257  dp_algorithm(DataTagged& data,  dp_algorithm(DataTagged& data,
258               DataTagged& result,               DataTagged& result,
259               UnaryFunction operation)               BinaryFunction operation,
260             double initial_value)
261  {  {
262    const DataTagged::DataMapType& lookup=data.getTagLookup();    const DataTagged::DataMapType& lookup=data.getTagLookup();
263    DataTagged::DataMapType::const_iterator i;    DataTagged::DataMapType::const_iterator i;
# Line 274  dp_algorithm(DataTagged& data, Line 268  dp_algorithm(DataTagged& data,
268    // and assign this to the corresponding element in result    // and assign this to the corresponding element in result
269    for (i=lookup.begin();i!=lookupEnd;i++) {    for (i=lookup.begin();i!=lookupEnd;i++) {
270      resultView.getData(i->second) =      resultView.getData(i->second) =
271        dataView.reductionOp(i->second,operation);        dataView.reductionOp(i->second,operation,initial_value);
272    }    }
273    // perform the operation on the default data value    // perform the operation on the default data value
274    // and assign this to the default element in result    // and assign this to the default element in result
275    resultView.getData(0) =    resultView.getData(0) =
276      data.getDefaultValue().reductionOp(operation);      data.getDefaultValue().reductionOp(operation,initial_value);
277  }  }
278    
279  template <class UnaryFunction>  template <class BinaryFunction>
280  inline  inline
281  void  void
282  dp_algorithm(DataConstant& data,  dp_algorithm(DataConstant& data,
283               DataConstant& result,               DataConstant& result,
284               UnaryFunction operation)               BinaryFunction operation,
285             double initial_value)
286  {  {
287    // perform the operation on the data value    // perform the operation on the data value
288    // and assign this to the element in result    // and assign this to the element in result
289    result.getPointDataView().getData(0) =    result.getPointDataView().getData(0) =
290      data.getPointDataView().reductionOp(operation);      data.getPointDataView().reductionOp(operation,initial_value);
291  }  }
292    
293  } // end of namespace  } // end of namespace
294    
295  #endif  #endif

Legend:
Removed from v.121  
changed lines
  Added in v.478

  ViewVC Help
Powered by ViewVC 1.1.26