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

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

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

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

Legend:
Removed from v.100  
changed lines
  Added in v.782

  ViewVC Help
Powered by ViewVC 1.1.26