/[escript]/trunk/escript/src/DataTagged.cpp
ViewVC logotype

Diff of /trunk/escript/src/DataTagged.cpp

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

trunk/esys2/escript/src/Data/DataTagged.cpp revision 100 by jgs, Wed Dec 15 03:48:48 2004 UTC trunk/escript/src/DataTagged.cpp revision 854 by gross, Thu Sep 21 05:29:42 2006 UTC
# Line 1  Line 1 
1  // $Id$  // $Id$
2    
3  /*  /*
4   ******************************************************************************   ************************************************************
5   *                                                                            *   *          Copyright 2006 by ACcESS MNRF                   *
6   *       COPYRIGHT  ACcESS 2004 -  All Rights Reserved                        *   *                                                          *
7   *                                                                            *   *              http://www.access.edu.au                    *
8   * This software is the property of ACcESS. No part of this code              *   *       Primary Business: Queensland, Australia            *
9   * may be copied in any form or by any means without the expressed written    *   *  Licensed under the Open Software License version 3.0    *
10   * consent of ACcESS.  Copying, use or modification of this software          *   *     http://www.opensource.org/licenses/osl-3.0.php       *
11   * by any unauthorised person is illegal unless that person has a software    *   *                                                          *
12   * license agreement with ACcESS.                                             *   ************************************************************
  *                                                                            *  
  ******************************************************************************  
13  */  */
14    
15  #include "escript/Data/DataTagged.h"  #include "DataTagged.h"
 #include "escript/Data/DataConstant.h"  
16    
17  #include <sstream>  #include "DataConstant.h"
18    #include "DataException.h"
19    
20  using namespace std;  using namespace std;
21    
22  namespace escript {  namespace escript {
23    
24  DataTagged::DataTagged():  DataTagged::DataTagged()
25    DataAbstract(FunctionSpace())    : DataAbstract(FunctionSpace())
26  {  {
27    //    // default constructor
28    
29    // create a scalar default value    // create a scalar default value
30    m_data.push_back(0.0);    m_data.resize(1,0.,1);
31    DataArrayView temp(m_data,DataArrayView::ShapeType());    DataArrayView temp(m_data,DataArrayView::ShapeType());
32    setPointDataView(temp);    setPointDataView(temp);
33  }  }
# Line 35  DataTagged::DataTagged(): Line 35  DataTagged::DataTagged():
35  DataTagged::DataTagged(const TagListType& tagKeys,  DataTagged::DataTagged(const TagListType& tagKeys,
36                 const ValueListType& values,                 const ValueListType& values,
37                 const DataArrayView& defaultValue,                 const DataArrayView& defaultValue,
38                 const FunctionSpace& what):                 const FunctionSpace& what)
39    DataAbstract(what)    : DataAbstract(what)
40  {  {
41    //    // constructor
42    // The default value is always the first item in the values list  
43    m_data.insert(m_data.end(), &defaultValue.getData(0), &defaultValue.getData(defaultValue.noValues()) );    // initialise the array of data values
44      // the default value is always the first item in the values list
45      int len = defaultValue.noValues();
46      m_data.resize(len,0.,len);
47      for (int i=0; i<defaultValue.noValues(); i++) {
48        m_data[i]=defaultValue.getData(i);
49      }
50    
51      // create the data view
52    DataArrayView temp(m_data,defaultValue.getShape());    DataArrayView temp(m_data,defaultValue.getShape());
53    setPointDataView(temp);    setPointDataView(temp);
54    
55    // add remaining tags and values    // add remaining tags and values
56    addTaggedValues(tagKeys,values);    addTaggedValues(tagKeys,values);
57  }  }
58    
59  DataTagged::DataTagged(const DataTagged& other):  DataTagged::DataTagged(const FunctionSpace& what,
60    DataAbstract(other.getFunctionSpace()),                         const DataArrayView::ShapeType &shape,
61                           const int tags[],
62                           const ValueType& data)
63      : DataAbstract(what)
64    {
65      // alternative constructor
66      // not unit_tested tested yet
67    
68      // copy the data
69      m_data=data;
70    
71      // create the view of the data
72      DataArrayView tempView(m_data,shape);
73      setPointDataView(tempView);
74    
75      // create the tag lookup map
76      for (int sampleNo=0; sampleNo<getNumSamples(); sampleNo++) {
77        m_offsetLookup.insert(DataMapType::value_type(sampleNo,tags[sampleNo]));
78      }
79    }
80    
81    DataTagged::DataTagged(const FunctionSpace& what,
82                           const DataArrayView::ShapeType &shape,
83                           const TagListType& tags,
84                           const ValueType& data)
85      : DataAbstract(what)
86    {
87      // alternative constructor
88      // not unit_tested tested yet
89    
90      // copy the data
91      m_data=data;
92    
93      // create the view of the data
94      DataArrayView tempView(m_data,shape);
95      setPointDataView(tempView);
96    
97      // create the tag lookup map
98      for (int sampleNo=0; sampleNo<getNumSamples(); sampleNo++) {
99        m_offsetLookup.insert(DataMapType::value_type(sampleNo,tags[sampleNo]));
100      }
101    }
102    
103    
104    DataTagged::DataTagged(const DataTagged& other)
105      : DataAbstract(other.getFunctionSpace()),
106    m_data(other.m_data),    m_data(other.m_data),
107    m_offsetLookup(other.m_offsetLookup)    m_offsetLookup(other.m_offsetLookup)
108  {  {
109      // copy constructor
110    
111      // create the data view
112    DataArrayView temp(m_data,other.getPointDataView().getShape());    DataArrayView temp(m_data,other.getPointDataView().getShape());
113    setPointDataView(temp);    setPointDataView(temp);
114  }  }
115    
116  DataTagged::DataTagged(const DataConstant& other):  DataTagged::DataTagged(const DataConstant& other)
117    DataAbstract(other.getFunctionSpace())    : DataAbstract(other.getFunctionSpace())
118  {  {
119    //    // copy constructor
120    // Fill the default value with the constant value item from other  
121      // fill the default value with the constant value item from "other"
122    const DataArrayView& value=other.getPointDataView();    const DataArrayView& value=other.getPointDataView();
123    m_data.insert(m_data.end(), &value.getData(0), &value.getData(value.noValues()) );    int len = value.noValues();
124      m_data.resize(len,0.,len);
125      for (int i=0; i<value.noValues(); i++) {
126        m_data[i]=value.getData(i);
127      }
128    
129      // create the data view
130    DataArrayView temp(m_data,value.getShape());    DataArrayView temp(m_data,value.getShape());
131    setPointDataView(temp);    setPointDataView(temp);
132  }  }
133    
134    DataAbstract*
135    DataTagged::getSlice(const DataArrayView::RegionType& region) const
136    {
137      return new DataTagged(*this, region);
138    }
139    
140  DataTagged::DataTagged(const DataTagged& other,  DataTagged::DataTagged(const DataTagged& other,
141                 const DataArrayView::RegionType& region):                 const DataArrayView::RegionType& region)
142    DataAbstract(other.getFunctionSpace())    : DataAbstract(other.getFunctionSpace())
143  {  {
144    //    // slice constructor
145    
146    // get the shape of the slice to copy from other    // get the shape of the slice to copy from other
147    DataArrayView::ShapeType shape(DataArrayView::getResultSliceShape(region));    DataArrayView::ShapeType regionShape(DataArrayView::getResultSliceShape(region));
148    //    DataArrayView::RegionLoopRangeType regionLoopRange=getSliceRegionLoopRange(region);
149    // allocate enough space for all values  
150    m_data.resize(DataArrayView::noValues(shape)*(other.m_offsetLookup.size()+1));    // allocate enough space in this for all values
151    DataArrayView temp(m_data,shape);    // (need to add one to allow for the default value)
152      int len = DataArrayView::noValues(regionShape)*(other.m_offsetLookup.size()+1);
153      m_data.resize(len,0.0,len);
154    
155      // create the data view
156      DataArrayView temp(m_data,regionShape);
157    setPointDataView(temp);    setPointDataView(temp);
158    getDefaultValue().copySlice(other.getDefaultValue(),region);  
159    //    // copy the default value from other to this
160    // Loop through the tag values    getDefaultValue().copySlice(other.getDefaultValue(), regionLoopRange);
161    
162      // loop through the tag values copying these
163    DataMapType::const_iterator pos;    DataMapType::const_iterator pos;
164    DataArrayView::ValueType::size_type tagOffset=getPointDataView().noValues();    DataArrayView::ValueType::size_type tagOffset=getPointDataView().noValues();
165    for (pos=other.m_offsetLookup.begin();pos!=other.m_offsetLookup.end();++pos){    for (pos=other.m_offsetLookup.begin();pos!=other.m_offsetLookup.end();pos++){
166      getPointDataView().copySlice(tagOffset,other.getPointDataView(), pos->second,region);      getPointDataView().copySlice(tagOffset,other.getPointDataView(),pos->second,regionLoopRange);
167      m_offsetLookup.insert(DataMapType::value_type(pos->first,tagOffset));      m_offsetLookup.insert(DataMapType::value_type(pos->first,tagOffset));
168      tagOffset+=getPointDataView().noValues();      tagOffset+=getPointDataView().noValues();
   }  
 }  
   
 void  
 DataTagged::reshapeDataPoint(const DataArrayView::ShapeType& shape)  
 {  
   //  
   // can only reshape a rank zero data point  
   if (getPointDataView().getRank()!=0) {  
     stringstream temp;  
     temp << "Error - Can only reshape Data with data points of rank 0. "  
      << "This Data has data points with rank: "  
      << getPointDataView().getRank();  
     throw DataException(temp.str());  
   }  
   //  
   // allocate enough space for all values  
   DataArrayView::ValueType newData(DataArrayView::noValues(shape)*(m_offsetLookup.size()+1));  
   DataArrayView newView(newData,shape);  
   newView.copy(0,getDefaultValue()());  
   //  
   // Loop through the tag values  
   DataMapType::iterator pos;  
   DataArrayView::ValueType::size_type tagOffset=DataArrayView::noValues(shape);  
   for (pos=m_offsetLookup.begin();pos!=m_offsetLookup.end();++pos){  
     newView.copy(tagOffset,m_data[pos->second]);  
     pos->second=tagOffset;  
     tagOffset+=DataArrayView::noValues(shape);  
169    }    }
   m_data=newData;  
   DataArrayView temp(m_data,shape);  
   setPointDataView(temp);  
 }  
   
 DataAbstract*  
 DataTagged::getSlice(const DataArrayView::RegionType& region) const  
 {  
   return new DataTagged(*this,region);  
170  }  }
171    
172  void  void
173  DataTagged::setSlice(const DataAbstract* value,  DataTagged::setSlice(const DataAbstract* other,
174                       const DataArrayView::RegionType& region)                       const DataArrayView::RegionType& region)
175  {  {
176    const DataTagged* tempDataTag=dynamic_cast<const DataTagged*>(value);  
177    if (tempDataTag==0) {    // other must be another DataTagged object
178      // Data:setSlice implementation should ensure this
179      const DataTagged* otherTemp=dynamic_cast<const DataTagged*>(other);
180      if (otherTemp==0) {
181      throw DataException("Programming error - casting to DataTagged.");      throw DataException("Programming error - casting to DataTagged.");
182    }    }
183    
184      // determine shape of the specified region
185      DataArrayView::ShapeType regionShape(DataArrayView::getResultSliceShape(region));
186    
187      // modify region specification as needed to match rank of this object
188      DataArrayView::RegionLoopRangeType regionLoopRange=getSliceRegionLoopRange(region);
189    
190      // ensure rank/shape of this object is compatible with specified region
191    if (getPointDataView().getRank()!=region.size()) {    if (getPointDataView().getRank()!=region.size()) {
192      throw DataException("Error - Invalid slice region.");      throw DataException("Error - Invalid slice region.");
193    }    }
194    //    if (otherTemp->getPointDataView().getRank()>0 && !other->getPointDataView().checkShape(regionShape)) {
195    // get the shape of the slice      throw DataException (other->getPointDataView().createShapeErrorMessage(
196    DataArrayView::ShapeType shape(DataArrayView::getResultSliceShape(region));                           "Error - Couldn't copy slice due to shape mismatch.",regionShape));
   if (!value->getPointDataView().checkShape(shape)) {  
     throw DataException (value->getPointDataView().createShapeErrorMessage(  
                 "Error - Couldn't copy slice due to shape mismatch.",shape));  
197    }    }
198    getDefaultValue().copySliceFrom(tempDataTag->getDefaultValue(),region);  
199    //    // copy slice from other default value to this default value
200    // Loop through the tag values    getDefaultValue().copySliceFrom(otherTemp->getDefaultValue(), regionLoopRange);
201    
202      // loop through tag values in other, adding any which aren't in this, using default value
203    DataMapType::const_iterator pos;    DataMapType::const_iterator pos;
204    for (pos=m_offsetLookup.begin();pos!=m_offsetLookup.end();++pos){    for (pos=otherTemp->m_offsetLookup.begin();pos!=otherTemp->m_offsetLookup.end();pos++) {
205      getDataPointByTag(pos->first).copySliceFrom(tempDataTag->getDataPointByTag(pos->first),region);      if (!isCurrentTag(pos->first)) {
206    }        addTaggedValue(pos->first,getDefaultValue());
207        }
208      }
209    
210      // loop through the tag values copying slices from other to this
211      for (pos=m_offsetLookup.begin();pos!=m_offsetLookup.end();pos++) {
212        getDataPointByTag(pos->first).copySliceFrom(otherTemp->getDataPointByTag(pos->first), regionLoopRange);
213      }
214    
215  }  }
216    
217  void  int
218  DataTagged::setTaggedValue(int tagKey,  DataTagged::getTagNumber(int dpno)
                            const DataArrayView& value)  
219  {  {
220    DataMapType::iterator pos(m_offsetLookup.find(tagKey));    //
221    if (pos==m_offsetLookup.end()) {    // Get the number of samples and data-points per sample
222      //    int numSamples = getNumSamples();
223      // tag couldn't be found so add as a new tag    int numDataPointsPerSample = getNumDPPSample();
224      addTaggedValue(tagKey,value);    int numDataPoints = numSamples * numDataPointsPerSample;
225    } else {  
226      if (!getPointDataView().checkShape(value.getShape())) {    if (numDataPointsPerSample==0) {
227        throw DataException(getPointDataView().createShapeErrorMessage(      throw DataException("DataTagged::getTagNumber error: no data-points associated with this object.");
          "Error - Cannot setTaggedValue due to shape mismatch.", value.getShape()));  
     }  
     //  
     // copy the values into tagged data storage  
     copy(&value.getData(0), &value.getData(getPointDataView().noValues()), &m_data[pos->second]);  
228    }    }
229    
230      if (dpno<0 || dpno>numDataPoints-1) {
231        throw DataException("DataTagged::getTagNumber error: invalid data-point number supplied.");
232      }
233    
234      //
235      // Determine the sample number which corresponds to this data-point number
236      int sampleNo = dpno / numDataPointsPerSample;
237    
238      //
239      // Determine the tag number which corresponds to this sample number
240      int tagNo = getFunctionSpace().getTagFromSampleNo(sampleNo);
241    
242      //
243      // return the tag number
244      return(tagNo);
245  }  }
246    
247  void  void
248  DataTagged::setTaggedValues(const TagListType& tagKeys,  DataTagged::setTaggedValues(const TagListType& tagKeys,
249                              const ValueListType& values)                              const ValueListType& values)
250  {  {
251    for (int i=0;i<tagKeys.size();++i) {    addTaggedValues(tagKeys,values);
     setTaggedValue(tagKeys[i],values[i]);  
   }  
252  }  }
253    
254  void  void
255  DataTagged::addTaggedValue(int tagKey,  DataTagged::setTaggedValue(int tagKey,
256                             const DataArrayView& value)                             const DataArrayView& value)
257  {  {
258    if (!getPointDataView().checkShape(value.getShape())) {    if (!getPointDataView().checkShape(value.getShape())) {
259      throw DataException(getPointDataView().createShapeErrorMessage(        throw DataException(getPointDataView().createShapeErrorMessage(
260           "Error - Cannot addTaggedValue due to shape mismatch.", value.getShape()));                            "Error - Cannot setTaggedValue due to shape mismatch.", value.getShape()));
261      }
262      DataMapType::iterator pos(m_offsetLookup.find(tagKey));
263      if (pos==m_offsetLookup.end()) {
264        // tag couldn't be found so use addTaggedValue
265        addTaggedValue(tagKey,value);
266      } else {
267        // copy the values into the data array at the offset determined by m_offsetLookup
268        int offset=pos->second;
269        for (int i=0; i<getPointDataView().noValues(); i++) {
270          m_data[offset+i]=value.getData(i);
271        }
272    }    }
   //  
   // save the key and the location of its data  
   m_offsetLookup.insert( DataMapType::value_type(tagKey,m_data.size()) );  
   //  
   // insert the data given in value at the end of m_data  
   m_data.insert( m_data.end(), &(value.getData(0)), &(value.getData(value.noValues())) );  
273  }  }
274    
275  void  void
# Line 205  DataTagged::addTaggedValues(const TagLis Line 277  DataTagged::addTaggedValues(const TagLis
277                              const ValueListType& values)                              const ValueListType& values)
278  {  {
279    if (values.size()==0) {    if (values.size()==0) {
280      //      // copy the current default value for each of the tags
     // Copy the default value for each of the tags  
281      TagListType::const_iterator iT;      TagListType::const_iterator iT;
282      for (iT=tagKeys.begin();iT!=tagKeys.end();++iT) {      for (iT=tagKeys.begin();iT!=tagKeys.end();iT++) {
       //  
283        // the point data view for DataTagged points at the default value        // the point data view for DataTagged points at the default value
284        addTaggedValue(*iT,getPointDataView());        addTaggedValue(*iT,getPointDataView());
285      }      }
286    } else if (values.size()==1 && tagKeys.size()>1) {    } else if (values.size()==1 && tagKeys.size()>1) {
287      //      // assume the one given value will be used for all tag values
     // assume the one value will be used for all tag values  
     // Copy the input data  
288      TagListType::const_iterator iT;      TagListType::const_iterator iT;
289      for (iT=tagKeys.begin();iT!=tagKeys.end();++iT) {      for (iT=tagKeys.begin();iT!=tagKeys.end();iT++) {
290        addTaggedValue(*iT,values[0]);        addTaggedValue(*iT,values[0]);
291      }      }
292    } else {    } else {
293      if (tagKeys.size()!=values.size()) {      if (tagKeys.size()!=values.size()) {
294        stringstream temp;        stringstream temp;
295        temp << "Error - (addTaggedValue) Number of tags: " << tagKeys.size()        temp << "Error - (addTaggedValue) Number of tags: " << tagKeys.size()
296         << " doesn't match the number of values: " << values.size();         << " doesn't match number of values: " << values.size();
297        throw DataException(temp.str());        throw DataException(temp.str());
298      } else {      } else {
299        for (int i=0;i<tagKeys.size();++i) {        for (int i=0;i<tagKeys.size();i++) {
300          addTaggedValue(tagKeys[i],values[i]);          addTaggedValue(tagKeys[i],values[i]);
301        }        }
302      }      }
303    }    }
304  }  }
305    
306    void
307    DataTagged::addTaggedValue(int tagKey,
308                               const DataArrayView& value)
309    {
310      if (!getPointDataView().checkShape(value.getShape())) {
311        throw DataException(getPointDataView().createShapeErrorMessage(
312                            "Error - Cannot addTaggedValue due to shape mismatch.", value.getShape()));
313      }
314      DataMapType::iterator pos(m_offsetLookup.find(tagKey));
315      if (pos!=m_offsetLookup.end()) {
316        // tag already exists so use setTaggedValue
317        setTaggedValue(tagKey,value);
318      } else {
319        // save the key and the location of its data in the lookup tab
320        m_offsetLookup.insert(DataMapType::value_type(tagKey,m_data.size()));
321        // add the data given in "value" at the end of m_data
322        // need to make a temp copy of m_data, resize m_data, then copy
323        // all the old values plus the value to be added back into m_data
324        ValueType m_data_temp(m_data);
325        int oldSize=m_data.size();
326        int newSize=m_data.size()+value.noValues();
327        m_data.resize(newSize,0.,newSize);
328        for (int i=0;i<oldSize;i++) {
329          m_data[i]=m_data_temp[i];
330        }
331        for (int i=0;i<value.noValues();i++) {
332          m_data[oldSize+i]=value.getData(i);
333        }
334      }
335    }
336    
337  double*  double*
338  DataTagged::getSampleDataByTag(int tag)  DataTagged::getSampleDataByTag(int tag)
339  {  {
340    DataMapType::iterator pos(m_offsetLookup.find(tag));    DataMapType::iterator pos(m_offsetLookup.find(tag));
341    if (pos==m_offsetLookup.end()) {    if (pos==m_offsetLookup.end()) {
     //  
342      // tag couldn't be found so return the default value      // tag couldn't be found so return the default value
343      return &(m_data[0]);      return &(m_data[0]);
344    } else {    } else {
     //  
345      // return the data-point corresponding to the given tag      // return the data-point corresponding to the given tag
346      return &(m_data[pos->second]);      return &(m_data[pos->second]);
347    }    }
# Line 257  DataTagged::toString() const Line 354  DataTagged::toString() const
354    DataMapType::const_iterator i;    DataMapType::const_iterator i;
355    temp << "Tag(Default)" << endl;    temp << "Tag(Default)" << endl;
356    temp << getDefaultValue().toString() << endl;    temp << getDefaultValue().toString() << endl;
   //  
357    // create a temporary view as the offset will be changed    // create a temporary view as the offset will be changed
358    DataArrayView tempView(getPointDataView().getData(), getPointDataView().getShape());    DataArrayView tempView(getPointDataView().getData(), getPointDataView().getShape());
359    for (i=m_offsetLookup.begin();i!=m_offsetLookup.end();++i) {    for (i=m_offsetLookup.begin();i!=m_offsetLookup.end();++i) {
# Line 268  DataTagged::toString() const Line 364  DataTagged::toString() const
364    return temp.str();    return temp.str();
365  }  }
366    
367  DataArrayView  DataArrayView::ValueType::size_type
368  DataTagged::getDataPointByTag(int tag) const  DataTagged::getPointOffset(int sampleNo,
369                               int dataPointNo) const
370  {  {
371    DataMapType::const_iterator pos(m_offsetLookup.find(tag));    int tagKey=getFunctionSpace().getTagFromSampleNo(sampleNo);
372      DataMapType::const_iterator pos(m_offsetLookup.find(tagKey));
373    DataArrayView::ValueType::size_type offset=m_defaultValueOffset;    DataArrayView::ValueType::size_type offset=m_defaultValueOffset;
374    if (pos!=m_offsetLookup.end()) {    if (pos!=m_offsetLookup.end()) {
375      offset=pos->second;      offset=pos->second;
376    }    }
377    DataArrayView temp(getPointDataView());    return offset;
   temp.setOffset(offset);  
   return temp;  
378  }  }
379    
380  DataArrayView::ValueType::size_type  DataArrayView
381  DataTagged::getPointOffset(int sampleNo,  DataTagged::getDataPointByTag(int tag) const
                            int dataPointNo) const  
382  {  {
383    int tagKey=getFunctionSpace().getTagFromSampleNo(sampleNo);    DataMapType::const_iterator pos(m_offsetLookup.find(tag));
   DataMapType::const_iterator pos(m_offsetLookup.find(tagKey));  
384    DataArrayView::ValueType::size_type offset=m_defaultValueOffset;    DataArrayView::ValueType::size_type offset=m_defaultValueOffset;
385    if (pos!=m_offsetLookup.end()) {    if (pos!=m_offsetLookup.end()) {
386      offset=pos->second;      offset=pos->second;
387    }    }
388    return offset;    DataArrayView temp(getPointDataView());
389      temp.setOffset(offset);
390      return temp;
391  }  }
392    
393  DataArrayView  DataArrayView
# Line 303  DataTagged::getDataPoint(int sampleNo, Line 399  DataTagged::getDataPoint(int sampleNo,
399    return getDataPointByTag(tagKey);    return getDataPointByTag(tagKey);
400  }  }
401    
402  const DataTagged::DataMapType&  int
403  DataTagged::getTagLookup() const  DataTagged::archiveData(ofstream& archiveFile,
404                            const DataArrayView::ValueType::size_type noValues) const
405  {  {
406    return m_offsetLookup;    return(m_data.archiveData(archiveFile, noValues));
407  }  }
408    
409  DataArrayView::ValueType::size_type  int
410  DataTagged::getLength() const  DataTagged::extractData(ifstream& archiveFile,
411                            const DataArrayView::ValueType::size_type noValues)
412    {
413      return(m_data.extractData(archiveFile, noValues));
414    }
415    void
416    DataTagged::symmetric(DataAbstract* ev)
417    {
418      DataTagged* temp_ev=dynamic_cast<DataTagged*>(ev);
419      if (temp_ev==0) {
420        throw DataException("Error - DataTagged::symmetric casting to DataTagged failed (probably a programming error).");
421      }
422      const DataTagged::DataMapType& thisLookup=getTagLookup();
423      DataTagged::DataMapType::const_iterator i;
424      DataTagged::DataMapType::const_iterator thisLookupEnd=thisLookup.end();
425      for (i=thisLookup.begin();i!=thisLookupEnd;i++) {
426          temp_ev->addTaggedValue(i->first,temp_ev->getDefaultValue());
427          DataArrayView thisView=getDataPointByTag(i->first);
428          DataArrayView evView=temp_ev->getDataPointByTag(i->first);
429          DataArrayView::symmetric(thisView,0,evView,0);
430      }
431      DataArrayView::symmetric(getDefaultValue(),0,temp_ev->getDefaultValue(),0);
432    }
433    void
434    DataTagged::nonsymmetric(DataAbstract* ev)
435  {  {
436    return m_data.size();    DataTagged* temp_ev=dynamic_cast<DataTagged*>(ev);
437      if (temp_ev==0) {
438        throw DataException("Error - DataTagged::nonsymmetric casting to DataTagged failed (probably a programming error).");
439      }
440      const DataTagged::DataMapType& thisLookup=getTagLookup();
441      DataTagged::DataMapType::const_iterator i;
442      DataTagged::DataMapType::const_iterator thisLookupEnd=thisLookup.end();
443      for (i=thisLookup.begin();i!=thisLookupEnd;i++) {
444          temp_ev->addTaggedValue(i->first,temp_ev->getDefaultValue());
445          DataArrayView thisView=getDataPointByTag(i->first);
446          DataArrayView evView=temp_ev->getDataPointByTag(i->first);
447          DataArrayView::nonsymmetric(thisView,0,evView,0);
448      }
449      DataArrayView::nonsymmetric(getDefaultValue(),0,temp_ev->getDefaultValue(),0);
450    }
451    void
452    DataTagged::trace(DataAbstract* ev, int axis_offset)
453    {
454      DataTagged* temp_ev=dynamic_cast<DataTagged*>(ev);
455      if (temp_ev==0) {
456        throw DataException("Error - DataTagged::trace casting to DataTagged failed (probably a programming error).");
457      }
458      const DataTagged::DataMapType& thisLookup=getTagLookup();
459      DataTagged::DataMapType::const_iterator i;
460      DataTagged::DataMapType::const_iterator thisLookupEnd=thisLookup.end();
461      for (i=thisLookup.begin();i!=thisLookupEnd;i++) {
462          temp_ev->addTaggedValue(i->first,temp_ev->getDefaultValue());
463          DataArrayView thisView=getDataPointByTag(i->first);
464          DataArrayView evView=temp_ev->getDataPointByTag(i->first);
465          DataArrayView::trace(thisView,0,evView,0, axis_offset);
466      }
467      DataArrayView::trace(getDefaultValue(),0,temp_ev->getDefaultValue(),0,axis_offset);
468  }  }
469    
470    void
471    DataTagged::transpose(DataAbstract* ev, int axis_offset)
472    {
473      DataTagged* temp_ev=dynamic_cast<DataTagged*>(ev);
474      if (temp_ev==0) {
475        throw DataException("Error - DataTagged::transpose casting to DataTagged failed (probably a programming error).");
476      }
477      const DataTagged::DataMapType& thisLookup=getTagLookup();
478      DataTagged::DataMapType::const_iterator i;
479      DataTagged::DataMapType::const_iterator thisLookupEnd=thisLookup.end();
480      for (i=thisLookup.begin();i!=thisLookupEnd;i++) {
481          temp_ev->addTaggedValue(i->first,temp_ev->getDefaultValue());
482          DataArrayView thisView=getDataPointByTag(i->first);
483          DataArrayView evView=temp_ev->getDataPointByTag(i->first);
484          DataArrayView::transpose(thisView,0,evView,0, axis_offset);
485      }
486      DataArrayView::transpose(getDefaultValue(),0,temp_ev->getDefaultValue(),0,axis_offset);
487    }
488    
489    void
490    DataTagged::swapaxes(DataAbstract* ev, int axis0, int axis1)
491    {
492      DataTagged* temp_ev=dynamic_cast<DataTagged*>(ev);
493      if (temp_ev==0) {
494        throw DataException("Error - DataTagged::swapaxes casting to DataTagged failed (probably a programming error).");
495      }
496      const DataTagged::DataMapType& thisLookup=getTagLookup();
497      DataTagged::DataMapType::const_iterator i;
498      DataTagged::DataMapType::const_iterator thisLookupEnd=thisLookup.end();
499      for (i=thisLookup.begin();i!=thisLookupEnd;i++) {
500          temp_ev->addTaggedValue(i->first,temp_ev->getDefaultValue());
501          DataArrayView thisView=getDataPointByTag(i->first);
502          DataArrayView evView=temp_ev->getDataPointByTag(i->first);
503          DataArrayView::swapaxes(thisView,0,evView,0,axis0,axis1);
504      }
505      DataArrayView::swapaxes(getDefaultValue(),0,temp_ev->getDefaultValue(),0,axis0,axis1);
506    }
507    
508    void
509    DataTagged::eigenvalues(DataAbstract* ev)
510    {
511      DataTagged* temp_ev=dynamic_cast<DataTagged*>(ev);
512      if (temp_ev==0) {
513        throw DataException("Error - DataTagged::eigenvalues casting to DataTagged failed (propably a programming error).");
514      }
515      const DataTagged::DataMapType& thisLookup=getTagLookup();
516      DataTagged::DataMapType::const_iterator i;
517      DataTagged::DataMapType::const_iterator thisLookupEnd=thisLookup.end();
518      for (i=thisLookup.begin();i!=thisLookupEnd;i++) {
519          temp_ev->addTaggedValue(i->first,temp_ev->getDefaultValue());
520          DataArrayView thisView=getDataPointByTag(i->first);
521          DataArrayView evView=temp_ev->getDataPointByTag(i->first);
522          DataArrayView::eigenvalues(thisView,0,evView,0);
523      }
524      DataArrayView::eigenvalues(getDefaultValue(),0,temp_ev->getDefaultValue(),0);
525    }
526    void
527    DataTagged::eigenvalues_and_eigenvectors(DataAbstract* ev,DataAbstract* V,const double tol)
528    {
529      DataTagged* temp_ev=dynamic_cast<DataTagged*>(ev);
530      if (temp_ev==0) {
531        throw DataException("Error - DataTagged::eigenvalues_and_eigenvectors casting to DataTagged failed (propably a programming error).");
532      }
533      DataTagged* temp_V=dynamic_cast<DataTagged*>(V);
534      if (temp_V==0) {
535        throw DataException("Error - DataTagged::eigenvalues_and_eigenvectors casting to DataTagged failed (propably a programming error).");
536      }
537      const DataTagged::DataMapType& thisLookup=getTagLookup();
538      DataTagged::DataMapType::const_iterator i;
539      DataTagged::DataMapType::const_iterator thisLookupEnd=thisLookup.end();
540      for (i=thisLookup.begin();i!=thisLookupEnd;i++) {
541          temp_ev->addTaggedValue(i->first,temp_ev->getDefaultValue());
542          temp_V->addTaggedValue(i->first,temp_V->getDefaultValue());
543          DataArrayView thisView=getDataPointByTag(i->first);
544          DataArrayView evView=temp_ev->getDataPointByTag(i->first);
545          DataArrayView VView=temp_V->getDataPointByTag(i->first);
546          DataArrayView::eigenvalues_and_eigenvectors(thisView,0,evView,0,VView,0,tol);
547      }
548      DataArrayView::eigenvalues_and_eigenvectors(getDefaultValue(),0,
549                                                  temp_ev->getDefaultValue(),0,
550                                                  temp_V->getDefaultValue(),0,
551                                                  tol);
552    
553    
554    }
555    
556    
557  }  // end of namespace  }  // end of namespace

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

  ViewVC Help
Powered by ViewVC 1.1.26