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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 2177 - (hide annotations)
Wed Dec 17 23:51:23 2008 UTC (11 years, 3 months ago) by jfenwick
File MIME type: text/plain
File size: 11868 byte(s)
used unused variable.
Added support for limiting the size of lazy expression trees.
500,000 seems a bit high
1 jfenwick 1865
2     /*******************************************************
3     *
4     * Copyright (c) 2003-2008 by University of Queensland
5     * Earth Systems Science Computational Center (ESSCC)
6     * http://www.uq.edu.au/esscc
7     *
8     * Primary Business: Queensland, Australia
9     * Licensed under the Open Software License version 3.0
10     * http://www.opensource.org/licenses/osl-3.0.php
11     *
12     *******************************************************/
13    
14    
15     #if !defined escript_DataLazy_20081008_H
16     #define escript_DataLazy_20081008_H
17     #include "system_dep.h"
18    
19     #include "DataAbstract.h"
20    
21     #include <string>
22 jfenwick 1868 #include <functional>
23 jfenwick 1865
24 jfenwick 1879 #include "LocalOps.h" // for tensor_binary_op
25    
26 jfenwick 1865 namespace escript {
27    
28 jfenwick 1926 // For the purposes of unit testing and maintaining sanity, it is important that this enum be contiguous
29 jfenwick 1865 enum ES_optype
30     {
31     UNKNOWNOP=0,
32 jfenwick 1868 IDENTITY=1,
33     ADD=2,
34     SUB=3,
35     MUL=4,
36 jfenwick 1886 DIV=5,
37 jfenwick 1910 POW=6,
38     SIN=POW+1,
39     COS=SIN+1,
40     TAN=SIN+2,
41     ASIN=SIN+3,
42     ACOS=SIN+4,
43     ATAN=SIN+5,
44     SINH=SIN+6,
45     COSH=SIN+7,
46     TANH=SIN+8,
47     ERF=SIN+9,
48     ASINH=SIN+10,
49     ACOSH=SIN+11,
50     ATANH=SIN+12,
51     LOG10=ATANH+1,
52     LOG=LOG10+1,
53     SIGN=LOG10+2,
54     ABS=LOG10+3,
55     NEG=LOG10+4,
56     POS=LOG10+5,
57     EXP=LOG10+6,
58     SQRT=LOG10+7,
59     RECIP=LOG10+8,
60     GZ=RECIP+1,
61     LZ=GZ+1,
62     GEZ=GZ+2,
63 jfenwick 2037 LEZ=GZ+3,
64 jfenwick 2147 NEZ=GZ+4,
65     EZ=GZ+5,
66     SYM=EZ+1,
67 jfenwick 2066 NSYM=SYM+1,
68 jfenwick 2084 PROD=NSYM+1,
69     TRANS=PROD+1,
70     TRACE=TRANS+1
71 jfenwick 1865 };
72    
73 phornby 1992 ESCRIPT_DLL_API
74 jfenwick 1865 const std::string&
75     opToString(ES_optype op);
76    
77     /**
78     \class escript::DataLazy
79     \brief Wraps an expression tree of other DataObjects.
80 jfenwick 1903 The data will be evaluated when required.
81 jfenwick 1879
82 jfenwick 1903
83 jfenwick 1879 NOTE: This class assumes that the Data being pointed at are immutable.
84 jfenwick 1865 */
85    
86 jfenwick 1879 class DataLazy;
87    
88     typedef POINTER_WRAPPER_CLASS(DataLazy) DataLazy_ptr;
89     typedef POINTER_WRAPPER_CLASS(const DataLazy) const_DataLazy_ptr;
90    
91 jfenwick 1865 class DataLazy : public DataAbstract
92     {
93    
94     typedef DataAbstract parent;
95     typedef DataTypes::ValueType ValueType;
96     typedef DataTypes::ShapeType ShapeType;
97    
98     public:
99 jfenwick 1899 /**
100     \brief Create an IDENTITY DataLazy for the given DataAbstract.
101     \param p DataAbstract to be wrapped.
102     \throws DataException if p is lazy data or it is not constant, tagged or expanded.
103     */
104 jfenwick 1865 ESCRIPT_DLL_API
105     DataLazy(DataAbstract_ptr p);
106    
107 jfenwick 1899
108     /**
109     \brief Produce a DataLazy for a unary operation.
110     \param left DataAbstract to be operated on.
111     \param op unary operation to perform.
112     \throws DataException if op is not a unary operation or if p cannot be converted to a DataLazy.
113     Note that IDENTITY is not considered a unary operation.
114     */
115 jfenwick 1865 ESCRIPT_DLL_API
116 jfenwick 1886 DataLazy(DataAbstract_ptr left, ES_optype op);
117    
118 jfenwick 1899 /**
119 jfenwick 2147 \brief Produce a DataLazy for a unary operation.
120     \param left DataAbstract to be operated on.
121     \param op unary operation to perform.
122     \param tol tolerance for operation
123     \throws DataException if op is not a unary operation or if p cannot be converted to a DataLazy.
124     Note that IDENTITY is not considered a unary operation.
125     */
126     ESCRIPT_DLL_API
127     DataLazy(DataAbstract_ptr left, ES_optype op, double tol);
128    
129     /**
130 jfenwick 2084 \brief Produce a DataLazy for a unary operation which requires a parameter.
131     \param left DataAbstract to be operated on.
132     \param op unary operation to perform.
133     \param axis_offset the parameter for the operation
134     \throws DataException if op is not a unary operation or if p cannot be converted to a DataLazy.
135     Note that IDENTITY is not considered a unary operation.
136     */
137     ESCRIPT_DLL_API
138     DataLazy(DataAbstract_ptr left, ES_optype op, int axis_offset);
139    
140    
141     /**
142 jfenwick 1899 \brief Produce a DataLazy for a binary operation.
143     \param left left operand
144     \param right right operand
145     \param op unary operation to perform.
146     \throws DataException if op is not a binary operation or if left or right cannot be converted to a DataLazy.
147     */
148 jfenwick 1886 ESCRIPT_DLL_API
149 jfenwick 1865 DataLazy(DataAbstract_ptr left, DataAbstract_ptr right, ES_optype op);
150    
151 jfenwick 2066 /**
152     \brief Produce a DataLazy for a binary operation with additional paramters.
153     \param left left operand
154     \param right right operand
155     \param op unary operation to perform.
156     \param axis_offset
157     \param transpose
158     \throws DataException if op is not a binary operation requiring parameters or if left or right cannot be converted to a DataLazy.
159     */
160 jfenwick 1865 ESCRIPT_DLL_API
161 jfenwick 2066 DataLazy(DataAbstract_ptr left, DataAbstract_ptr right, ES_optype op, int axis_offset, int transpose);
162    
163     ESCRIPT_DLL_API
164 jfenwick 1865 ~DataLazy();
165    
166     /**
167 jfenwick 1899 \brief Evaluate the lazy expression.
168     \return A DataReady with the value of the lazy expresion.
169 jfenwick 1865 */
170     ESCRIPT_DLL_API
171 jfenwick 1879 DataReady_ptr
172     resolve();
173 jfenwick 1865
174     ESCRIPT_DLL_API
175     std::string
176     toString() const;
177    
178     ESCRIPT_DLL_API
179     DataAbstract*
180     deepCopy();
181    
182    
183     /**
184     \brief
185 jfenwick 2066 This method throws an exception. It does not really make sense to ask this question of lazy data.
186 jfenwick 1865 */
187     ESCRIPT_DLL_API
188     ValueType::size_type
189     getLength() const;
190    
191    
192     ESCRIPT_DLL_API
193     DataAbstract*
194     getSlice(const DataTypes::RegionType& region) const;
195    
196    
197     DataTypes::ValueType::size_type
198     getPointOffset(int sampleNo,
199     int dataPointNo) const;
200    
201 jfenwick 1935 DataTypes::ValueType::size_type
202     getPointOffset(int sampleNo,
203     int dataPointNo);
204 jfenwick 1879
205 jfenwick 1935
206 jfenwick 1899 /**
207     \return the number of samples which need to be stored to evaluate the expression.
208     */
209 jfenwick 1879 ESCRIPT_DLL_API
210     int
211     getBuffsRequired() const;
212    
213 jfenwick 1901 /**
214 jfenwick 2066 \return the largest samplesize required to evaluate the expression.
215     */
216     ESCRIPT_DLL_API
217     size_t
218     getMaxSampleSize() const;
219    
220    
221     /**
222 jfenwick 1901 \brief Produces an IDENTITY DataLazy containing zero.
223     The result will have the same shape and functionspace as before.
224     */
225     ESCRIPT_DLL_API
226     virtual void
227     setToZero();
228 jfenwick 1889
229 jfenwick 1865 private:
230 jfenwick 1899 DataReady_ptr m_id; // For IDENTITY nodes, stores a wrapped value.
231     DataLazy_ptr m_left, m_right; // operands for operation.
232     ES_optype m_op; // operation to perform.
233 jfenwick 1879
234 jfenwick 1899 int m_buffsRequired; // how many samples are required to evaluate this expression
235 jfenwick 1879 size_t m_samplesize; // number of values required to store a sample
236    
237 jfenwick 1899 char m_readytype; // E for expanded, T for tagged, C for constant
238 jfenwick 1879
239 jfenwick 2066 int m_axis_offset; // required extra info for general tensor product
240     int m_transpose;
241     int m_SL, m_SM, m_SR; // computed properties used in general tensor product
242 jfenwick 1889
243 jfenwick 2147 double m_tol; // required extra info for <>0 and ==0
244    
245 jfenwick 2177 size_t m_maxsamplesize; // largest samplesize required by any node in the expression
246     size_t m_children;
247     size_t m_height;
248 jfenwick 2066
249    
250 jfenwick 1899 /**
251     Does the work for toString.
252     */
253 jfenwick 1886 void
254     intoString(std::ostringstream& oss) const;
255    
256 jfenwick 1899 /**
257     \brief Converts the DataLazy into an IDENTITY storing the value of the expression.
258     This method uses the original methods on the Data class to evaluate the expressions.
259     For this reason, it should not be used on DataExpanded instances. (To do so would defeat
260     the purpose of using DataLazy in the first place).
261     */
262 jfenwick 1889 void
263     collapse(); // converts the node into an IDENTITY node
264    
265 jfenwick 1899
266     /**
267     \brief Evaluates the expression using methods on Data.
268     This does the work for the collapse method.
269     For reasons of efficiency do not call this method on DataExpanded nodes.
270     */
271 jfenwick 1889 DataReady_ptr
272     collapseToReady();
273    
274 jfenwick 1899 /**
275 jfenwick 2177 \brief resolve the expression can store it in the current node
276     The current node will be converted to an identity node.
277     */
278     void
279     resolveToIdentity();
280    
281     /**
282     \brief helper method for resolveToIdentity and the identity constructor
283     */
284     void
285     makeIdentity(const DataReady_ptr& p);
286    
287     /**
288 jfenwick 1899 \brief Compute the value of the expression for the given sample.
289     \return Vector which stores the value of the subexpression for the given sample.
290     \param v A vector to store intermediate results.
291     \param offset Index in v to begin storing results.
292     \param sampleNo Sample number to evaluate.
293     \param roffset (output parameter) the offset in the return vector where the result begins.
294 jfenwick 1889
295 jfenwick 1899 The return value will be an existing vector so do not deallocate it.
296     */
297     const ValueType*
298     resolveSample(ValueType& v, size_t offset ,int sampleNo, size_t& roffset);
299 jfenwick 1889
300 jfenwick 1899 /**
301 jfenwick 2037 \brief Compute the value of the expression (unary operation) for the given sample.
302 jfenwick 1899 \return Vector which stores the value of the subexpression for the given sample.
303     \param v A vector to store intermediate results.
304     \param offset Index in v to begin storing results.
305     \param sampleNo Sample number to evaluate.
306     \param roffset (output parameter) the offset in the return vector where the result begins.
307    
308     The return value will be an existing vector so do not deallocate it.
309     If the result is stored in v it should be stored at the offset given.
310     Everything from offset to the end of v should be considered available for this method to use.
311     */
312 jfenwick 1898 ValueType*
313     resolveUnary(ValueType& v, size_t offset,int sampleNo, size_t& roffset) const;
314 jfenwick 1889
315 jfenwick 1899 /**
316 jfenwick 2037 \brief Compute the value of the expression (unary non-pointwise operation) for the given sample.
317     \return Vector which stores the value of the subexpression for the given sample.
318     \param v A vector to store intermediate results.
319     \param offset Index in v to begin storing results.
320     \param sampleNo Sample number to evaluate.
321     \param roffset (output parameter) the offset in the return vector where the result begins.
322    
323     The return value will be an existing vector so do not deallocate it.
324     If the result is stored in v it should be stored at the offset given.
325     Everything from offset to the end of v should be considered available for this method to use.
326    
327     This method differs from the one above in that deals with operations that are not
328     point-wise. That is, the answer cannot just be written on top of the input.
329     Extra buffers are required for these operations.
330     */
331    
332     ValueType*
333     resolveNP1OUT(ValueType& v, size_t offset, int sampleNo, size_t& roffset) const;
334    
335 jfenwick 2084 /**
336     \brief Compute the value of the expression (unary operation) for the given sample.
337     \return Vector which stores the value of the subexpression for the given sample.
338     \param v A vector to store intermediate results.
339     \param offset Index in v to begin storing results.
340     \param sampleNo Sample number to evaluate.
341     \param roffset (output parameter) the offset in the return vector where the result begins.
342 jfenwick 2037
343 jfenwick 2084 The return value will be an existing vector so do not deallocate it.
344     If the result is stored in v it should be stored at the offset given.
345     Everything from offset to the end of v should be considered available for this method to use.
346     */
347     DataTypes::ValueType*
348     resolveNP1OUT_P(ValueType& v, size_t offset, int sampleNo, size_t& roffset) const;
349    
350    
351 jfenwick 2037 /**
352 jfenwick 1899 \brief Compute the value of the expression (binary operation) for the given sample.
353     \return Vector which stores the value of the subexpression for the given sample.
354     \param v A vector to store intermediate results.
355     \param offset Index in v to begin storing results.
356     \param sampleNo Sample number to evaluate.
357     \param roffset (output parameter) the offset in the return vector where the result begins.
358    
359     The return value will be an existing vector so do not deallocate it.
360     If the result is stored in v it should be stored at the offset given.
361     Everything from offset to the end of v should be considered available for this method to use.
362     */
363 jfenwick 1898 ValueType*
364     resolveBinary(ValueType& v, size_t offset,int sampleNo, size_t& roffset) const;
365    
366 jfenwick 2066 /**
367     \brief Compute the value of the expression (tensor product) for the given sample.
368     \return Vector which stores the value of the subexpression for the given sample.
369     \param v A vector to store intermediate results.
370     \param offset Index in v to begin storing results.
371     \param sampleNo Sample number to evaluate.
372     \param roffset (output parameter) the offset in the return vector where the result begins.
373    
374     The return value will be an existing vector so do not deallocate it.
375     If the result is stored in v it should be stored at the offset given.
376     Everything from offset to the end of v should be considered available for this method to use.
377     */
378     DataTypes::ValueType*
379     resolveTProd(ValueType& v, size_t offset, int sampleNo, size_t& roffset) const;
380    
381 jfenwick 1865 };
382    
383     }
384     #endif

  ViewVC Help
Powered by ViewVC 1.1.26