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

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

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

revision 100 by jgs, Wed Dec 15 03:48:48 2004 UTC revision 147 by jgs, Fri Aug 12 01:45:47 2005 UTC
# Line 1  Line 1 
1    // $Id$
2  /*  /*
3   ******************************************************************************   ******************************************************************************
4   *                                                                            *   *                                                                            *
# Line 12  Line 13 
13   ******************************************************************************   ******************************************************************************
14  */  */
15                                                                                                                                                        
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 "escript/Data/DataExpanded.h"
# Line 24  Line 25 
25  #include <algorithm>  #include <algorithm>
26  #include <math.h>  #include <math.h>
27  #include <limits>  #include <limits>
28    #include <vector>
29    
30  namespace escript {  namespace escript {
31    
32  /**  /**
33     \brief     \brief
34     Return the maximum value.     Adapt binary algorithms so they may be used in DataArrayView reduction operations.
35    
36     Description:     Description:
37     Return the maximum value.     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>  struct FMax : public std::binary_function<double,double,double>
86  {  {
# Line 43  struct FMax : public std::binary_functio Line 92  struct FMax : public std::binary_functio
92    
93  /**  /**
94     \brief     \brief
95     Return the minimum value.     Return the minimum value of the two given values.
   
    Description:  
    Return the minimum value.  
96  */  */
97  struct FMin : public std::binary_function<double,double,double>  struct FMin : public std::binary_function<double,double,double>
98  {  {
# Line 58  struct FMin : public std::binary_functio Line 104  struct FMin : public std::binary_functio
104    
105  /**  /**
106     \brief     \brief
107     Return the absolute maximum value.     Return the absolute maximum value of the two given values.
   
    Description:  
    Return the absolute maximum value.  
108  */  */
109  struct AbsMax : public std::binary_function<double,double,double>  struct AbsMax : public std::binary_function<double,double,double>
110  {  {
# Line 70  struct AbsMax : public std::binary_funct Line 113  struct AbsMax : public std::binary_funct
113      return std::max(fabs(x),fabs(y));      return std::max(fabs(x),fabs(y));
114    }    }
115  };  };
116    
117  /**  /**
118     \brief     \brief
119     Adapt algorithms so they may be used by Data.     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     Description:  /**
130     Adapt algorithms so they may be used by Data. The functor     \brief
131     maintains state, ie the currentValue retuned by the operation.     Return the length between the two given values.
132  */  */
133  template <class BinaryFunction>  struct Length : public std::binary_function<double,double,double>
134  class DataAlgorithmAdapter {  {
135   public:    inline double operator()(double x, double y) const
136      DataAlgorithmAdapter(double initialValue):    {
137        m_currentValue(initialValue)      return std::sqrt(std::pow(x,2)+std::pow(y,2));
138      {}    }
     inline void operator()(double value)  
     {  
       m_currentValue=operation(m_currentValue,value);  
       return;  
     }  
     inline double getResult() const  
     {  
       return m_currentValue;  
     }  
  private:  
     //  
     // the current maximum value  
     double m_currentValue;  
     //  
     // The operation to perform  
     BinaryFunction operation;  
139  };  };
140    
141  /**  /**
142     \brief     \brief
143     Perform the given operation upon all DataElements and return a single     Return the trace of the two given values.
144     result.  */
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     Description:  /**
154     Perform the given operation upon all DataElements and return a single     \brief
155     result.     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 UnaryFunction>  template <class BinaryFunction>
161  inline double algorithm(DataExpanded& data, UnaryFunction operation)  inline
162    double
163    algorithm(DataExpanded& data,
164              BinaryFunction operation,
165          double initial_value)
166  {  {
167    int i,j;    int i,j;
168    DataArrayView::ValueType::size_type numDPPSample=data.getNumDPPSample();    int numDPPSample=data.getNumDPPSample();
169    DataArrayView::ValueType::size_type numSamples=data.getNumSamples();    int numSamples=data.getNumSamples();
170    double resultLocal;    int resultVectorLength=numDPPSample*numSamples;
171    #pragma omp parallel private(resultLocal)    std::vector<double> resultVector(resultVectorLength);
172    {    DataArrayView dataView=data.getPointDataView();
173      #pragma omp parallel for private(i,j) schedule(static)    // calculate the reduction operation value for each data point
174      for (i=0;i<numSamples;++i) {    // storing the result for each data-point in successive entries
175        for (j=0;j<numDPPSample;++j) {    // in resultVector
176      resultLocal=data.getPointDataView().algorithm(data.getPointOffset(i,j),    #pragma omp parallel for private(i,j) schedule(static)
177                                operation);    for (i=0;i<numSamples;i++) {
178      #pragma omp critical (algorithm)      for (j=0;j<numDPPSample;j++) {
179      operation(resultLocal);        resultVector[j*numSamples+i]=dataView.reductionOp(data.getPointOffset(i,j),operation,initial_value);
       }  
180      }      }
181    }    }
182    return operation.getResult();    // now calculate the reduction operation value across the results
183      // for each data-point
184      double current_value=initial_value;
185      for (int l=0;l<resultVectorLength;l++) {
186        current_value=operation(current_value,resultVector[l]);
187      }
188      return current_value;
189  }  }
190    
191  template <class UnaryFunction>  template <class BinaryFunction>
192  inline double algorithm(DataTagged& data, UnaryFunction operation)  inline
193    double
194    algorithm(DataTagged& data,
195              BinaryFunction operation,
196          double initial_value)
197  {  {
   //  
   // perform the operation on each tagged value including the default  
198    const DataTagged::DataMapType& lookup=data.getTagLookup();    const DataTagged::DataMapType& lookup=data.getTagLookup();
199    DataTagged::DataMapType::const_iterator i;    DataTagged::DataMapType::const_iterator i;
200    DataTagged::DataMapType::const_iterator lookupEnd=lookup.end();    DataTagged::DataMapType::const_iterator lookupEnd=lookup.end();
201    DataArrayView& dataView=data.getPointDataView();    DataArrayView& dataView=data.getPointDataView();
202    for (i=lookup.begin();i!=lookupEnd;++i) {    std::vector<double> resultVector;
203      operation(dataView.algorithm(i->second,operation));    int resultVectorLength;
204      // perform the operation on each tagged value
205      for (i=lookup.begin();i!=lookupEnd;i++) {
206        resultVector.push_back(dataView.reductionOp(i->second,operation,initial_value));
207      }
208      // perform the operation on the default value
209      resultVector.push_back(data.getDefaultValue().reductionOp(operation,initial_value));
210      // now calculate the reduction operation value across the results
211      // for each tagged value
212      resultVectorLength=resultVector.size();
213      double current_value=initial_value;
214      for (int l=0;l<resultVectorLength;l++) {
215        current_value=operation(current_value,resultVector[l]);
216      }
217      return current_value;
218    }
219    
220    template <class BinaryFunction>
221    inline
222    double
223    algorithm(DataConstant& data,
224              BinaryFunction operation,
225          double initial_value)
226    {
227      return data.getPointDataView().reductionOp(operation,initial_value);
228    }
229    
230    /**
231       \brief
232       Perform the given data-point reduction operation on all data-points
233       in data, storing results in corresponding data-points of result.
234    
235       Objects data and result must be of the same type, and have the same number
236       of data points, but where data has data points of rank n, result must have
237       data points of rank 0.
238    
239       Calls DataArrayView::reductionOp
240    */
241    template <class BinaryFunction>
242    inline
243    void
244    dp_algorithm(DataExpanded& data,
245                 DataExpanded& result,
246                 BinaryFunction operation,
247             double initial_value)
248    {
249      int i,j;
250      int numSamples=data.getNumSamples();
251      int numDPPSample=data.getNumDPPSample();
252      DataArrayView dataView=data.getPointDataView();
253      DataArrayView resultView=result.getPointDataView();
254      // perform the operation on each data-point and assign
255      // this to the corresponding element in result
256      #pragma omp parallel for private(i,j) schedule(static)
257      for (i=0;i<numSamples;i++) {
258        for (j=0;j<numDPPSample;j++) {
259          resultView.getData(result.getPointOffset(i,j)) =
260            dataView.reductionOp(data.getPointOffset(i,j),operation,initial_value);
261        }
262    }    }
   //  
   // finally perform the operation on the default value  
   operation(data.getDefaultValue().algorithm(operation));  
   return operation.getResult();  
263  }  }
264    
265  template <class UnaryFunction>  template <class BinaryFunction>
266  inline double algorithm(DataConstant& data, UnaryFunction operation)  inline
267    void
268    dp_algorithm(DataTagged& data,
269                 DataTagged& result,
270                 BinaryFunction operation,
271             double initial_value)
272  {  {
273    return data.getPointDataView().algorithm(operation);    const DataTagged::DataMapType& lookup=data.getTagLookup();
274      DataTagged::DataMapType::const_iterator i;
275      DataTagged::DataMapType::const_iterator lookupEnd=lookup.end();
276      DataArrayView dataView=data.getPointDataView();
277      DataArrayView resultView=result.getPointDataView();
278      // perform the operation on each tagged data value
279      // and assign this to the corresponding element in result
280      for (i=lookup.begin();i!=lookupEnd;i++) {
281        resultView.getData(i->second) =
282          dataView.reductionOp(i->second,operation,initial_value);
283      }
284      // perform the operation on the default data value
285      // and assign this to the default element in result
286      resultView.getData(0) =
287        data.getDefaultValue().reductionOp(operation,initial_value);
288  }  }
289    
290    template <class BinaryFunction>
291    inline
292    void
293    dp_algorithm(DataConstant& data,
294                 DataConstant& result,
295                 BinaryFunction operation,
296             double initial_value)
297    {
298      // perform the operation on the data value
299      // and assign this to the element in result
300      result.getPointDataView().getData(0) =
301        data.getPointDataView().reductionOp(operation,initial_value);
302    }
303    
304  } // end of namespace  } // end of namespace
305    
306  #endif  #endif

Legend:
Removed from v.100  
changed lines
  Added in v.147

  ViewVC Help
Powered by ViewVC 1.1.26