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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 757 - (hide annotations)
Mon Jun 26 13:12:56 2006 UTC (12 years, 9 months ago) by woo409
File MIME type: text/plain
File size: 41395 byte(s)
+ Merge of intelc_win32 branch (revision 741:755) with trunk. Tested on iVEC altix (run_tests and py_tests all pass)

1 jgs 94 // $Id$
2 jgs 121 /*
3 elspeth 615 ************************************************************
4     * Copyright 2006 by ACcESS MNRF *
5     * *
6     * http://www.access.edu.au *
7     * Primary Business: Queensland, Australia *
8     * Licensed under the Open Software License version 3.0 *
9     * http://www.opensource.org/licenses/osl-3.0.php *
10     * *
11     ************************************************************
12 jgs 121 */
13 jgs 94
14 jgs 121 /** \file Data.h */
15 jgs 94
16     #ifndef DATA_H
17     #define DATA_H
18 woo409 757 #include "system_dep.h"
19 jgs 94
20 jgs 474 #include "DataAbstract.h"
21     #include "DataAlgorithm.h"
22     #include "FunctionSpace.h"
23     #include "BinaryOp.h"
24     #include "UnaryOp.h"
25     #include "DataException.h"
26 jgs 94
27     extern "C" {
28 jgs 474 #include "DataC.h"
29 woo409 757 #include "paso/Paso.h"
30 jgs 94 }
31    
32     #include <string>
33     #include <algorithm>
34    
35     #include <boost/shared_ptr.hpp>
36     #include <boost/python/object.hpp>
37     #include <boost/python/tuple.hpp>
38     #include <boost/python/numeric.hpp>
39    
40 jgs 121 namespace escript {
41    
42     //
43 jgs 149 // Forward declaration for various implementations of Data.
44 jgs 121 class DataConstant;
45     class DataTagged;
46     class DataExpanded;
47    
48 jgs 94 /**
49     \brief
50 jgs 121 Data creates the appropriate Data object for the given construction
51     arguments.
52 jgs 94
53     Description:
54     Data is essentially a factory class which creates the appropriate Data
55     object for the given construction arguments. It retains control over
56     the object created for the lifetime of the object.
57     The type of Data object referred to may change during the lifetime of
58     the Data object.
59     */
60     class Data {
61    
62     public:
63    
64 jgs 110 // These typedefs allow function names to be cast to pointers
65     // to functions of the appropriate type when calling unaryOp etc.
66 jgs 94 typedef double (*UnaryDFunPtr)(double);
67     typedef double (*BinaryDFunPtr)(double,double);
68    
69     /**
70 jgs 102 Constructors.
71     */
72    
73     /**
74 jgs 94 \brief
75     Default constructor.
76     Creates a DataEmpty object.
77     */
78 woo409 757 ESCRIPT_DLL_API
79 jgs 94 Data();
80    
81     /**
82     \brief
83     Copy constructor.
84     WARNING: Only performs a shallow copy.
85     */
86 woo409 757 ESCRIPT_DLL_API
87 jgs 94 Data(const Data& inData);
88    
89     /**
90     \brief
91     Constructor from another Data object. If "what" is different from the
92 jgs 102 function space of inData the inData are tried to be interpolated to what,
93 jgs 94 otherwise a shallow copy of inData is returned.
94     */
95 woo409 757 ESCRIPT_DLL_API
96 jgs 94 Data(const Data& inData,
97     const FunctionSpace& what);
98    
99     /**
100     \brief
101     Constructor which copies data from a DataArrayView.
102    
103     \param value - Input - Data value for a single point.
104     \param what - Input - A description of what this data represents.
105     \param expanded - Input - Flag, if true fill the entire container with
106     the value. Otherwise a more efficient storage
107     mechanism will be used.
108     */
109 woo409 757 ESCRIPT_DLL_API
110 jgs 94 Data(const DataArrayView& value,
111     const FunctionSpace& what=FunctionSpace(),
112     bool expanded=false);
113    
114     /**
115     \brief
116     Constructor which creates a Data from a DataArrayView shape.
117    
118     \param value - Input - Single value applied to all Data.
119     \param dataPointShape - Input - The shape of each data point.
120     \param what - Input - A description of what this data represents.
121     \param expanded - Input - Flag, if true fill the entire container with
122     the given value. Otherwise a more efficient storage
123     mechanism will be used.
124     */
125 woo409 757 ESCRIPT_DLL_API
126 jgs 94 Data(double value,
127     const DataArrayView::ShapeType& dataPointShape=DataArrayView::ShapeType(),
128     const FunctionSpace& what=FunctionSpace(),
129     bool expanded=false);
130    
131     /**
132     \brief
133     Constructor which performs a deep copy of a region from another Data object.
134    
135     \param inData - Input - Input Data object.
136     \param region - Input - Region to copy.
137     */
138 woo409 757 ESCRIPT_DLL_API
139 jgs 94 Data(const Data& inData,
140     const DataArrayView::RegionType& region);
141    
142     /**
143     \brief
144     Constructor which will create Tagged data if expanded is false.
145     No attempt is made to ensure the tag keys match the tag keys
146     within the function space.
147    
148     \param tagKeys - Input - List of tag values.
149     \param values - Input - List of values, one for each tag.
150     \param defaultValue - Input - A default value, used if tag doesn't exist.
151     \param what - Input - A description of what this data represents.
152     \param expanded - Input - Flag, if true fill the entire container with
153     the appropriate values.
154 jgs 544 ==>*
155 jgs 94 */
156 woo409 757 ESCRIPT_DLL_API
157 jgs 94 Data(const DataTagged::TagListType& tagKeys,
158     const DataTagged::ValueListType& values,
159     const DataArrayView& defaultValue,
160     const FunctionSpace& what=FunctionSpace(),
161     bool expanded=false);
162    
163     /**
164     \brief
165     Constructor which copies data from a python numarray.
166    
167     \param value - Input - Data value for a single point.
168     \param what - Input - A description of what this data represents.
169     \param expanded - Input - Flag, if true fill the entire container with
170     the value. Otherwise a more efficient storage
171     mechanism will be used.
172     */
173 woo409 757 ESCRIPT_DLL_API
174 jgs 94 Data(const boost::python::numeric::array& value,
175     const FunctionSpace& what=FunctionSpace(),
176     bool expanded=false);
177    
178     /**
179     \brief
180     Constructor which copies data from any object that can be converted into
181     a python numarray.
182    
183     \param value - Input - Input data.
184     \param what - Input - A description of what this data represents.
185     \param expanded - Input - Flag, if true fill the entire container with
186     the value. Otherwise a more efficient storage
187     mechanism will be used.
188     */
189 woo409 757 ESCRIPT_DLL_API
190 jgs 94 Data(const boost::python::object& value,
191     const FunctionSpace& what=FunctionSpace(),
192     bool expanded=false);
193    
194     /**
195     \brief
196     Constructor which creates a DataConstant.
197     Copies data from any object that can be converted
198     into a numarray. All other parameters are copied from other.
199    
200     \param value - Input - Input data.
201     \param other - Input - contains all other parameters.
202     */
203 woo409 757 ESCRIPT_DLL_API
204 jgs 94 Data(const boost::python::object& value,
205     const Data& other);
206    
207     /**
208     \brief
209     Constructor which creates a DataConstant of "shape" with constant value.
210     */
211 woo409 757 ESCRIPT_DLL_API
212 jgs 94 Data(double value,
213     const boost::python::tuple& shape=boost::python::make_tuple(),
214     const FunctionSpace& what=FunctionSpace(),
215     bool expanded=false);
216 jgs 151 /**
217     \brief
218     Destructor
219     */
220 woo409 757 ESCRIPT_DLL_API
221 jgs 151 ~Data();
222 jgs 94
223     /**
224     \brief
225 jgs 102 Perform a deep copy.
226 jgs 94 */
227 woo409 757 ESCRIPT_DLL_API
228 jgs 94 void
229 jgs 102 copy(const Data& other);
230 jgs 94
231     /**
232 jgs 102 Member access methods.
233 jgs 94 */
234    
235     /**
236     \brief
237 jgs 121 Return the values of all data-points as a single python numarray object.
238 jgs 117 */
239 woo409 757 ESCRIPT_DLL_API
240 jgs 121 const boost::python::numeric::array
241 jgs 117 convertToNumArray();
242    
243     /**
244     \brief
245 jgs 121 Return the values of all data-points for the given sample as a single python numarray object.
246     */
247 woo409 757 ESCRIPT_DLL_API
248 jgs 121 const boost::python::numeric::array
249     convertToNumArrayFromSampleNo(int sampleNo);
250    
251     /**
252     \brief
253     Return the value of the specified data-point as a single python numarray object.
254     */
255 woo409 757 ESCRIPT_DLL_API
256 jgs 121 const boost::python::numeric::array
257     convertToNumArrayFromDPNo(int sampleNo,
258     int dataPointNo);
259    
260     /**
261     \brief
262 jgs 149 Fills the expanded Data object from values of a python numarray object.
263     */
264 woo409 757 ESCRIPT_DLL_API
265 jgs 149 void
266     fillFromNumArray(const boost::python::numeric::array);
267    
268     /**
269     \brief
270     Return the tag number associated with the given data-point.
271    
272     The data-point number here corresponds to the data-point number in the
273     numarray returned by convertToNumArray.
274     */
275 woo409 757 ESCRIPT_DLL_API
276 jgs 149 int
277     getTagNumber(int dpno);
278    
279     /**
280     \brief
281 jgs 94 Return the C wrapper for the Data object.
282     */
283 woo409 757 ESCRIPT_DLL_API
284 jgs 102 escriptDataC
285     getDataC();
286 jgs 94
287     /**
288     \brief
289     Return the C wrapper for the Data object - const version.
290     */
291 woo409 757 ESCRIPT_DLL_API
292 jgs 102 escriptDataC
293     getDataC() const;
294 jgs 94
295     /**
296     \brief
297     Write the data as a string.
298     */
299 woo409 757 ESCRIPT_DLL_API
300 jgs 102 inline
301     std::string
302     toString() const
303     {
304     return m_data->toString();
305     }
306 jgs 94
307     /**
308     \brief
309     Return the DataArrayView of the point data. This essentially contains
310     the shape information for each data point although it also may be used
311     to manipulate the point data.
312     */
313 woo409 757 ESCRIPT_DLL_API
314 jgs 94 inline
315     const DataArrayView&
316     getPointDataView() const
317     {
318     return m_data->getPointDataView();
319     }
320    
321     /**
322     \brief
323 jgs 102 Whatever the current Data type make this into a DataExpanded.
324 jgs 94 */
325 woo409 757 ESCRIPT_DLL_API
326 jgs 94 void
327     expand();
328    
329     /**
330     \brief
331 jgs 102 If possible convert this Data to DataTagged. This will only allow
332 jgs 94 Constant data to be converted to tagged. An attempt to convert
333     Expanded data to tagged will throw an exception.
334 jgs 544 ==>*
335 jgs 94 */
336 woo409 757 ESCRIPT_DLL_API
337 jgs 94 void
338     tag();
339    
340     /**
341     \brief
342     Return true if this Data is expanded.
343     */
344 woo409 757 ESCRIPT_DLL_API
345 jgs 94 bool
346     isExpanded() const;
347    
348     /**
349     \brief
350     Return true if this Data is tagged.
351     */
352 woo409 757 ESCRIPT_DLL_API
353 jgs 94 bool
354     isTagged() const;
355    
356     /**
357     \brief
358 jgs 102 Return true if this Data is constant.
359 jgs 94 */
360 woo409 757 ESCRIPT_DLL_API
361 jgs 94 bool
362 jgs 102 isConstant() const;
363 jgs 94
364     /**
365     \brief
366 jgs 102 Return true if this Data is empty.
367 jgs 94 */
368 woo409 757 ESCRIPT_DLL_API
369 jgs 94 bool
370 jgs 102 isEmpty() const;
371 jgs 94
372     /**
373     \brief
374     Return the function space.
375     */
376 woo409 757 ESCRIPT_DLL_API
377 jgs 94 inline
378     const FunctionSpace&
379     getFunctionSpace() const
380     {
381     return m_data->getFunctionSpace();
382     }
383    
384     /**
385     \brief
386     Return a copy of the function space.
387     */
388 woo409 757 ESCRIPT_DLL_API
389 jgs 94 const FunctionSpace
390     getCopyOfFunctionSpace() const;
391    
392     /**
393     \brief
394     Return the domain.
395     */
396 woo409 757 ESCRIPT_DLL_API
397 jgs 94 inline
398     const AbstractDomain&
399     getDomain() const
400     {
401     return getFunctionSpace().getDomain();
402     }
403    
404     /**
405     \brief
406     Return a copy of the domain.
407     */
408 woo409 757 ESCRIPT_DLL_API
409 jgs 94 const AbstractDomain
410     getCopyOfDomain() const;
411    
412     /**
413     \brief
414     Return the rank of the point data.
415     */
416 woo409 757 ESCRIPT_DLL_API
417 jgs 94 inline
418     int
419     getDataPointRank() const
420     {
421     return m_data->getPointDataView().getRank();
422     }
423    
424     /**
425     \brief
426 jgs 102 Return the number of samples.
427 jgs 94 */
428 woo409 757 ESCRIPT_DLL_API
429 jgs 94 inline
430     int
431 jgs 102 getNumSamples() const
432 jgs 94 {
433 jgs 102 return m_data->getNumSamples();
434 jgs 94 }
435    
436     /**
437     \brief
438 jgs 102 Return the number of data points per sample.
439 jgs 94 */
440 woo409 757 ESCRIPT_DLL_API
441 jgs 102 inline
442 jgs 94 int
443 jgs 102 getNumDataPointsPerSample() const
444     {
445     return m_data->getNumDPPSample();
446     }
447 jgs 94
448     /**
449     \brief
450     Return the sample data for the given sample no. This is not the
451     preferred interface but is provided for use by C code.
452     \param sampleNo - Input - the given sample no.
453     */
454 woo409 757 ESCRIPT_DLL_API
455 jgs 102 inline
456 jgs 94 DataAbstract::ValueType::value_type*
457 jgs 102 getSampleData(DataAbstract::ValueType::size_type sampleNo)
458     {
459     return m_data->getSampleData(sampleNo);
460     }
461 jgs 94
462     /**
463     \brief
464     Return the sample data for the given tag. If an attempt is made to
465     access data that isn't tagged an exception will be thrown.
466     \param tag - Input - the tag key.
467     */
468 woo409 757 ESCRIPT_DLL_API
469 jgs 102 inline
470 jgs 94 DataAbstract::ValueType::value_type*
471 jgs 102 getSampleDataByTag(int tag)
472     {
473     return m_data->getSampleDataByTag(tag);
474     }
475 jgs 94
476     /**
477     \brief
478 jgs 110 Assign the given value to the data-points referenced by the given
479     reference number.
480    
481     The value supplied is a python numarray object. The data from this numarray
482     is unpacked into a DataArray, and this is used to set the corresponding
483     data-points in the underlying Data object.
484    
485     If the underlying Data object cannot be accessed via reference numbers, an
486     exception will be thrown.
487    
488     \param ref - Input - reference number.
489     \param value - Input - value to assign to data-points associated with
490     the given reference number.
491     */
492 woo409 757 ESCRIPT_DLL_API
493 jgs 110 void
494     setRefValue(int ref,
495     const boost::python::numeric::array& value);
496    
497     /**
498     \brief
499     Return the values associated with the data-points referenced by the given
500     reference number.
501    
502     The value supplied is a python numarray object. The data from the corresponding
503     data-points in this Data object are packed into the given numarray object.
504    
505     If the underlying Data object cannot be accessed via reference numbers, an
506     exception will be thrown.
507    
508     \param ref - Input - reference number.
509     \param value - Output - object to receive values from data-points
510     associated with the given reference number.
511     */
512 woo409 757 ESCRIPT_DLL_API
513 jgs 110 void
514     getRefValue(int ref,
515     boost::python::numeric::array& value);
516    
517     /**
518     \brief
519 jgs 94 Return a view into the data for the data point specified.
520     NOTE: Construction of the DataArrayView is a relatively expensive
521     operation.
522     \param sampleNo - Input -
523     \param dataPointNo - Input -
524     */
525 woo409 757 ESCRIPT_DLL_API
526 jgs 94 inline
527     DataArrayView
528     getDataPoint(int sampleNo,
529     int dataPointNo)
530     {
531     return m_data->getDataPoint(sampleNo,dataPointNo);
532     }
533    
534     /**
535     \brief
536     Return a reference to the data point shape.
537     */
538 woo409 757 ESCRIPT_DLL_API
539 jgs 94 const DataArrayView::ShapeType&
540     getDataPointShape() const;
541    
542     /**
543     \brief
544 jgs 102 Return the data point shape as a tuple of integers.
545 jgs 94 */
546 woo409 757 ESCRIPT_DLL_API
547 jgs 121 const boost::python::tuple
548 jgs 94 getShapeTuple() const;
549    
550     /**
551     \brief
552     Return the size of the data point. It is the product of the
553     data point shape dimensions.
554     */
555 woo409 757 ESCRIPT_DLL_API
556 jgs 94 int
557     getDataPointSize() const;
558    
559     /**
560     \brief
561 jgs 102 Return the number of doubles stored for this Data.
562 jgs 94 */
563 woo409 757 ESCRIPT_DLL_API
564 jgs 94 DataArrayView::ValueType::size_type
565     getLength() const;
566    
567     /**
568     \brief
569 jgs 102 Assign the given value to the tag. Implicitly converts this
570     object to type DataTagged. Throws an exception if this object
571     cannot be converted to a DataTagged object.
572     \param tagKey - Input - Integer key.
573     \param value - Input - Value to associate with given key.
574 jgs 544 ==>*
575 jgs 94 */
576 woo409 757 ESCRIPT_DLL_API
577 jgs 102 void
578     setTaggedValue(int tagKey,
579     const boost::python::object& value);
580    
581     /**
582     \brief
583     Assign the given value to the tag. Implicitly converts this
584     object to type DataTagged. Throws an exception if this object
585     cannot be converted to a DataTagged object.
586     \param tagKey - Input - Integer key.
587     \param value - Input - Value to associate with given key.
588 jgs 544 ==>*
589 jgs 102 */
590 woo409 757 ESCRIPT_DLL_API
591 jgs 102 void
592 jgs 121 setTaggedValueFromCPP(int tagKey,
593     const DataArrayView& value);
594 jgs 102
595     /**
596     \brief
597     Copy other Data object into this Data object where mask is positive.
598     */
599 woo409 757 ESCRIPT_DLL_API
600 jgs 102 void
601     copyWithMask(const Data& other,
602     const Data& mask);
603    
604     /**
605     Data object operation methods and operators.
606     */
607    
608     /**
609     \brief
610     Interpolates this onto the given functionspace and returns
611     the result as a Data object.
612 jgs 123 *
613 jgs 102 */
614 woo409 757 ESCRIPT_DLL_API
615 jgs 94 Data
616     interpolate(const FunctionSpace& functionspace) const;
617    
618     /**
619     \brief
620     Calculates the gradient of the data at the data points of functionspace.
621     If functionspace is not present the function space of Function(getDomain()) is used.
622 jgs 123 *
623 jgs 94 */
624 woo409 757 ESCRIPT_DLL_API
625 jgs 94 Data
626     gradOn(const FunctionSpace& functionspace) const;
627    
628 woo409 757 ESCRIPT_DLL_API
629 jgs 94 Data
630     grad() const;
631    
632     /**
633     \brief
634     Calculate the integral over the function space domain.
635 jgs 123 *
636 jgs 94 */
637 woo409 757 ESCRIPT_DLL_API
638 jgs 94 boost::python::numeric::array
639     integrate() const;
640    
641     /**
642     \brief
643     Return a Data with a 1 for +ive values and a 0 for 0 or -ive values.
644 jgs 123 *
645 jgs 94 */
646 woo409 757 ESCRIPT_DLL_API
647 jgs 94 Data
648 gross 698 wherePositive() const;
649 jgs 94
650     /**
651     \brief
652 jgs 102 Return a Data with a 1 for -ive values and a 0 for +ive or 0 values.
653 jgs 123 *
654 jgs 94 */
655 woo409 757 ESCRIPT_DLL_API
656 jgs 94 Data
657 gross 698 whereNegative() const;
658 jgs 102
659     /**
660     \brief
661     Return a Data with a 1 for +ive or 0 values and a 0 for -ive values.
662 jgs 123 *
663 jgs 102 */
664 woo409 757 ESCRIPT_DLL_API
665 jgs 102 Data
666 gross 698 whereNonNegative() const;
667 jgs 94
668     /**
669     \brief
670 jgs 102 Return a Data with a 1 for -ive or 0 values and a 0 for +ive values.
671 jgs 123 *
672 jgs 94 */
673 woo409 757 ESCRIPT_DLL_API
674 jgs 94 Data
675 gross 698 whereNonPositive() const;
676 jgs 94
677     /**
678     \brief
679 jgs 102 Return a Data with a 1 for 0 values and a 0 for +ive or -ive values.
680 jgs 123 *
681 jgs 94 */
682 woo409 757 ESCRIPT_DLL_API
683 jgs 94 Data
684 jgs 571 whereZero(double tol=0.0) const;
685 jgs 94
686     /**
687     \brief
688 jgs 102 Return a Data with a 0 for 0 values and a 1 for +ive or -ive values.
689 jgs 123 *
690 jgs 94 */
691 woo409 757 ESCRIPT_DLL_API
692 jgs 94 Data
693 jgs 571 whereNonZero(double tol=0.0) const;
694 jgs 102
695     /**
696     \brief
697     Return the maximum absolute value of this Data object.
698 jgs 123 *
699 jgs 94 */
700 woo409 757 ESCRIPT_DLL_API
701 jgs 102 double
702     Lsup() const;
703 jgs 94
704     /**
705     \brief
706 jgs 117 Return the minimum absolute value of this Data object.
707 jgs 123 *
708 jgs 117 */
709 woo409 757 ESCRIPT_DLL_API
710 jgs 117 double
711     Linf() const;
712    
713     /**
714     \brief
715 jgs 102 Return the maximum value of this Data object.
716 jgs 123 *
717 jgs 94 */
718 woo409 757 ESCRIPT_DLL_API
719 jgs 102 double
720     sup() const;
721 jgs 94
722     /**
723     \brief
724 jgs 102 Return the minimum value of this Data object.
725 jgs 123 *
726 jgs 94 */
727 woo409 757 ESCRIPT_DLL_API
728 jgs 94 double
729 jgs 102 inf() const;
730 jgs 94
731     /**
732     \brief
733 jgs 102 Return the absolute value of each data point of this Data object.
734 jgs 123 *
735 jgs 94 */
736 woo409 757 ESCRIPT_DLL_API
737 jgs 102 Data
738     abs() const;
739 jgs 94
740     /**
741     \brief
742 jgs 102 Return the maximum value of each data point of this Data object.
743 jgs 123 *
744 jgs 94 */
745 woo409 757 ESCRIPT_DLL_API
746 jgs 102 Data
747     maxval() const;
748 jgs 94
749     /**
750     \brief
751 jgs 102 Return the minimum value of each data point of this Data object.
752 jgs 123 *
753 jgs 94 */
754 woo409 757 ESCRIPT_DLL_API
755 jgs 94 Data
756 jgs 102 minval() const;
757 jgs 94
758     /**
759     \brief
760 jgs 121 Return the (sample number, data-point number) of the data point with
761     the minimum value in this Data object.
762     */
763 woo409 757 ESCRIPT_DLL_API
764 jgs 121 const boost::python::tuple
765     mindp() const;
766    
767 woo409 757 ESCRIPT_DLL_API
768 jgs 148 void
769     calc_mindp(int& SampleNo,
770     int& DataPointNo) const;
771    
772 jgs 121 /**
773     \brief
774 jgs 102 Return the sign of each data point of this Data object.
775     -1 for negative values, zero for zero values, 1 for positive values.
776 jgs 123 *
777 jgs 94 */
778 woo409 757 ESCRIPT_DLL_API
779 jgs 102 Data
780     sign() const;
781 jgs 94
782     /**
783 jgs 123 \brief
784 gross 576 Return the eigenvalues of the symmetric part at each data point of this Data object in increasing values.
785     Currently this function is restricted to rank 2, square shape, and dimension 3.
786     *
787     */
788 woo409 757 ESCRIPT_DLL_API
789 gross 576 Data
790     eigenvalues() const;
791    
792     /**
793     \brief
794     Return the eigenvalues and corresponding eigenvcetors of the symmetric part at each data point of this Data object.
795     the eigenvalues are ordered in increasing size where eigenvalues with relative difference less than
796     tol are treated as equal. The eigenvectors are orthogonal, normalized and the sclaed such that the
797     first non-zero entry is positive.
798     Currently this function is restricted to rank 2, square shape, and dimension 3
799     *
800     */
801 woo409 757 ESCRIPT_DLL_API
802 gross 576 const boost::python::tuple
803     eigenvalues_and_eigenvectors(const double tol=1.e-12) const;
804    
805     /**
806     \brief
807 jgs 123 Transpose each data point of this Data object around the given axis.
808     --* not implemented yet *--
809     *
810 jgs 102 */
811 woo409 757 ESCRIPT_DLL_API
812 jgs 102 Data
813     transpose(int axis) const;
814    
815     /**
816 jgs 123 \brief
817     Calculate the trace of each data point of this Data object.
818     *
819 jgs 102 */
820 woo409 757 ESCRIPT_DLL_API
821 jgs 102 Data
822     trace() const;
823    
824     /**
825 jgs 123 \brief
826     Return the sin of each data point of this Data object.
827     *
828 jgs 102 */
829 woo409 757 ESCRIPT_DLL_API
830 jgs 102 Data
831 jgs 123 sin() const;
832    
833     /**
834     \brief
835     Return the cos of each data point of this Data object.
836     *
837     */
838 woo409 757 ESCRIPT_DLL_API
839 jgs 123 Data
840     cos() const;
841    
842     /**
843     \brief
844     Return the tan of each data point of this Data object.
845     *
846     */
847 woo409 757 ESCRIPT_DLL_API
848 jgs 123 Data
849     tan() const;
850    
851     /**
852     \brief
853 jgs 150 Return the asin of each data point of this Data object.
854     *
855     */
856 woo409 757 ESCRIPT_DLL_API
857 jgs 150 Data
858     asin() const;
859    
860     /**
861     \brief
862     Return the acos of each data point of this Data object.
863     *
864     */
865 woo409 757 ESCRIPT_DLL_API
866 jgs 150 Data
867     acos() const;
868    
869     /**
870     \brief
871     Return the atan of each data point of this Data object.
872     *
873     */
874 woo409 757 ESCRIPT_DLL_API
875 jgs 150 Data
876     atan() const;
877    
878     /**
879     \brief
880     Return the sinh of each data point of this Data object.
881     *
882     */
883 woo409 757 ESCRIPT_DLL_API
884 jgs 150 Data
885     sinh() const;
886    
887     /**
888     \brief
889     Return the cosh of each data point of this Data object.
890     *
891     */
892 woo409 757 ESCRIPT_DLL_API
893 jgs 150 Data
894     cosh() const;
895    
896     /**
897     \brief
898     Return the tanh of each data point of this Data object.
899     *
900     */
901 woo409 757 ESCRIPT_DLL_API
902 jgs 150 Data
903     tanh() const;
904    
905     /**
906     \brief
907     Return the asinh of each data point of this Data object.
908     *
909     */
910 woo409 757 ESCRIPT_DLL_API
911 jgs 150 Data
912     asinh() const;
913    
914     /**
915     \brief
916     Return the acosh of each data point of this Data object.
917     *
918     */
919 woo409 757 ESCRIPT_DLL_API
920 jgs 150 Data
921     acosh() const;
922    
923     /**
924     \brief
925     Return the atanh of each data point of this Data object.
926     *
927     */
928 woo409 757 ESCRIPT_DLL_API
929 jgs 150 Data
930     atanh() const;
931    
932     /**
933     \brief
934 jgs 123 Return the log to base 10 of each data point of this Data object.
935     *
936     */
937 woo409 757 ESCRIPT_DLL_API
938 jgs 123 Data
939 gross 286 log10() const;
940 jgs 123
941     /**
942     \brief
943     Return the natural log of each data point of this Data object.
944     *
945     */
946 woo409 757 ESCRIPT_DLL_API
947 jgs 123 Data
948 gross 286 log() const;
949 jgs 123
950     /**
951     \brief
952     Return the exponential function of each data point of this Data object.
953     *
954     */
955 woo409 757 ESCRIPT_DLL_API
956 jgs 123 Data
957 jgs 102 exp() const;
958    
959     /**
960 jgs 123 \brief
961     Return the square root of each data point of this Data object.
962     *
963 jgs 102 */
964 woo409 757 ESCRIPT_DLL_API
965 jgs 102 Data
966     sqrt() const;
967    
968     /**
969 jgs 123 \brief
970     Return the negation of each data point of this Data object.
971     *
972 jgs 121 */
973 woo409 757 ESCRIPT_DLL_API
974 jgs 121 Data
975     neg() const;
976    
977     /**
978 jgs 123 \brief
979     Return the identity of each data point of this Data object.
980     Simply returns this object unmodified.
981     *
982 jgs 121 */
983 woo409 757 ESCRIPT_DLL_API
984 jgs 121 Data
985     pos() const;
986    
987     /**
988 jgs 94 \brief
989 jgs 102 Return the given power of each data point of this Data object.
990 jgs 121
991     \param right Input - the power to raise the object to.
992 jgs 123 *
993 jgs 102 */
994 woo409 757 ESCRIPT_DLL_API
995 jgs 102 Data
996     powD(const Data& right) const;
997    
998 jgs 121 /**
999 jgs 123 \brief
1000     Return the given power of each data point of this boost python object.
1001    
1002     \param right Input - the power to raise the object to.
1003     *
1004 jgs 121 */
1005 woo409 757 ESCRIPT_DLL_API
1006 jgs 102 Data
1007     powO(const boost::python::object& right) const;
1008    
1009     /**
1010 jgs 123 \brief
1011 gross 699 Return the given power of each data point of this boost python object.
1012    
1013     \param left Input - the bases
1014     *
1015     */
1016    
1017 woo409 757 ESCRIPT_DLL_API
1018 gross 699 Data
1019     rpowO(const boost::python::object& left) const;
1020    
1021     /**
1022     \brief
1023 jgs 123 writes the object to a file in the DX file format
1024 jgs 104 */
1025 woo409 757 ESCRIPT_DLL_API
1026 jgs 104 void
1027     saveDX(std::string fileName) const;
1028    
1029     /**
1030 jgs 123 \brief
1031     writes the object to a file in the VTK file format
1032 jgs 110 */
1033 woo409 757 ESCRIPT_DLL_API
1034 jgs 110 void
1035     saveVTK(std::string fileName) const;
1036    
1037     /**
1038 jgs 102 \brief
1039     Overloaded operator +=
1040     \param right - Input - The right hand side.
1041 jgs 123 *
1042 jgs 102 */
1043 woo409 757 ESCRIPT_DLL_API
1044 jgs 102 Data& operator+=(const Data& right);
1045 woo409 757 ESCRIPT_DLL_API
1046 jgs 102 Data& operator+=(const boost::python::object& right);
1047    
1048     /**
1049     \brief
1050     Overloaded operator -=
1051     \param right - Input - The right hand side.
1052 jgs 123 *
1053 jgs 102 */
1054 woo409 757 ESCRIPT_DLL_API
1055 jgs 102 Data& operator-=(const Data& right);
1056 woo409 757 ESCRIPT_DLL_API
1057 jgs 102 Data& operator-=(const boost::python::object& right);
1058    
1059     /**
1060     \brief
1061     Overloaded operator *=
1062     \param right - Input - The right hand side.
1063 jgs 123 *
1064 jgs 102 */
1065 woo409 757 ESCRIPT_DLL_API
1066 jgs 102 Data& operator*=(const Data& right);
1067 woo409 757 ESCRIPT_DLL_API
1068 jgs 102 Data& operator*=(const boost::python::object& right);
1069    
1070     /**
1071     \brief
1072     Overloaded operator /=
1073     \param right - Input - The right hand side.
1074 jgs 123 *
1075 jgs 102 */
1076 woo409 757 ESCRIPT_DLL_API
1077 jgs 102 Data& operator/=(const Data& right);
1078 woo409 757 ESCRIPT_DLL_API
1079 jgs 102 Data& operator/=(const boost::python::object& right);
1080    
1081     /**
1082     \brief
1083 jgs 94 Returns true if this can be interpolated to functionspace.
1084     */
1085 woo409 757 ESCRIPT_DLL_API
1086 jgs 94 bool
1087     probeInterpolation(const FunctionSpace& functionspace) const;
1088    
1089     /**
1090 jgs 102 Data object slicing methods.
1091     */
1092    
1093     /**
1094 jgs 94 \brief
1095 jgs 102 Returns a slice from this Data object.
1096    
1097     /description
1098     Implements the [] get operator in python.
1099     Calls getSlice.
1100    
1101     \param key - Input - python slice tuple specifying
1102     slice to return.
1103 jgs 94 */
1104 woo409 757 ESCRIPT_DLL_API
1105 jgs 102 Data
1106     getItem(const boost::python::object& key) const;
1107    
1108     /**
1109     \brief
1110     Copies slice from value into this Data object.
1111    
1112     Implements the [] set operator in python.
1113     Calls setSlice.
1114    
1115     \param key - Input - python slice tuple specifying
1116     slice to copy from value.
1117     \param value - Input - Data object to copy from.
1118     */
1119 woo409 757 ESCRIPT_DLL_API
1120 jgs 94 void
1121 jgs 102 setItemD(const boost::python::object& key,
1122     const Data& value);
1123 jgs 94
1124 woo409 757 ESCRIPT_DLL_API
1125 jgs 102 void
1126     setItemO(const boost::python::object& key,
1127     const boost::python::object& value);
1128    
1129     // These following public methods should be treated as private.
1130    
1131 jgs 94 /**
1132     \brief
1133 jgs 102 Perform the given unary operation on every element of every data point in
1134     this Data object.
1135 jgs 94 */
1136 jgs 102 template <class UnaryFunction>
1137 woo409 757 ESCRIPT_DLL_API
1138 jgs 102 inline
1139 jgs 94 void
1140 jgs 102 unaryOp(UnaryFunction operation);
1141    
1142     /**
1143     \brief
1144     Return a Data object containing the specified slice of
1145     this Data object.
1146     \param region - Input - Region to copy.
1147 jgs 123 *
1148 jgs 94 */
1149 woo409 757 ESCRIPT_DLL_API
1150 jgs 102 Data
1151     getSlice(const DataArrayView::RegionType& region) const;
1152 jgs 94
1153 jgs 102 /**
1154     \brief
1155     Copy the specified slice from the given value into this
1156     Data object.
1157     \param value - Input - Data to copy from.
1158     \param region - Input - Region to copy.
1159 jgs 123 *
1160 jgs 102 */
1161 woo409 757 ESCRIPT_DLL_API
1162 jgs 102 void
1163     setSlice(const Data& value,
1164     const DataArrayView::RegionType& region);
1165    
1166 jgs 119 /**
1167     \brief
1168     Archive the current Data object to the given file.
1169     \param fileName - Input - file to archive to.
1170     */
1171 woo409 757 ESCRIPT_DLL_API
1172 jgs 119 void
1173     archiveData(const std::string fileName);
1174    
1175     /**
1176     \brief
1177     Extract the Data object archived in the given file, overwriting
1178     the current Data object.
1179     Note - the current object must be of type DataEmpty.
1180     \param fileName - Input - file to extract from.
1181 jgs 121 \param fspace - Input - a suitable FunctionSpace descibing the data.
1182 jgs 119 */
1183 woo409 757 ESCRIPT_DLL_API
1184 jgs 119 void
1185     extractData(const std::string fileName,
1186     const FunctionSpace& fspace);
1187    
1188 bcumming 751
1189     /**
1190     \brief
1191     print the data values to stdout. Used for debugging
1192     */
1193     void print();
1194    
1195 jgs 102 protected:
1196    
1197 jgs 94 private:
1198    
1199     /**
1200     \brief
1201 jgs 102 Check *this and the right operand are compatible. Throws
1202     an exception if they aren't.
1203     \param right - Input - The right hand side.
1204     */
1205     inline
1206     void
1207     operandCheck(const Data& right) const
1208     {
1209     return m_data->operandCheck(*(right.m_data.get()));
1210     }
1211    
1212     /**
1213     \brief
1214     Perform the specified reduction algorithm on every element of every data point in
1215 jgs 113 this Data object according to the given function and return the single value result.
1216 jgs 102 */
1217 jgs 147 template <class BinaryFunction>
1218 jgs 102 inline
1219     double
1220 jgs 147 algorithm(BinaryFunction operation,
1221     double initial_value) const;
1222 jgs 102
1223 jgs 113 /**
1224     \brief
1225     Reduce each data-point in this Data object using the given operation. Return a Data
1226     object with the same number of data-points, but with each data-point containing only
1227     one value - the result of the reduction operation on the corresponding data-point in
1228     this Data object
1229     */
1230 jgs 147 template <class BinaryFunction>
1231 jgs 106 inline
1232     Data
1233 jgs 147 dp_algorithm(BinaryFunction operation,
1234     double initial_value) const;
1235 jgs 106
1236 jgs 102 /**
1237     \brief
1238     Perform the given binary operation on all of the data's elements.
1239     The underlying type of the right hand side (right) determines the final
1240     type of *this after the operation. For example if the right hand side
1241     is expanded *this will be expanded if necessary.
1242     RHS is a Data object.
1243     */
1244     template <class BinaryFunction>
1245     inline
1246     void
1247     binaryOp(const Data& right,
1248     BinaryFunction operation);
1249    
1250     /**
1251     \brief
1252     Perform the given binary operation on all of the data's elements.
1253     RHS is a boost::python object.
1254     */
1255     template <class BinaryFunction>
1256     inline
1257     void
1258     binaryOp(const boost::python::object& right,
1259     BinaryFunction operation);
1260    
1261     /**
1262     \brief
1263     Convert the data type of the RHS to match this.
1264     \param right - Input - data type to match.
1265     */
1266     void
1267     typeMatchLeft(Data& right) const;
1268    
1269     /**
1270     \brief
1271     Convert the data type of this to match the RHS.
1272     \param right - Input - data type to match.
1273     */
1274     void
1275     typeMatchRight(const Data& right);
1276    
1277     /**
1278     \brief
1279 jgs 94 Construct a Data object of the appropriate type.
1280     */
1281     template <class IValueType>
1282     void
1283     initialise(const IValueType& value,
1284     const FunctionSpace& what,
1285     bool expanded);
1286    
1287     /**
1288     \brief
1289     Reshape the data point if the data point is currently rank 0.
1290     Will throw an exception if the data points are not rank 0.
1291     The original data point value is used for all values of the new
1292     data point.
1293     */
1294     void
1295     reshapeDataPoint(const DataArrayView::ShapeType& shape);
1296    
1297     //
1298 jgs 102 // pointer to the actual data object
1299 jgs 94 boost::shared_ptr<DataAbstract> m_data;
1300    
1301 jgs 123 //
1302     // pointer to the internal profiling data
1303     struct profDataEntry *profData;
1304    
1305 jgs 94 };
1306    
1307     template <class IValueType>
1308     void
1309     Data::initialise(const IValueType& value,
1310     const FunctionSpace& what,
1311     bool expanded)
1312     {
1313     //
1314     // Construct a Data object of the appropriate type.
1315     // Construct the object first as there seems to be a bug which causes
1316     // undefined behaviour if an exception is thrown during construction
1317     // within the shared_ptr constructor.
1318     if (expanded) {
1319     DataAbstract* temp=new DataExpanded(value,what);
1320 jgs 102 boost::shared_ptr<DataAbstract> temp_data(temp);
1321     m_data=temp_data;
1322 jgs 94 } else {
1323     DataAbstract* temp=new DataConstant(value,what);
1324 jgs 102 boost::shared_ptr<DataAbstract> temp_data(temp);
1325     m_data=temp_data;
1326 jgs 94 }
1327     }
1328    
1329 jgs 102 /**
1330     Binary Data object operators.
1331     */
1332 jgs 94
1333     /**
1334     \brief
1335     Operator+
1336     Takes two Data objects.
1337     */
1338 woo409 757 ESCRIPT_DLL_API Data operator+(const Data& left, const Data& right);
1339 jgs 94
1340     /**
1341     \brief
1342     Operator-
1343     Takes two Data objects.
1344     */
1345 woo409 757 ESCRIPT_DLL_API Data operator-(const Data& left, const Data& right);
1346 jgs 94
1347     /**
1348     \brief
1349     Operator*
1350     Takes two Data objects.
1351     */
1352 woo409 757 ESCRIPT_DLL_API Data operator*(const Data& left, const Data& right);
1353 jgs 94
1354     /**
1355     \brief
1356     Operator/
1357     Takes two Data objects.
1358     */
1359 woo409 757 ESCRIPT_DLL_API Data operator/(const Data& left, const Data& right);
1360 jgs 94
1361     /**
1362     \brief
1363     Operator+
1364     Takes LHS Data object and RHS python::object.
1365     python::object must be convertable to Data type.
1366     */
1367 woo409 757 ESCRIPT_DLL_API Data operator+(const Data& left, const boost::python::object& right);
1368 jgs 94
1369     /**
1370     \brief
1371     Operator-
1372     Takes LHS Data object and RHS python::object.
1373     python::object must be convertable to Data type.
1374     */
1375 woo409 757 ESCRIPT_DLL_API Data operator-(const Data& left, const boost::python::object& right);
1376 jgs 94
1377     /**
1378     \brief
1379     Operator*
1380     Takes LHS Data object and RHS python::object.
1381     python::object must be convertable to Data type.
1382     */
1383 woo409 757 ESCRIPT_DLL_API Data operator*(const Data& left, const boost::python::object& right);
1384 jgs 94
1385     /**
1386     \brief
1387     Operator/
1388     Takes LHS Data object and RHS python::object.
1389     python::object must be convertable to Data type.
1390     */
1391 woo409 757 ESCRIPT_DLL_API Data operator/(const Data& left, const boost::python::object& right);
1392 jgs 94
1393     /**
1394     \brief
1395     Operator+
1396     Takes LHS python::object and RHS Data object.
1397     python::object must be convertable to Data type.
1398     */
1399 woo409 757 ESCRIPT_DLL_API Data operator+(const boost::python::object& left, const Data& right);
1400 jgs 94
1401     /**
1402     \brief
1403     Operator-
1404     Takes LHS python::object and RHS Data object.
1405     python::object must be convertable to Data type.
1406     */
1407 woo409 757 ESCRIPT_DLL_API Data operator-(const boost::python::object& left, const Data& right);
1408 jgs 94
1409     /**
1410     \brief
1411     Operator*
1412     Takes LHS python::object and RHS Data object.
1413     python::object must be convertable to Data type.
1414     */
1415 woo409 757 ESCRIPT_DLL_API Data operator*(const boost::python::object& left, const Data& right);
1416 jgs 94
1417     /**
1418     \brief
1419     Operator/
1420     Takes LHS python::object and RHS Data object.
1421     python::object must be convertable to Data type.
1422     */
1423 woo409 757 ESCRIPT_DLL_API Data operator/(const boost::python::object& left, const Data& right);
1424 jgs 94
1425     /**
1426     \brief
1427     Output operator
1428     */
1429 woo409 757 ESCRIPT_DLL_API std::ostream& operator<<(std::ostream& o, const Data& data);
1430 jgs 94
1431     /**
1432     \brief
1433     Return true if operands are equivalent, else return false.
1434     NB: this operator does very little at this point, and isn't to
1435     be relied on. Requires further implementation.
1436     */
1437 woo409 757 //ESCRIPT_DLL_API bool operator==(const Data& left, const Data& right);
1438 jgs 94
1439 jgs 102 /**
1440     \brief
1441     Perform the given binary operation with this and right as operands.
1442     Right is a Data object.
1443     */
1444 jgs 94 template <class BinaryFunction>
1445     inline
1446     void
1447     Data::binaryOp(const Data& right,
1448     BinaryFunction operation)
1449     {
1450     //
1451     // if this has a rank of zero promote it to the rank of the RHS
1452     if (getPointDataView().getRank()==0 && right.getPointDataView().getRank()!=0) {
1453     reshapeDataPoint(right.getPointDataView().getShape());
1454     }
1455     //
1456     // initially make the temporary a shallow copy
1457     Data tempRight(right);
1458     if (getFunctionSpace()!=right.getFunctionSpace()) {
1459     if (right.probeInterpolation(getFunctionSpace())) {
1460     //
1461     // an interpolation is required so create a new Data
1462     tempRight=Data(right,this->getFunctionSpace());
1463     } else if (probeInterpolation(right.getFunctionSpace())) {
1464     //
1465     // interpolate onto the RHS function space
1466     Data tempLeft(*this,right.getFunctionSpace());
1467     m_data=tempLeft.m_data;
1468     }
1469     }
1470     operandCheck(tempRight);
1471     //
1472     // ensure this has the right type for the RHS
1473 jgs 102 typeMatchRight(tempRight);
1474 jgs 94 //
1475     // Need to cast to the concrete types so that the correct binaryOp
1476     // is called.
1477     if (isExpanded()) {
1478     //
1479     // Expanded data will be done in parallel, the right hand side can be
1480     // of any data type
1481     DataExpanded* leftC=dynamic_cast<DataExpanded*>(m_data.get());
1482     EsysAssert((leftC!=0), "Programming error - casting to DataExpanded.");
1483     escript::binaryOp(*leftC,*(tempRight.m_data.get()),operation);
1484     } else if (isTagged()) {
1485     //
1486     // Tagged data is operated on serially, the right hand side can be
1487     // either DataConstant or DataTagged
1488     DataTagged* leftC=dynamic_cast<DataTagged*>(m_data.get());
1489     EsysAssert((leftC!=0), "Programming error - casting to DataTagged.");
1490     if (right.isTagged()) {
1491     DataTagged* rightC=dynamic_cast<DataTagged*>(tempRight.m_data.get());
1492     EsysAssert((rightC!=0), "Programming error - casting to DataTagged.");
1493     escript::binaryOp(*leftC,*rightC,operation);
1494     } else {
1495     DataConstant* rightC=dynamic_cast<DataConstant*>(tempRight.m_data.get());
1496     EsysAssert((rightC!=0), "Programming error - casting to DataConstant.");
1497     escript::binaryOp(*leftC,*rightC,operation);
1498     }
1499 jgs 102 } else if (isConstant()) {
1500 jgs 94 DataConstant* leftC=dynamic_cast<DataConstant*>(m_data.get());
1501     DataConstant* rightC=dynamic_cast<DataConstant*>(tempRight.m_data.get());
1502     EsysAssert((leftC!=0 && rightC!=0), "Programming error - casting to DataConstant.");
1503     escript::binaryOp(*leftC,*rightC,operation);
1504     }
1505     }
1506    
1507 jgs 102 /**
1508     \brief
1509     Perform the given binary operation with this and right as operands.
1510     Right is a boost::python object.
1511     */
1512 jgs 94 template <class BinaryFunction>
1513     inline
1514     void
1515     Data::binaryOp(const boost::python::object& right,
1516     BinaryFunction operation)
1517     {
1518     DataArray temp(right);
1519     //
1520     // if this has a rank of zero promote it to the rank of the RHS.
1521     if (getPointDataView().getRank()==0 && temp.getView().getRank()!=0) {
1522     reshapeDataPoint(temp.getView().getShape());
1523     }
1524     //
1525     // Always allow scalar values for the RHS but check other shapes
1526     if (temp.getView().getRank()!=0) {
1527     if (!getPointDataView().checkShape(temp.getView().getShape())) {
1528     throw DataException(getPointDataView().createShapeErrorMessage(
1529     "Error - RHS shape doesn't match LHS shape.",temp.getView().getShape()));
1530     }
1531     }
1532     if (isExpanded()) {
1533     DataExpanded* leftC=dynamic_cast<DataExpanded*>(m_data.get());
1534     EsysAssert((leftC!=0),"Programming error - casting to DataExpanded.");
1535     escript::binaryOp(*leftC,temp.getView(),operation);
1536     } else if (isTagged()) {
1537     DataTagged* leftC=dynamic_cast<DataTagged*>(m_data.get());
1538     EsysAssert((leftC!=0), "Programming error - casting to DataTagged.");
1539     escript::binaryOp(*leftC,temp.getView(),operation);
1540 jgs 102 } else if (isConstant()) {
1541 jgs 94 DataConstant* leftC=dynamic_cast<DataConstant*>(m_data.get());
1542     EsysAssert((leftC!=0),"Programming error - casting to DataConstant.");
1543     escript::binaryOp(*leftC,temp.getView(),operation);
1544     }
1545     }
1546    
1547 jgs 102 /**
1548     \brief
1549     Perform the given unary operation on other and return the result.
1550     Given operation is performed on each element of each data point, thus
1551     argument object is a rank n Data object, and returned object is a rank n
1552     Data object.
1553     Calls Data::unaryOp.
1554     */
1555 jgs 94 template <class UnaryFunction>
1556     inline
1557 jgs 102 Data
1558     unaryOp(const Data& other,
1559     UnaryFunction operation)
1560     {
1561     Data result;
1562     result.copy(other);
1563     result.unaryOp(operation);
1564     return result;
1565     }
1566    
1567     /**
1568     \brief
1569     Perform the given unary operation on this.
1570     Given operation is performed on each element of each data point.
1571     Calls escript::unaryOp.
1572     */
1573     template <class UnaryFunction>
1574     inline
1575 jgs 94 void
1576     Data::unaryOp(UnaryFunction operation)
1577     {
1578     if (isExpanded()) {
1579     DataExpanded* leftC=dynamic_cast<DataExpanded*>(m_data.get());
1580     EsysAssert((leftC!=0), "Programming error - casting to DataExpanded.");
1581     escript::unaryOp(*leftC,operation);
1582     } else if (isTagged()) {
1583     DataTagged* leftC=dynamic_cast<DataTagged*>(m_data.get());
1584     EsysAssert((leftC!=0), "Programming error - casting to DataTagged.");
1585     escript::unaryOp(*leftC,operation);
1586 jgs 102 } else if (isConstant()) {
1587 jgs 94 DataConstant* leftC=dynamic_cast<DataConstant*>(m_data.get());
1588     EsysAssert((leftC!=0), "Programming error - casting to DataConstant.");
1589     escript::unaryOp(*leftC,operation);
1590     }
1591     }
1592    
1593 jgs 102 /**
1594     \brief
1595     Perform the given Data object reduction algorithm on this and return the result.
1596     Given operation combines each element of each data point, thus argument
1597     object (*this) is a rank n Data object, and returned object is a scalar.
1598     Calls escript::algorithm.
1599     */
1600 jgs 147 template <class BinaryFunction>
1601 jgs 94 inline
1602     double
1603 jgs 147 Data::algorithm(BinaryFunction operation, double initial_value) const
1604 jgs 94 {
1605     if (isExpanded()) {
1606     DataExpanded* leftC=dynamic_cast<DataExpanded*>(m_data.get());
1607     EsysAssert((leftC!=0), "Programming error - casting to DataExpanded.");
1608 jgs 147 return escript::algorithm(*leftC,operation,initial_value);
1609 jgs 102 } else if (isTagged()) {
1610 jgs 94 DataTagged* leftC=dynamic_cast<DataTagged*>(m_data.get());
1611     EsysAssert((leftC!=0), "Programming error - casting to DataTagged.");
1612 jgs 147 return escript::algorithm(*leftC,operation,initial_value);
1613 jgs 102 } else if (isConstant()) {
1614 jgs 94 DataConstant* leftC=dynamic_cast<DataConstant*>(m_data.get());
1615     EsysAssert((leftC!=0), "Programming error - casting to DataConstant.");
1616 jgs 147 return escript::algorithm(*leftC,operation,initial_value);
1617 jgs 94 }
1618 jgs 102 return 0;
1619 jgs 94 }
1620    
1621 jgs 102 /**
1622     \brief
1623     Perform the given data point reduction algorithm on data and return the result.
1624     Given operation combines each element within each data point into a scalar,
1625     thus argument object is a rank n Data object, and returned object is a
1626     rank 0 Data object.
1627     Calls escript::dp_algorithm.
1628     */
1629 jgs 147 template <class BinaryFunction>
1630 jgs 94 inline
1631     Data
1632 jgs 147 Data::dp_algorithm(BinaryFunction operation, double initial_value) const
1633 jgs 94 {
1634 jgs 106 if (isExpanded()) {
1635 jgs 559 Data result(0,DataArrayView::ShapeType(),getFunctionSpace(),isExpanded());
1636 jgs 106 DataExpanded* dataE=dynamic_cast<DataExpanded*>(m_data.get());
1637 jgs 102 DataExpanded* resultE=dynamic_cast<DataExpanded*>(result.m_data.get());
1638     EsysAssert((dataE!=0), "Programming error - casting data to DataExpanded.");
1639     EsysAssert((resultE!=0), "Programming error - casting result to DataExpanded.");
1640 jgs 147 escript::dp_algorithm(*dataE,*resultE,operation,initial_value);
1641 jgs 559 return result;
1642 jgs 106 } else if (isTagged()) {
1643     DataTagged* dataT=dynamic_cast<DataTagged*>(m_data.get());
1644 jgs 562 DataArrayView::ShapeType viewShape;
1645     DataArrayView::ValueType viewData(1);
1646     viewData[0]=0;
1647     DataArrayView defaultValue(viewData,viewShape);
1648 jgs 559 DataTagged::TagListType keys;
1649 jgs 562 DataTagged::ValueListType values;
1650 jgs 559 DataTagged::DataMapType::const_iterator i;
1651     for (i=dataT->getTagLookup().begin();i!=dataT->getTagLookup().end();i++) {
1652     keys.push_back(i->first);
1653 jgs 562 values.push_back(defaultValue);
1654 jgs 559 }
1655     Data result(keys,values,defaultValue,getFunctionSpace());
1656 jgs 102 DataTagged* resultT=dynamic_cast<DataTagged*>(result.m_data.get());
1657     EsysAssert((dataT!=0), "Programming error - casting data to DataTagged.");
1658     EsysAssert((resultT!=0), "Programming error - casting result to DataTagged.");
1659 jgs 147 escript::dp_algorithm(*dataT,*resultT,operation,initial_value);
1660 jgs 559 return result;
1661 jgs 106 } else if (isConstant()) {
1662 jgs 559 Data result(0,DataArrayView::ShapeType(),getFunctionSpace(),isExpanded());
1663 jgs 106 DataConstant* dataC=dynamic_cast<DataConstant*>(m_data.get());
1664 jgs 102 DataConstant* resultC=dynamic_cast<DataConstant*>(result.m_data.get());
1665     EsysAssert((dataC!=0), "Programming error - casting data to DataConstant.");
1666     EsysAssert((resultC!=0), "Programming error - casting result to DataConstant.");
1667 jgs 147 escript::dp_algorithm(*dataC,*resultC,operation,initial_value);
1668 jgs 559 return result;
1669 jgs 102 }
1670 jgs 559 Data falseRetVal; // to keep compiler quiet
1671     return falseRetVal;
1672 jgs 94 }
1673    
1674     }
1675     #endif

Properties

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

  ViewVC Help
Powered by ViewVC 1.1.26