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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 813 - (show annotations)
Mon Aug 21 02:08:47 2006 UTC (13 years, 3 months ago) by ksteube
File MIME type: text/plain
File size: 43635 byte(s)
Tensor products for Data objects are now computed by a C++ method
C_GeneralTensorProduct, which calls C function matrix_matrix_product
to do the actual calculation.

Can perform product with either input transposed in place, meaning
without first computing the transpose in a separate step.

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

Properties

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

  ViewVC Help
Powered by ViewVC 1.1.26