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

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

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

revision 1884 by jfenwick, Tue Oct 14 04:54:59 2008 UTC revision 1903 by jfenwick, Wed Oct 22 06:11:01 2008 UTC
# Line 17  Line 17 
17  #include "system_dep.h"  #include "system_dep.h"
18    
19  #include "DataAbstract.h"  #include "DataAbstract.h"
 //#include "DataTypes.h"  
 //#include "FunctionSpace.h"  
20    
21  #include <string>  #include <string>
22  #include <functional>  #include <functional>
# Line 34  enum ES_optype Line 32  enum ES_optype
32      ADD=2,      ADD=2,
33      SUB=3,      SUB=3,
34      MUL=4,      MUL=4,
35      DIV=5      DIV=5,
36        SIN=6,
37        COS=7,
38        TAN=8,
39        ASIN=9,
40        ACOS=10,
41        ATAN=11,
42        SINH=12,
43        COSH=13,
44        TANH=14,
45        ERF=15,
46        ASINH=16,
47        ACOSH=17,
48        ATANH=18,
49        LOG10=19,
50        LOG=20,
51        SIGN=21,
52        ABS=22,
53        NEG=23,
54        POS=24,
55        EXP=25,
56        SQRT=26,
57        RECIP=27,
58        GZ=28,
59        LZ=29,
60        GEZ=30,
61        LEZ=31
62  };  };
63    
64  const std::string&  const std::string&
# Line 43  opToString(ES_optype op); Line 67  opToString(ES_optype op);
67  /**  /**
68  \class escript::DataLazy  \class escript::DataLazy
69  \brief Wraps an expression tree of other DataObjects.  \brief Wraps an expression tree of other DataObjects.
70  The values of DataPoints are computed when requested rather than all at once.  The data will be evaluated when required.
71    
72    
73  NOTE: This class assumes that the Data being pointed at are immutable.  NOTE: This class assumes that the Data being pointed at are immutable.
74  */  */
# Line 61  typedef DataTypes::ValueType ValueType; Line 86  typedef DataTypes::ValueType ValueType;
86  typedef DataTypes::ShapeType ShapeType;  typedef DataTypes::ShapeType ShapeType;
87    
88  public:  public:
89      /**
90      \brief Create an IDENTITY DataLazy for the given DataAbstract.
91      \param p DataAbstract to be wrapped.
92      \throws DataException if p is lazy data or it is not constant, tagged or expanded.
93      */
94    ESCRIPT_DLL_API    ESCRIPT_DLL_API
95    DataLazy(DataAbstract_ptr p);    DataLazy(DataAbstract_ptr p);
96    
97    
98      /**
99      \brief Produce a DataLazy for a unary operation.
100      \param left DataAbstract to be operated on.
101      \param op unary operation to perform.
102      \throws DataException if op is not a unary operation or if p cannot be converted to a DataLazy.
103      Note that IDENTITY is not considered a unary operation.
104      */
105    ESCRIPT_DLL_API    ESCRIPT_DLL_API
106    DataLazy(DataLazy_ptr left, DataLazy_ptr right, ES_optype op);    DataLazy(DataAbstract_ptr left, ES_optype op);
107    
108      /**
109      \brief Produce a DataLazy for a binary operation.
110      \param left left operand
111      \param right right operand
112      \param op unary operation to perform.
113      \throws DataException if op is not a binary operation or if left or right cannot be converted to a DataLazy.
114      */
115    ESCRIPT_DLL_API    ESCRIPT_DLL_API
116    DataLazy(DataAbstract_ptr left, DataAbstract_ptr right, ES_optype op);    DataLazy(DataAbstract_ptr left, DataAbstract_ptr right, ES_optype op);
117    
118    ESCRIPT_DLL_API    ESCRIPT_DLL_API
119    ~DataLazy();    ~DataLazy();
120    
   
   
121    /**    /**
122    \brief Compute all data points in the expression tree    \brief Evaluate the lazy expression.
123      \return A DataReady with the value of the lazy expresion.
124    */    */
125    ESCRIPT_DLL_API    ESCRIPT_DLL_API
126    DataReady_ptr    DataReady_ptr
# Line 110  public: Line 154  public:
154                   int dataPointNo) const;                   int dataPointNo) const;
155    
156    
157  //   // this is a top level function, the actual searching will be done by helper methods    /**
158  //   ESCRIPT_DLL_API      \return the number of samples which need to be stored to evaluate the expression.
159  //   void    */
 //   getSample(ValueType& v, int sampleNo,size_t offset=0) const;  
   
160    ESCRIPT_DLL_API    ESCRIPT_DLL_API
161    int    int
162    getBuffsRequired() const;    getBuffsRequired() const;
163    
164      /**
165         \brief Produces an IDENTITY DataLazy containing zero.
166         The result will have the same shape and functionspace as before.
167      */
168      ESCRIPT_DLL_API
169      virtual void
170      setToZero();
171    
172  private:  private:
173    DataReady_ptr m_id;    DataReady_ptr m_id;   //  For IDENTITY nodes, stores a wrapped value.
174    DataLazy_ptr m_left, m_right;    DataLazy_ptr m_left, m_right; // operands for operation.
175    ES_optype m_op;    ES_optype m_op;   // operation to perform.
176    size_t m_length;  // number of values represented by the operation    size_t m_length;  // number of values represented by the operation
177    
178    int m_buffsRequired;  // how many buffers are required to evaluate this expression    int m_buffsRequired;  // how many samples are required to evaluate this expression
179    size_t m_samplesize;  // number of values required to store a sample    size_t m_samplesize;  // number of values required to store a sample
180    
181    const double*    char m_readytype; // E for expanded, T for tagged, C for constant
182    resolveSample(ValueType& v,int sampleNo,  size_t offset ) const;  
183    
184      /**
185      Does the work for toString.
186      */
187      void
188      intoString(std::ostringstream& oss) const;
189    
190      /**
191       \brief Converts the DataLazy into an IDENTITY storing the value of the expression.
192       This method uses the original methods on the Data class to evaluate the expressions.
193       For this reason, it should not be used on DataExpanded instances. (To do so would defeat
194       the purpose of using DataLazy in the first place).
195      */
196      void
197      collapse();       // converts the node into an IDENTITY node
198    
199    
200      /**
201      \brief Evaluates the expression using methods on Data.
202      This does the work for the collapse method.
203      For reasons of efficiency do not call this method on DataExpanded nodes.
204      */
205      DataReady_ptr
206      collapseToReady();
207    
208      /**
209      \brief Compute the value of the expression for the given sample.
210      \return Vector which stores the value of the subexpression for the given sample.
211      \param v A vector to store intermediate results.
212      \param offset Index in v to begin storing results.
213      \param sampleNo Sample number to evaluate.
214      \param roffset (output parameter) the offset in the return vector where the result begins.
215    
216      The return value will be an existing vector so do not deallocate it.
217      */
218      const ValueType*
219      resolveSample(ValueType& v,  size_t offset ,int sampleNo, size_t& roffset);
220    
221      /**
222      \brief Compute the value of the expression (binary operation) for the given sample.
223      \return Vector which stores the value of the subexpression for the given sample.
224      \param v A vector to store intermediate results.
225      \param offset Index in v to begin storing results.
226      \param sampleNo Sample number to evaluate.
227      \param roffset (output parameter) the offset in the return vector where the result begins.
228    
229      The return value will be an existing vector so do not deallocate it.
230      If the result is stored in v it should be stored at the offset given.
231      Everything from offset to the end of v should be considered available for this method to use.
232      */
233      ValueType*
234      resolveUnary(ValueType& v,  size_t offset,int sampleNo,  size_t& roffset) const;
235    
236      /**
237      \brief Compute the value of the expression (binary operation) for the given sample.
238      \return Vector which stores the value of the subexpression for the given sample.
239      \param v A vector to store intermediate results.
240      \param offset Index in v to begin storing results.
241      \param sampleNo Sample number to evaluate.
242      \param roffset (output parameter) the offset in the return vector where the result begins.
243    
244      The return value will be an existing vector so do not deallocate it.
245      If the result is stored in v it should be stored at the offset given.
246      Everything from offset to the end of v should be considered available for this method to use.
247      */
248      ValueType*
249      resolveBinary(ValueType& v,  size_t offset,int sampleNo,  size_t& roffset) const;
250    
251  };  };
252    

Legend:
Removed from v.1884  
changed lines
  Added in v.1903

  ViewVC Help
Powered by ViewVC 1.1.26