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

Diff of /temp/escript/src/Data.h

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

trunk/esys2/escript/src/Data/Data.h revision 94 by jgs, Wed Oct 27 00:45:54 2004 UTC trunk/escript/src/Data.h revision 790 by bcumming, Wed Jul 26 23:12:34 2006 UTC
# Line 1  Line 1 
1  // $Id$  // $Id$
2  /*=============================================================================  /*
3     ************************************************************
4   ******************************************************************************   *          Copyright 2006 by ACcESS MNRF                   *
5   *                                                                            *   *                                                          *
6   *       COPYRIGHT ACcESS 2004 -  All Rights Reserved                         *   *              http://www.access.edu.au                    *
7   *                                                                            *   *       Primary Business: Queensland, Australia            *
8   * This software is the property of ACcESS.  No part of this code             *   *  Licensed under the Open Software License version 3.0    *
9   * may be copied in any form or by any means without the expressed written    *   *     http://www.opensource.org/licenses/osl-3.0.php       *
10   * consent of ACcESS.  Copying, use or modification of this software          *   *                                                          *
11   * by any unauthorised person is illegal unless that                          *   ************************************************************
12   * person has a software license agreement with ACcESS.                       *  */
  *                                                                            *  
  ******************************************************************************  
13    
14  ******************************************************************************/  /** \file Data.h */
15    
16  #ifndef DATA_H  #ifndef DATA_H
17  #define DATA_H  #define DATA_H
18    #include "system_dep.h"
19    
20  #include "escript/Data/DataAbstract.h"  #include "DataAbstract.h"
21  #include "escript/Data/DataTagged.h"  #include "DataAlgorithm.h"
22  #include "escript/Data/FunctionSpace.h"  #include "FunctionSpace.h"
23  #include "escript/Data/BinaryOp.h"  #include "BinaryOp.h"
24  #include "escript/Data/UnaryOp.h"  #include "UnaryOp.h"
25    #include "DataException.h"
26    
27  extern "C" {  extern "C" {
28  #include "escript/Data/DataC.h"  #include "DataC.h"
29    #include "paso/Paso.h"
30  }  }
31    
32  #include <iostream>  #ifndef PASO_MPI
33    #define MPI_Comm long
34    #endif
35    
36  #include <string>  #include <string>
 #include <memory>  
37  #include <algorithm>  #include <algorithm>
38    
39  #include <boost/shared_ptr.hpp>  #include <boost/shared_ptr.hpp>
40  #include <boost/python/object.hpp>  #include <boost/python/object.hpp>
 #include <boost/python/list.hpp>  
41  #include <boost/python/tuple.hpp>  #include <boost/python/tuple.hpp>
42  #include <boost/python/numeric.hpp>  #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     \brief
54     Data is essentially a factory class which creates the appropriate Data     Data creates the appropriate Data object for the given construction
55     object for the given construction arguments. It retains control over     arguments.
    the object created for the lifetime of the object.  
    The type of Data object referred to may change during the lifetime of  
    the Data object.  
56    
57     Description:     Description:
58     Data is essentially a factory class which creates the appropriate Data     Data is essentially a factory class which creates the appropriate Data
# Line 54  extern "C" { Line 61  extern "C" {
61     The type of Data object referred to may change during the lifetime of     The type of Data object referred to may change during the lifetime of
62     the Data object.     the Data object.
63  */  */
   
 namespace escript {  
   
 //  
 // Forward declaration for various implimentations of Data.  
 class DataEmpty;  
 class DataConstant;  
 class DataTagged;  
 class DataExpanded;  
   
64  class Data {  class Data {
65    
66    public:    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);    typedef double (*UnaryDFunPtr)(double);
71    typedef double (*BinaryDFunPtr)(double,double);    typedef double (*BinaryDFunPtr)(double,double);
72    
73    /**    /**
74         Constructors.
75      */
76    
77      /**
78       \brief       \brief
79       Default constructor.       Default constructor.
80       Creates a DataEmpty object.       Creates a DataEmpty object.
81    */    */
82      ESCRIPT_DLL_API
83    Data();    Data();
84    
85    /**    /**
# Line 83  class Data { Line 87  class Data {
87       Copy constructor.       Copy constructor.
88       WARNING: Only performs a shallow copy.       WARNING: Only performs a shallow copy.
89    */    */
90      ESCRIPT_DLL_API
91    Data(const Data& inData);    Data(const Data& inData);
92    
93    /**    /**
94       \brief       \brief
95       Constructor from another Data object. If "what" is different from the       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       function space of inData the inData are tried to be interpolated to what,
97       otherwise a shallow copy of inData is returned.       otherwise a shallow copy of inData is returned.
98    */    */
99      ESCRIPT_DLL_API
100    Data(const Data& inData,    Data(const Data& inData,
101         const FunctionSpace& what);         const FunctionSpace& what);
102    
# Line 104  class Data { Line 110  class Data {
110                         the value. Otherwise a more efficient storage                         the value. Otherwise a more efficient storage
111                         mechanism will be used.                         mechanism will be used.
112    */    */
113      ESCRIPT_DLL_API
114    Data(const DataArrayView& value,    Data(const DataArrayView& value,
115         const FunctionSpace& what=FunctionSpace(),         const FunctionSpace& what=FunctionSpace(),
116         bool expanded=false);         bool expanded=false);
# Line 119  class Data { Line 126  class Data {
126                         the given value. Otherwise a more efficient storage                         the given value. Otherwise a more efficient storage
127                         mechanism will be used.                         mechanism will be used.
128    */    */
129      ESCRIPT_DLL_API
130    Data(double value,    Data(double value,
131         const DataArrayView::ShapeType& dataPointShape=DataArrayView::ShapeType(),         const DataArrayView::ShapeType& dataPointShape=DataArrayView::ShapeType(),
132         const FunctionSpace& what=FunctionSpace(),         const FunctionSpace& what=FunctionSpace(),
# Line 131  class Data { Line 139  class Data {
139       \param inData - Input - Input Data object.       \param inData - Input - Input Data object.
140       \param region - Input - Region to copy.       \param region - Input - Region to copy.
141    */    */
142      ESCRIPT_DLL_API
143    Data(const Data& inData,    Data(const Data& inData,
144         const DataArrayView::RegionType& region);         const DataArrayView::RegionType& region);
145    
# Line 146  class Data { Line 155  class Data {
155       \param what - Input - A description of what this data represents.       \param what - Input - A description of what this data represents.
156       \param expanded - Input - Flag, if true fill the entire container with       \param expanded - Input - Flag, if true fill the entire container with
157                         the appropriate values.                         the appropriate values.
158        ==>*
159    */    */
160      ESCRIPT_DLL_API
161    Data(const DataTagged::TagListType& tagKeys,    Data(const DataTagged::TagListType& tagKeys,
162         const DataTagged::ValueListType& values,         const DataTagged::ValueListType& values,
163         const DataArrayView& defaultValue,         const DataArrayView& defaultValue,
# Line 163  class Data { Line 174  class Data {
174                         the value. Otherwise a more efficient storage                         the value. Otherwise a more efficient storage
175                         mechanism will be used.                         mechanism will be used.
176    */    */
177      ESCRIPT_DLL_API
178    Data(const boost::python::numeric::array& value,    Data(const boost::python::numeric::array& value,
179         const FunctionSpace& what=FunctionSpace(),         const FunctionSpace& what=FunctionSpace(),
180         bool expanded=false);         bool expanded=false);
# Line 178  class Data { Line 190  class Data {
190                         the value. Otherwise a more efficient storage                         the value. Otherwise a more efficient storage
191                         mechanism will be used.                         mechanism will be used.
192    */    */
193      ESCRIPT_DLL_API
194    Data(const boost::python::object& value,    Data(const boost::python::object& value,
195         const FunctionSpace& what=FunctionSpace(),         const FunctionSpace& what=FunctionSpace(),
196         bool expanded=false);         bool expanded=false);
# Line 191  class Data { Line 204  class Data {
204       \param value - Input - Input data.       \param value - Input - Input data.
205       \param other - Input - contains all other parameters.       \param other - Input - contains all other parameters.
206    */    */
207      ESCRIPT_DLL_API
208    Data(const boost::python::object& value,    Data(const boost::python::object& value,
209         const Data& other);         const Data& other);
210    
# Line 198  class Data { Line 212  class Data {
212       \brief       \brief
213       Constructor which creates a DataConstant of "shape" with constant value.       Constructor which creates a DataConstant of "shape" with constant value.
214    */    */
215      ESCRIPT_DLL_API
216    Data(double value,    Data(double value,
217         const boost::python::tuple& shape=boost::python::make_tuple(),         const boost::python::tuple& shape=boost::python::make_tuple(),
218         const FunctionSpace& what=FunctionSpace(),         const FunctionSpace& what=FunctionSpace(),
219         bool expanded=false);         bool expanded=false);
   
220    /**    /**
221       \brief       \brief
222       Perform the specified algorithm on the Data and return result.       Destructor
223    */    */
224    template <class UnaryFunction>    ESCRIPT_DLL_API
225    inline double    ~Data();
   algorithm(UnaryFunction operation) const;  
226    
227    /**    /**
228       \brief       \brief
229       Perform the given unary operation on all of the data's elements.       Perform a deep copy.
230    */    */
231    template <class UnaryFunction>    ESCRIPT_DLL_API
232    void    void
233    unaryOp(UnaryFunction operation);    copy(const Data& other);
234    
235    /**    /**
236       \brief       Member access methods.
      Perform the given binary operation on all of the data's elements.  
      The underlying type of the right hand side (right) determines the final  
      type of *this after the operation. For example if the right hand side  
      is expanded *this will be expanded if necessary.  
237    */    */
   template <class BinaryFunction>  
   void  
   binaryOp(const Data& right,  
            BinaryFunction operation);  
238    
239    /**    /**
240       \brief       \brief
241       Perform the given binary operation on all of the data's elements.       switches on update protection
242    
243    */    */
244    template <class BinaryFunction>    ESCRIPT_DLL_API
245    void    void
246    binaryOp(const boost::python::object& right,    setProtection();
            BinaryFunction operation);  
247    
248    /**    /**
249       \brief       \brief
250       Overloaded operator +=       Returns trueif the data object is protected against update
251       \param right - Input - The right hand side.  
252    */    */
253    Data& operator+=(const Data& right);    ESCRIPT_DLL_API
254    Data& operator+=(const boost::python::object& right);    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       \brief
266       Overloaded operator -=       Return the values of all data-points for the given sample as a single python numarray object.
      \param right - Input - The right hand side.  
267    */    */
268    Data& operator-=(const Data& right);    ESCRIPT_DLL_API
269    Data& operator-=(const boost::python::object& right);    const boost::python::numeric::array
270      convertToNumArrayFromSampleNo(int sampleNo);
271    
272   /**    /**
273       \brief       \brief
274       Overloaded operator *=       Return the value of the specified data-point as a single python numarray object.
      \param right - Input - The right hand side.  
275    */    */
276    Data& operator*=(const Data& right);  #ifndef PASO_MPI  
277    Data& operator*=(const boost::python::object& right);    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       \brief
293       Overloaded operator /=       Fills the expanded Data object from values of a python numarray object.
      \param right - Input - The right hand side.  
294    */    */
295    Data& operator/=(const Data& right);    ESCRIPT_DLL_API
296    Data& operator/=(const boost::python::object& right);    void
297      fillFromNumArray(const boost::python::numeric::array);
298    
299    /**    /**
300       \brief       \brief
301       Return the power of Data.       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    Data powD(const Data& right) const;    ESCRIPT_DLL_API
307    Data powO(const boost::python::object& right) const;    int
308      getTagNumber(int dpno);
309    
310    /**    /**
311       \brief       \brief
312       Return the C wrapper for the Data object.       Return the C wrapper for the Data object.
313    */    */
314    escriptDataC getDataC();    ESCRIPT_DLL_API
315      escriptDataC
316      getDataC();
317    
318    /**    /**
319       \brief       \brief
320       Return the C wrapper for the Data object - const version.       Return the C wrapper for the Data object - const version.
321    */    */
322    escriptDataC getDataC() const;    ESCRIPT_DLL_API
323      escriptDataC
324      getDataC() const;
325    
326    /**    /**
327       \brief       \brief
328       Write the data as a string.       Write the data as a string.
329    */    */
330    std::string toString() const;    ESCRIPT_DLL_API
331      inline
332      std::string
333      toString() const
334      {
335        return m_data->toString();
336      }
337    
338    /**    /**
339       \brief       \brief
# Line 303  class Data { Line 341  class Data {
341       the shape information for each data point although it also may be used       the shape information for each data point although it also may be used
342       to manipulate the point data.       to manipulate the point data.
343    */    */
344      ESCRIPT_DLL_API
345    inline    inline
346    const DataArrayView&    const DataArrayView&
347    getPointDataView() const    getPointDataView() const
# Line 312  class Data { Line 351  class Data {
351    
352    /**    /**
353       \brief       \brief
354       Perform a deep copy.       Whatever the current Data type make this into a DataExpanded.
   */  
   void  
   copy(const Data& other);  
   
   /**  
     \brief  
     Copy other Data object into this Data object where mask is positive.  
   */  
   void  
   copyWithMask(const Data& other,  
                const Data& mask);  
   
   /**  
      \brief  
      Whatever the current Data type make it expanded.  
355    */    */
356      ESCRIPT_DLL_API
357    void    void
358    expand();    expand();
359    
360    /**    /**
361       \brief       \brief
362       If possible convert the Data type to tagged. This will only allow       If possible convert this Data to DataTagged. This will only allow
363       Constant data to be converted to tagged. An attempt to convert       Constant data to be converted to tagged. An attempt to convert
364       Expanded data to tagged will throw an exception.       Expanded data to tagged will throw an exception.
365        ==>*
366    */    */
367      ESCRIPT_DLL_API
368    void    void
369    tag();    tag();
370    
# Line 345  class Data { Line 372  class Data {
372       \brief       \brief
373       Return true if this Data is expanded.       Return true if this Data is expanded.
374    */    */
375      ESCRIPT_DLL_API
376    bool    bool
377    isExpanded() const;    isExpanded() const;
378    
# Line 352  class Data { Line 380  class Data {
380       \brief       \brief
381       Return true if this Data is tagged.       Return true if this Data is tagged.
382    */    */
383      ESCRIPT_DLL_API
384    bool    bool
385    isTagged() const;    isTagged() const;
386    
387    /**    /**
388       \brief       \brief
389       Return true if this Data is empty.       Return true if this Data is constant.
390    */    */
391      ESCRIPT_DLL_API
392    bool    bool
393    isEmpty() const;    isConstant() const;
394    
395    /**    /**
396       \brief       \brief
397       Return true if this Data is constant.       Return true if this Data is empty.
398    */    */
399      ESCRIPT_DLL_API
400    bool    bool
401    isConstant() const;    isEmpty() const;
402    
403    /**    /**
404       \brief       \brief
405       Return the function space.       Return the function space.
406    */    */
407      ESCRIPT_DLL_API
408    inline    inline
409    const FunctionSpace&    const FunctionSpace&
410    getFunctionSpace() const    getFunctionSpace() const
# Line 384  class Data { Line 416  class Data {
416       \brief       \brief
417       Return a copy of the function space.       Return a copy of the function space.
418    */    */
419      ESCRIPT_DLL_API
420    const FunctionSpace    const FunctionSpace
421    getCopyOfFunctionSpace() const;    getCopyOfFunctionSpace() const;
422    
# Line 391  class Data { Line 424  class Data {
424       \brief       \brief
425       Return the domain.       Return the domain.
426    */    */
427      ESCRIPT_DLL_API
428    inline    inline
429    const AbstractDomain&    const AbstractDomain&
430    getDomain() const    getDomain() const
# Line 402  class Data { Line 436  class Data {
436       \brief       \brief
437       Return a copy of the domain.       Return a copy of the domain.
438    */    */
439      ESCRIPT_DLL_API
440    const AbstractDomain    const AbstractDomain
441    getCopyOfDomain() const;    getCopyOfDomain() const;
442    
# Line 409  class Data { Line 444  class Data {
444       \brief       \brief
445       Return the rank of the point data.       Return the rank of the point data.
446    */    */
447      ESCRIPT_DLL_API
448    inline    inline
449    int    int
450    getDataPointRank() const    getDataPointRank() const
# Line 418  class Data { Line 454  class Data {
454    
455    /**    /**
456       \brief       \brief
457       Return the number of data points per sample.       Return the number of samples.
458    */    */
459      ESCRIPT_DLL_API
460    inline    inline
461    int    int
462    getNumDataPointsPerSample() const    getNumSamples() const
463    {    {
464      return m_data->getNumDPPSample();      return m_data->getNumSamples();
465    }    }
466    
467    /**    /**
468       \brief       \brief
469       Return the number of samples.       Return the number of data points per sample.
470    */    */
471      ESCRIPT_DLL_API
472      inline
473    int    int
474    getNumSamples() const;    getNumDataPointsPerSample() const
475      {
476    /**      return m_data->getNumDPPSample();
477       \brief    }
      Check *this and the right operand are compatible. Throws  
      an exception if they aren't.  
      \param right - Input - The right hand side.  
   */  
   void  
   operandCheck(const Data& right) const;  
478    
479    /**    /**
480       \brief       \brief
# Line 449  class Data { Line 482  class Data {
482       preferred interface but is provided for use by C code.       preferred interface but is provided for use by C code.
483       \param sampleNo - Input - the given sample no.       \param sampleNo - Input - the given sample no.
484    */    */
485      ESCRIPT_DLL_API
486      inline
487    DataAbstract::ValueType::value_type*    DataAbstract::ValueType::value_type*
488    getSampleData(DataAbstract::ShapeType::size_type sampleNo);    getSampleData(DataAbstract::ValueType::size_type sampleNo)
489      {
490        return m_data->getSampleData(sampleNo);
491      }
492    
493    /**    /**
494       \brief       \brief
# Line 458  class Data { Line 496  class Data {
496       access data that isn't tagged an exception will be thrown.       access data that isn't tagged an exception will be thrown.
497       \param tag - Input - the tag key.       \param tag - Input - the tag key.
498    */    */
499      ESCRIPT_DLL_API
500      inline
501    DataAbstract::ValueType::value_type*    DataAbstract::ValueType::value_type*
502    getSampleDataByTag(int tag);    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       \brief
# Line 469  class Data { Line 553  class Data {
553       \param sampleNo - Input -       \param sampleNo - Input -
554       \param dataPointNo - Input -       \param dataPointNo - Input -
555    */    */
556      ESCRIPT_DLL_API
557    inline    inline
558    DataArrayView    DataArrayView
559    getDataPoint(int sampleNo,    getDataPoint(int sampleNo,
560                 int dataPointNo)                 int dataPointNo)
561    {    {
562      return m_data->getDataPoint(sampleNo,dataPointNo);          return m_data->getDataPoint(sampleNo,dataPointNo);
563    }    }
564    
565    /**    /**
566       \brief       \brief
567       Return a reference to the data point shape.       Return a reference to the data point shape.
568    */    */
569      ESCRIPT_DLL_API
570    const DataArrayView::ShapeType&    const DataArrayView::ShapeType&
571    getDataPointShape() const;    getDataPointShape() const;
572    
573    /**    /**
574       \brief       \brief
575       Return data point shape as a tuple of integers:       Return the data point shape as a tuple of integers.
576    */    */
577    boost::python::tuple    ESCRIPT_DLL_API
578      const boost::python::tuple
579    getShapeTuple() const;    getShapeTuple() const;
580    
581    /**    /**
# Line 496  class Data { Line 583  class Data {
583       Return the size of the data point. It is the product of the       Return the size of the data point. It is the product of the
584       data point shape dimensions.       data point shape dimensions.
585    */    */
586      ESCRIPT_DLL_API
587    int    int
588    getDataPointSize() const;    getDataPointSize() const;
589    
590    /**    /**
591       \brief       \brief
592       Return the number of doubles stored for Data.       Return the number of doubles stored for this Data.
593    */    */
594      ESCRIPT_DLL_API
595    DataArrayView::ValueType::size_type    DataArrayView::ValueType::size_type
596    getLength() const;    getLength() const;
597    
598    /**    /**
599       \brief       \brief
600       Interpolates this onto the given functionspace and returns the result as a Data object.       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    Data
647    interpolate(const FunctionSpace& functionspace) const;    interpolate(const FunctionSpace& functionspace) const;
648    
# Line 517  class Data { Line 650  class Data {
650       \brief       \brief
651       Calculates the gradient of the data at the data points of functionspace.       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.       If functionspace is not present the function space of Function(getDomain()) is used.
653         *
654    */    */
655      ESCRIPT_DLL_API
656    Data    Data
657    gradOn(const FunctionSpace& functionspace) const;    gradOn(const FunctionSpace& functionspace) const;
658    
659      ESCRIPT_DLL_API
660    Data    Data
661    grad() const;    grad() const;
662    
663    /**    /**
664       \brief       \brief
665       Calculate the integral over the function space domain.       Calculate the integral over the function space domain.
666         *
667    */    */
668      ESCRIPT_DLL_API
669    boost::python::numeric::array    boost::python::numeric::array
670    integrate() const;    integrate() const;
671    
672    /**    /**
673       \brief       \brief
674       Return a Data with a 1 for +ive values and a 0 for 0 or -ive values.       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    Data
679    wherePositive() const;    wherePositive() const;
680    
681    /**    /**
682       \brief       \brief
683       Return a Data with a 1 for +ive values and a 0 for -ive values.       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    Data
697    whereNonNegative() const;    whereNonNegative() const;
698    
699    /**    /**
700       \brief       \brief
701       Return a Data with a 1 for -ive values and a 0 for +ive or 0 values.       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    Data
706    whereNegative() const;    whereNonPositive() const;
707    
708    /**    /**
709       \brief       \brief
710       Return a Data with a 1 for 0 values a 0 for +ive or -ive.       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    Data
715    whereZero() const;    whereZero(double tol=0.0) const;
716    
717    /**    /**
718       \brief       \brief
719       Return the sin of Data.       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      matrixtrace(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         Calculate the trace of each data point of this Data object.
875         *
876      */
877      ESCRIPT_DLL_API
878      Data
879      trace() 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    Data
888    sin() const;    sin() const;
889    
890    /**    /**
891       \brief       \brief
892       Return the cos of Data.       Return the cos of each data point of this Data object.
893         *
894    */    */
895      ESCRIPT_DLL_API
896    Data    Data
897    cos() const;    cos() const;
898    
899    /**    /**
900       \brief       \brief
901       Return the tan of Data.       Return the tan of each data point of this Data object.
902         *
903    */    */
904      ESCRIPT_DLL_API
905    Data    Data
906    tan() const;    tan() const;
907    
908    /**    /**
909       \brief       \brief
910       Return the log to base 10 of Data.       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    Data
1005    log() const;    log() const;
1006    
1007    /**    /**
1008       \brief       \brief
1009       Return the natural log of Data.       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    Data
1042    ln() const;    pos() const;
1043    
1044    /**    /**
1045       \brief       \brief
1046       Return a Data containing a slice of this Data.       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    Data
1208    getSlice(const DataArrayView::RegionType& region) const;    getSlice(const DataArrayView::RegionType& region) const;
1209    
1210    /**    /**
1211       \brief       \brief
1212       Copy the specified region from the given value.       Copy the specified slice from the given value into this
1213         Data object.
1214       \param value - Input - Data to copy from.       \param value - Input - Data to copy from.
1215       \param region - Input - Region to copy.       \param region - Input - Region to copy.
1216         *
1217    */    */
1218      ESCRIPT_DLL_API
1219    void    void
1220    setSlice(const Data& value,    setSlice(const Data& value,
1221             const DataArrayView::RegionType& region);             const DataArrayView::RegionType& region);
1222    
1223    /**    /**
1224       \brief       \brief
1225       Return the maximum absolute value.       Archive the current Data object to the given file.
1226         \param fileName - Input - file to archive to.
1227    */    */
1228    double    ESCRIPT_DLL_API
1229    Lsup() const;    void
1230      archiveData(const std::string fileName);
1231    
1232    /**    /**
1233       \brief       \brief
1234       Return the maximum value.       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    double    ESCRIPT_DLL_API
1241    sup() const;    void
1242      extractData(const std::string fileName,
1243                  const FunctionSpace& fspace);
1244    
1245    
1246    /**    /**
1247       \brief       \brief
1248       Return the minimum value.       print the data values to stdout. Used for debugging
1249    */    */
1250    double    ESCRIPT_DLL_API
1251    inf() const;    void
1252        print(void);
1253    
1254    /**    /**
1255       \brief       \brief
1256       Returns a slice from this.       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    Data    ESCRIPT_DLL_API
1261    getItem(const boost::python::object& key) const;      int
1262        get_MPIRank(void) const;
1263    
1264    /**    /**
1265       \brief       \brief
1266       Copies slice from value into this.       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    void    ESCRIPT_DLL_API
1271    setItem(const boost::python::object& key,      int
1272            const Data& value);      get_MPISize(void) const;
1273    
1274    /**    /**
1275       \brief       \brief
1276       Convert the underlying data type to match the RHS.       return the MPI rank number of the local data
1277       \param right - Input - data type to match.           MPI_COMM_WORLD is assumed and returned.
1278    */    */
1279      ESCRIPT_DLL_API
1280        MPI_Comm
1281        get_MPIComm(void) const;
1282        
1283     protected:
1284    
1285     private:
1286    
1287      /**
1288         \brief
1289         Check *this and the right operand are compatible. Throws
1290         an exception if they aren't.
1291         \param right - Input - The right hand side.
1292      */
1293      inline
1294    void    void
1295    typeMatch(const Data& right);    operandCheck(const Data& right) const
1296      {
1297        return m_data->operandCheck(*(right.m_data.get()));
1298      }
1299    
1300    /**    /**
1301       \brief       \brief
1302       Returns true if this can be interpolated to functionspace.       Perform the specified reduction algorithm on every element of every data point in
1303         this Data object according to the given function and return the single value result.
1304    */    */
1305    bool    template <class BinaryFunction>
1306    probeInterpolation(const FunctionSpace& functionspace) const;    inline
1307      double
1308      algorithm(BinaryFunction operation,
1309                double initial_value) const;
1310    
1311    /**    /**
1312       \brief       \brief
1313       Assign the given value to the tag. Implicitly converts this       Reduce each data-point in this Data object using the given operation. Return a Data
1314       object to type DataTagged. Throws an exception if this object       object with the same number of data-points, but with each data-point containing only
1315       cannot be converted to a DataTagged object.       one value - the result of the reduction operation on the corresponding data-point in
1316       \param tagKey - Input - Integer key.       this Data object
      \param value - Input - Value to associate with given key.  
1317    */    */
1318      template <class BinaryFunction>
1319      inline
1320      Data
1321      dp_algorithm(BinaryFunction operation,
1322                   double initial_value) const;
1323    
1324      /**
1325         \brief
1326         Perform the given binary operation on all of the data's elements.
1327         The underlying type of the right hand side (right) determines the final
1328         type of *this after the operation. For example if the right hand side
1329         is expanded *this will be expanded if necessary.
1330         RHS is a Data object.
1331      */
1332      template <class BinaryFunction>
1333      inline
1334    void    void
1335    setTaggedValue(int tagKey,    binaryOp(const Data& right,
1336                   const boost::python::object& value);             BinaryFunction operation);
1337    
1338    /**    /**
1339       \brief       \brief
1340       Assign the given value to the tag. Implicitly converts this       Perform the given binary operation on all of the data's elements.
1341       object to type DataTagged. Throws an exception if this object       RHS is a boost::python object.
      cannot be converted to a DataTagged object.  
      \param tagKey - Input - Integer key.  
      \param value - Input - Value to associate with given key.  
      Note: removed for now - this version not needed, and breaks escript.cpp  
1342    */    */
1343    /*    template <class BinaryFunction>
1344      inline
1345    void    void
1346    setTaggedValue(int tagKey,    binaryOp(const boost::python::object& right,
1347                   const DataArrayView& value);             BinaryFunction operation);
1348    
1349      /**
1350         \brief
1351         Convert the data type of the RHS to match this.
1352         \param right - Input - data type to match.
1353    */    */
1354      void
1355      typeMatchLeft(Data& right) const;
1356    
1357   private:    /**
1358         \brief
1359         Convert the data type of this to match the RHS.
1360         \param right - Input - data type to match.
1361      */
1362      void
1363      typeMatchRight(const Data& right);
1364    
1365    /**    /**
1366       \brief       \brief
# Line 712  class Data { Line 1383  class Data {
1383    reshapeDataPoint(const DataArrayView::ShapeType& shape);    reshapeDataPoint(const DataArrayView::ShapeType& shape);
1384    
1385    //    //
1386    // pointer to the actual data    // flag to protect the data object against any update
1387      bool m_protected;
1388    
1389      //
1390      // pointer to the actual data object
1391    boost::shared_ptr<DataAbstract> m_data;    boost::shared_ptr<DataAbstract> m_data;
1392    
1393      //
1394      // pointer to the internal profiling data
1395      struct profDataEntry *profData;
1396    
1397  };  };
1398    
1399  template <class IValueType>  template <class IValueType>
# Line 730  Data::initialise(const IValueType& value Line 1409  Data::initialise(const IValueType& value
1409    // within the shared_ptr constructor.    // within the shared_ptr constructor.
1410    if (expanded) {    if (expanded) {
1411      DataAbstract* temp=new DataExpanded(value,what);      DataAbstract* temp=new DataExpanded(value,what);
1412      m_data=boost::shared_ptr<DataAbstract>(temp);      boost::shared_ptr<DataAbstract> temp_data(temp);
1413        m_data=temp_data;
1414    } else {    } else {
1415      DataAbstract* temp=new DataConstant(value,what);      DataAbstract* temp=new DataConstant(value,what);
1416      m_data=boost::shared_ptr<DataAbstract>(temp);      boost::shared_ptr<DataAbstract> temp_data(temp);
1417        m_data=temp_data;
1418    }    }
1419  }  }
1420    
1421  inline  /**
1422  DataAbstract::ValueType::value_type*     Binary Data object operators.
1423  Data::getSampleData(DataAbstract::ValueType::size_type sampleNo)  */
 {  
   return m_data->getSampleData(sampleNo);  
 }  
   
 inline  
 DataAbstract::ValueType::value_type*  
 Data::getSampleDataByTag(int tag)  
 {  
   return m_data->getSampleDataByTag(tag);  
 }  
   
 inline  
 void  
 Data::operandCheck(const Data& right) const  
 {  
   return m_data->operandCheck(*(right.m_data.get()));  
 }  
   
 inline  
 int  
 Data::getNumSamples() const  
 {  
   return m_data->getNumSamples();  
 }  
   
 inline  
 std::string  
 Data::toString() const  
 {  
   return m_data->toString();  
 }  
1424    
1425  /**  /**
1426    \brief    \brief
1427    Operator+    Operator+
1428    Takes two Data objects.    Takes two Data objects.
1429  */  */
1430  Data operator+(const Data& left, const Data& right);  ESCRIPT_DLL_API Data operator+(const Data& left, const Data& right);
1431    
1432  /**  /**
1433    \brief    \brief
1434    Operator-    Operator-
1435    Takes two Data objects.    Takes two Data objects.
1436  */  */
1437  Data operator-(const Data& left, const Data& right);  ESCRIPT_DLL_API Data operator-(const Data& left, const Data& right);
1438    
1439  /**  /**
1440    \brief    \brief
1441    Operator*    Operator*
1442    Takes two Data objects.    Takes two Data objects.
1443  */  */
1444  Data operator*(const Data& left, const Data& right);  ESCRIPT_DLL_API Data operator*(const Data& left, const Data& right);
1445    
1446  /**  /**
1447    \brief    \brief
1448    Operator/    Operator/
1449    Takes two Data objects.    Takes two Data objects.
1450  */  */
1451  Data operator/(const Data& left, const Data& right);  ESCRIPT_DLL_API Data operator/(const Data& left, const Data& right);
1452    
1453  /**  /**
1454    \brief    \brief
# Line 806  Data operator/(const Data& left, const D Line 1456  Data operator/(const Data& left, const D
1456    Takes LHS Data object and RHS python::object.    Takes LHS Data object and RHS python::object.
1457    python::object must be convertable to Data type.    python::object must be convertable to Data type.
1458  */  */
1459  Data operator+(const Data& left, const boost::python::object& right);  ESCRIPT_DLL_API Data operator+(const Data& left, const boost::python::object& right);
1460    
1461  /**  /**
1462    \brief    \brief
# Line 814  Data operator+(const Data& left, const b Line 1464  Data operator+(const Data& left, const b
1464    Takes LHS Data object and RHS python::object.    Takes LHS Data object and RHS python::object.
1465    python::object must be convertable to Data type.    python::object must be convertable to Data type.
1466  */  */
1467  Data operator-(const Data& left, const boost::python::object& right);  ESCRIPT_DLL_API Data operator-(const Data& left, const boost::python::object& right);
1468    
1469  /**  /**
1470    \brief    \brief
# Line 822  Data operator-(const Data& left, const b Line 1472  Data operator-(const Data& left, const b
1472    Takes LHS Data object and RHS python::object.    Takes LHS Data object and RHS python::object.
1473    python::object must be convertable to Data type.    python::object must be convertable to Data type.
1474  */  */
1475  Data operator*(const Data& left, const boost::python::object& right);  ESCRIPT_DLL_API Data operator*(const Data& left, const boost::python::object& right);
1476    
1477  /**  /**
1478    \brief    \brief
# Line 830  Data operator*(const Data& left, const b Line 1480  Data operator*(const Data& left, const b
1480    Takes LHS Data object and RHS python::object.    Takes LHS Data object and RHS python::object.
1481    python::object must be convertable to Data type.    python::object must be convertable to Data type.
1482  */  */
1483  Data operator/(const Data& left, const boost::python::object& right);  ESCRIPT_DLL_API Data operator/(const Data& left, const boost::python::object& right);
1484    
1485  /**  /**
1486    \brief    \brief
# Line 838  Data operator/(const Data& left, const b Line 1488  Data operator/(const Data& left, const b
1488    Takes LHS python::object and RHS Data object.    Takes LHS python::object and RHS Data object.
1489    python::object must be convertable to Data type.    python::object must be convertable to Data type.
1490  */  */
1491  Data operator+(const boost::python::object& left, const Data& right);  ESCRIPT_DLL_API Data operator+(const boost::python::object& left, const Data& right);
1492    
1493  /**  /**
1494    \brief    \brief
# Line 846  Data operator+(const boost::python::obje Line 1496  Data operator+(const boost::python::obje
1496    Takes LHS python::object and RHS Data object.    Takes LHS python::object and RHS Data object.
1497    python::object must be convertable to Data type.    python::object must be convertable to Data type.
1498  */  */
1499  Data operator-(const boost::python::object& left, const Data& right);  ESCRIPT_DLL_API Data operator-(const boost::python::object& left, const Data& right);
1500    
1501  /**  /**
1502    \brief    \brief
# Line 854  Data operator-(const boost::python::obje Line 1504  Data operator-(const boost::python::obje
1504    Takes LHS python::object and RHS Data object.    Takes LHS python::object and RHS Data object.
1505    python::object must be convertable to Data type.    python::object must be convertable to Data type.
1506  */  */
1507  Data operator*(const boost::python::object& left, const Data& right);  ESCRIPT_DLL_API Data operator*(const boost::python::object& left, const Data& right);
1508    
1509  /**  /**
1510    \brief    \brief
# Line 862  Data operator*(const boost::python::obje Line 1512  Data operator*(const boost::python::obje
1512    Takes LHS python::object and RHS Data object.    Takes LHS python::object and RHS Data object.
1513    python::object must be convertable to Data type.    python::object must be convertable to Data type.
1514  */  */
1515  Data operator/(const boost::python::object& left, const Data& right);  ESCRIPT_DLL_API Data operator/(const boost::python::object& left, const Data& right);
1516    
1517  /**  /**
1518    \brief    \brief
1519    Output operator    Output operator
1520  */  */
1521  std::ostream& operator<<(std::ostream& o, const Data& data);  ESCRIPT_DLL_API std::ostream& operator<<(std::ostream& o, const Data& data);
1522    
1523  /**  /**
1524    \brief    \brief
# Line 876  std::ostream& operator<<(std::ostream& o Line 1526  std::ostream& operator<<(std::ostream& o
1526    NB: this operator does very little at this point, and isn't to    NB: this operator does very little at this point, and isn't to
1527    be relied on. Requires further implementation.    be relied on. Requires further implementation.
1528  */  */
1529  bool operator==(const Data& left, const Data& right);  //ESCRIPT_DLL_API bool operator==(const Data& left, const Data& right);
1530    
1531    /**
1532      \brief
1533      Perform the given binary operation with this and right as operands.
1534      Right is a Data object.
1535    */
1536  template <class BinaryFunction>  template <class BinaryFunction>
1537  inline  inline
1538  void  void
# Line 907  Data::binaryOp(const Data& right, Line 1562  Data::binaryOp(const Data& right,
1562     operandCheck(tempRight);     operandCheck(tempRight);
1563     //     //
1564     // ensure this has the right type for the RHS     // ensure this has the right type for the RHS
1565     typeMatch(tempRight);     typeMatchRight(tempRight);
1566     //     //
1567     // Need to cast to the concrete types so that the correct binaryOp     // Need to cast to the concrete types so that the correct binaryOp
1568     // is called.     // is called.
# Line 933  Data::binaryOp(const Data& right, Line 1588  Data::binaryOp(const Data& right,
1588         EsysAssert((rightC!=0), "Programming error - casting to DataConstant.");         EsysAssert((rightC!=0), "Programming error - casting to DataConstant.");
1589         escript::binaryOp(*leftC,*rightC,operation);         escript::binaryOp(*leftC,*rightC,operation);
1590       }       }
1591     } else {     } else if (isConstant()) {
      //  
      // can only be DataConstant  
1592       DataConstant* leftC=dynamic_cast<DataConstant*>(m_data.get());       DataConstant* leftC=dynamic_cast<DataConstant*>(m_data.get());
1593       DataConstant* rightC=dynamic_cast<DataConstant*>(tempRight.m_data.get());       DataConstant* rightC=dynamic_cast<DataConstant*>(tempRight.m_data.get());
1594       EsysAssert((leftC!=0 && rightC!=0), "Programming error - casting to DataConstant.");       EsysAssert((leftC!=0 && rightC!=0), "Programming error - casting to DataConstant.");
# Line 943  Data::binaryOp(const Data& right, Line 1596  Data::binaryOp(const Data& right,
1596     }     }
1597  }  }
1598    
1599    /**
1600      \brief
1601      Perform the given binary operation with this and right as operands.
1602      Right is a boost::python object.
1603    */
1604  template <class BinaryFunction>  template <class BinaryFunction>
1605  inline  inline
1606  void  void
# Line 963  Data::binaryOp(const boost::python::obje Line 1621  Data::binaryOp(const boost::python::obje
1621                    "Error - RHS shape doesn't match LHS shape.",temp.getView().getShape()));                    "Error - RHS shape doesn't match LHS shape.",temp.getView().getShape()));
1622       }       }
1623     }     }
   
1624     if (isExpanded()) {     if (isExpanded()) {
      //  
      // Expanded data will be done in parallel  
1625       DataExpanded* leftC=dynamic_cast<DataExpanded*>(m_data.get());       DataExpanded* leftC=dynamic_cast<DataExpanded*>(m_data.get());
1626       EsysAssert((leftC!=0),"Programming error - casting to DataExpanded.");       EsysAssert((leftC!=0),"Programming error - casting to DataExpanded.");
1627       escript::binaryOp(*leftC,temp.getView(),operation);       escript::binaryOp(*leftC,temp.getView(),operation);
# Line 974  Data::binaryOp(const boost::python::obje Line 1629  Data::binaryOp(const boost::python::obje
1629       DataTagged* leftC=dynamic_cast<DataTagged*>(m_data.get());       DataTagged* leftC=dynamic_cast<DataTagged*>(m_data.get());
1630       EsysAssert((leftC!=0), "Programming error - casting to DataTagged.");       EsysAssert((leftC!=0), "Programming error - casting to DataTagged.");
1631       escript::binaryOp(*leftC,temp.getView(),operation);       escript::binaryOp(*leftC,temp.getView(),operation);
1632     } else {     } else if (isConstant()) {
      //  
      // can only be DataConstant  
1633       DataConstant* leftC=dynamic_cast<DataConstant*>(m_data.get());       DataConstant* leftC=dynamic_cast<DataConstant*>(m_data.get());
1634       EsysAssert((leftC!=0),"Programming error - casting to DataConstant.");       EsysAssert((leftC!=0),"Programming error - casting to DataConstant.");
1635       escript::binaryOp(*leftC,temp.getView(),operation);       escript::binaryOp(*leftC,temp.getView(),operation);
1636     }     }
1637  }  }
1638    
1639    /**
1640      \brief
1641      Perform the given unary operation on other and return the result.
1642      Given operation is performed on each element of each data point, thus
1643      argument object is a rank n Data object, and returned object is a rank n
1644      Data object.
1645      Calls Data::unaryOp.
1646    */
1647    template <class UnaryFunction>
1648    inline
1649    Data
1650    unaryOp(const Data& other,
1651            UnaryFunction operation)
1652    {
1653      Data result;
1654      result.copy(other);
1655      result.unaryOp(operation);
1656      return result;
1657    }
1658    
1659    /**
1660      \brief
1661      Perform the given unary operation on this.
1662      Given operation is performed on each element of each data point.
1663      Calls escript::unaryOp.
1664    */
1665  template <class UnaryFunction>  template <class UnaryFunction>
1666  inline  inline
1667  void  void
1668  Data::unaryOp(UnaryFunction operation)  Data::unaryOp(UnaryFunction operation)
1669  {  {
1670    if (isExpanded()) {    if (isExpanded()) {
     //  
     // Expanded data will be done in parallel  
1671      DataExpanded* leftC=dynamic_cast<DataExpanded*>(m_data.get());      DataExpanded* leftC=dynamic_cast<DataExpanded*>(m_data.get());
1672      EsysAssert((leftC!=0), "Programming error - casting to DataExpanded.");      EsysAssert((leftC!=0), "Programming error - casting to DataExpanded.");
1673      escript::unaryOp(*leftC,operation);      escript::unaryOp(*leftC,operation);
# Line 998  Data::unaryOp(UnaryFunction operation) Line 1675  Data::unaryOp(UnaryFunction operation)
1675      DataTagged* leftC=dynamic_cast<DataTagged*>(m_data.get());      DataTagged* leftC=dynamic_cast<DataTagged*>(m_data.get());
1676      EsysAssert((leftC!=0), "Programming error - casting to DataTagged.");      EsysAssert((leftC!=0), "Programming error - casting to DataTagged.");
1677      escript::unaryOp(*leftC,operation);      escript::unaryOp(*leftC,operation);
1678    } else {    } else if (isConstant()) {
1679      DataConstant* leftC=dynamic_cast<DataConstant*>(m_data.get());      DataConstant* leftC=dynamic_cast<DataConstant*>(m_data.get());
1680      EsysAssert((leftC!=0), "Programming error - casting to DataConstant.");      EsysAssert((leftC!=0), "Programming error - casting to DataConstant.");
1681      escript::unaryOp(*leftC,operation);      escript::unaryOp(*leftC,operation);
1682    }    }
1683  }  }
1684    
1685  template <class UnaryFunction>  /**
1686      \brief
1687      Perform the given Data object reduction algorithm on this and return the result.
1688      Given operation combines each element of each data point, thus argument
1689      object (*this) is a rank n Data object, and returned object is a scalar.
1690      Calls escript::algorithm.
1691    */
1692    template <class BinaryFunction>
1693  inline  inline
1694  double  double
1695  Data::algorithm(UnaryFunction operation) const  Data::algorithm(BinaryFunction operation, double initial_value) const
1696  {  {
1697    if (isExpanded()) {    if (isExpanded()) {
     //  
     // Expanded data will be done in parallel  
1698      DataExpanded* leftC=dynamic_cast<DataExpanded*>(m_data.get());      DataExpanded* leftC=dynamic_cast<DataExpanded*>(m_data.get());
1699      EsysAssert((leftC!=0), "Programming error - casting to DataExpanded.");      EsysAssert((leftC!=0), "Programming error - casting to DataExpanded.");
1700      return escript::algorithm(*leftC,operation);      return escript::algorithm(*leftC,operation,initial_value);
1701    }    } else if (isTagged()) {
   else if (isTagged()) {  
1702      DataTagged* leftC=dynamic_cast<DataTagged*>(m_data.get());      DataTagged* leftC=dynamic_cast<DataTagged*>(m_data.get());
1703      EsysAssert((leftC!=0), "Programming error - casting to DataTagged.");      EsysAssert((leftC!=0), "Programming error - casting to DataTagged.");
1704      return escript::algorithm(*leftC,operation);      return escript::algorithm(*leftC,operation,initial_value);
1705    } else {    } else if (isConstant()) {
1706      DataConstant* leftC=dynamic_cast<DataConstant*>(m_data.get());      DataConstant* leftC=dynamic_cast<DataConstant*>(m_data.get());
1707      EsysAssert((leftC!=0), "Programming error - casting to DataConstant.");      EsysAssert((leftC!=0), "Programming error - casting to DataConstant.");
1708      return escript::algorithm(*leftC,operation);      return escript::algorithm(*leftC,operation,initial_value);
1709    }    }
1710      return 0;
1711  }  }
1712    
1713  template <class UnaryFunction>  /**
1714      \brief
1715      Perform the given data point reduction algorithm on data and return the result.
1716      Given operation combines each element within each data point into a scalar,
1717      thus argument object is a rank n Data object, and returned object is a
1718      rank 0 Data object.
1719      Calls escript::dp_algorithm.
1720    */
1721    template <class BinaryFunction>
1722  inline  inline
1723  Data  Data
1724  unaryOp(const Data& other,  Data::dp_algorithm(BinaryFunction operation, double initial_value) const
         UnaryFunction operation)  
1725  {  {
1726    //    if (isExpanded()) {
1727    // Perform the given operation on a copy of the input data and return the result      Data result(0,DataArrayView::ShapeType(),getFunctionSpace(),isExpanded());
1728    Data result;      DataExpanded* dataE=dynamic_cast<DataExpanded*>(m_data.get());
1729    //      DataExpanded* resultE=dynamic_cast<DataExpanded*>(result.m_data.get());
1730    // perform a deep copy      EsysAssert((dataE!=0), "Programming error - casting data to DataExpanded.");
1731    result.copy(other);      EsysAssert((resultE!=0), "Programming error - casting result to DataExpanded.");
1732    result.unaryOp(operation);      escript::dp_algorithm(*dataE,*resultE,operation,initial_value);
1733    return result;      return result;
1734      } else if (isTagged()) {
1735        DataTagged* dataT=dynamic_cast<DataTagged*>(m_data.get());
1736        DataArrayView::ShapeType viewShape;
1737        DataArrayView::ValueType viewData(1);
1738        viewData[0]=0;
1739        DataArrayView defaultValue(viewData,viewShape);
1740        DataTagged::TagListType keys;
1741        DataTagged::ValueListType values;
1742        DataTagged::DataMapType::const_iterator i;
1743        for (i=dataT->getTagLookup().begin();i!=dataT->getTagLookup().end();i++) {
1744          keys.push_back(i->first);
1745          values.push_back(defaultValue);
1746        }
1747        Data result(keys,values,defaultValue,getFunctionSpace());
1748        DataTagged* resultT=dynamic_cast<DataTagged*>(result.m_data.get());
1749        EsysAssert((dataT!=0), "Programming error - casting data to DataTagged.");
1750        EsysAssert((resultT!=0), "Programming error - casting result to DataTagged.");
1751        escript::dp_algorithm(*dataT,*resultT,operation,initial_value);
1752        return result;
1753      } else if (isConstant()) {
1754        Data result(0,DataArrayView::ShapeType(),getFunctionSpace(),isExpanded());
1755        DataConstant* dataC=dynamic_cast<DataConstant*>(m_data.get());
1756        DataConstant* resultC=dynamic_cast<DataConstant*>(result.m_data.get());
1757        EsysAssert((dataC!=0), "Programming error - casting data to DataConstant.");
1758        EsysAssert((resultC!=0), "Programming error - casting result to DataConstant.");
1759        escript::dp_algorithm(*dataC,*resultC,operation,initial_value);
1760        return result;
1761      }
1762      Data falseRetVal; // to keep compiler quiet
1763      return falseRetVal;
1764  }  }
1765    
1766  }  }
   
1767  #endif  #endif

Legend:
Removed from v.94  
changed lines
  Added in v.790

  ViewVC Help
Powered by ViewVC 1.1.26