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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 950 - (hide annotations)
Tue Feb 6 07:01:11 2007 UTC (12 years, 2 months ago) by gross
File size: 19667 byte(s)
escript data objects can now be saved to netCDF files, see http://www.unidata.ucar.edu/software/netcdf/.
Currently only constant data are implemented with expanded and tagged data to follow.
There are two new functions to dump a data object

   s=Data(...)
   s.dump(<filename>)

and to recover it

   s=load(<filename>, domain)

Notice that the function space of s is recovered but domain is still need. 

dump and load will replace archive and extract.

The installation needs now the netCDF installed. 


1 jgs 82 // $Id$
2 jgs 121
3 jgs 82 /*
4 elspeth 615 ************************************************************
5     * Copyright 2006 by ACcESS MNRF *
6     * *
7     * http://www.access.edu.au *
8     * Primary Business: Queensland, Australia *
9     * Licensed under the Open Software License version 3.0 *
10     * http://www.opensource.org/licenses/osl-3.0.php *
11     * *
12     ************************************************************
13 jgs 82 */
14    
15 jgs 474 #include "DataTagged.h"
16 jgs 496
17 jgs 474 #include "DataConstant.h"
18     #include "DataException.h"
19 jgs 82
20     using namespace std;
21    
22     namespace escript {
23    
24 jgs 121 DataTagged::DataTagged()
25     : DataAbstract(FunctionSpace())
26 jgs 82 {
27 jgs 509 // default constructor
28    
29 jgs 82 // create a scalar default value
30 jgs 151 m_data.resize(1,0.,1);
31 jgs 82 DataArrayView temp(m_data,DataArrayView::ShapeType());
32     setPointDataView(temp);
33     }
34    
35     DataTagged::DataTagged(const TagListType& tagKeys,
36     const ValueListType& values,
37     const DataArrayView& defaultValue,
38 jgs 102 const FunctionSpace& what)
39     : DataAbstract(what)
40 jgs 82 {
41 jgs 509 // constructor
42    
43 jgs 121 // initialise the array of data values
44     // the default value is always the first item in the values list
45 jgs 151 int len = defaultValue.noValues();
46     m_data.resize(len,0.,len);
47 jgs 121 for (int i=0; i<defaultValue.noValues(); i++) {
48     m_data[i]=defaultValue.getData(i);
49     }
50    
51 jgs 119 // create the data view
52 jgs 82 DataArrayView temp(m_data,defaultValue.getShape());
53     setPointDataView(temp);
54 jgs 121
55 jgs 82 // add remaining tags and values
56     addTaggedValues(tagKeys,values);
57     }
58    
59 jgs 119 DataTagged::DataTagged(const FunctionSpace& what,
60     const DataArrayView::ShapeType &shape,
61     const int tags[],
62 jgs 500 const ValueType& data)
63 jgs 119 : DataAbstract(what)
64     {
65 jgs 509 // alternative constructor
66     // not unit_tested tested yet
67    
68 jgs 121 // copy the data
69 jgs 119 m_data=data;
70 jgs 121
71 jgs 119 // create the view of the data
72     DataArrayView tempView(m_data,shape);
73     setPointDataView(tempView);
74 jgs 121
75 jgs 119 // 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 woo409 757 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 jgs 102 DataTagged::DataTagged(const DataTagged& other)
105     : DataAbstract(other.getFunctionSpace()),
106 jgs 82 m_data(other.m_data),
107     m_offsetLookup(other.m_offsetLookup)
108     {
109 jgs 509 // copy constructor
110    
111 jgs 119 // create the data view
112 jgs 82 DataArrayView temp(m_data,other.getPointDataView().getShape());
113     setPointDataView(temp);
114     }
115    
116 jgs 102 DataTagged::DataTagged(const DataConstant& other)
117     : DataAbstract(other.getFunctionSpace())
118 jgs 82 {
119 jgs 509 // copy constructor
120    
121 jgs 121 // fill the default value with the constant value item from "other"
122 jgs 82 const DataArrayView& value=other.getPointDataView();
123 jgs 151 int len = value.noValues();
124     m_data.resize(len,0.,len);
125 jgs 121 for (int i=0; i<value.noValues(); i++) {
126     m_data[i]=value.getData(i);
127     }
128    
129 jgs 119 // create the data view
130 jgs 82 DataArrayView temp(m_data,value.getShape());
131     setPointDataView(temp);
132     }
133    
134     DataAbstract*
135     DataTagged::getSlice(const DataArrayView::RegionType& region) const
136     {
137 jgs 513 return new DataTagged(*this, region);
138 jgs 82 }
139    
140 jgs 513 DataTagged::DataTagged(const DataTagged& other,
141     const DataArrayView::RegionType& region)
142     : DataAbstract(other.getFunctionSpace())
143     {
144     // slice constructor
145    
146     // get the shape of the slice to copy from other
147     DataArrayView::ShapeType regionShape(DataArrayView::getResultSliceShape(region));
148     DataArrayView::RegionLoopRangeType regionLoopRange=getSliceRegionLoopRange(region);
149    
150     // allocate enough space in this for all values
151     // (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);
158    
159     // copy the default value from other to this
160     getDefaultValue().copySlice(other.getDefaultValue(), regionLoopRange);
161    
162     // loop through the tag values copying these
163     DataMapType::const_iterator pos;
164     DataArrayView::ValueType::size_type tagOffset=getPointDataView().noValues();
165     for (pos=other.m_offsetLookup.begin();pos!=other.m_offsetLookup.end();pos++){
166     getPointDataView().copySlice(tagOffset,other.getPointDataView(),pos->second,regionLoopRange);
167     m_offsetLookup.insert(DataMapType::value_type(pos->first,tagOffset));
168     tagOffset+=getPointDataView().noValues();
169     }
170     }
171    
172 jgs 82 void
173 jgs 513 DataTagged::setSlice(const DataAbstract* other,
174     const DataArrayView::RegionType& region)
175 jgs 82 {
176 jgs 513
177     // 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 jgs 82 throw DataException("Programming error - casting to DataTagged.");
182     }
183 jgs 121
184 jgs 513 // 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 jgs 82 if (getPointDataView().getRank()!=region.size()) {
192     throw DataException("Error - Invalid slice region.");
193     }
194 woo409 757 if (otherTemp->getPointDataView().getRank()>0 && !other->getPointDataView().checkShape(regionShape)) {
195 jgs 513 throw DataException (other->getPointDataView().createShapeErrorMessage(
196     "Error - Couldn't copy slice due to shape mismatch.",regionShape));
197 jgs 82 }
198 jgs 121
199 jgs 513 // copy slice from other default value to this default value
200     getDefaultValue().copySliceFrom(otherTemp->getDefaultValue(), regionLoopRange);
201 jgs 121
202 jgs 541 // loop through tag values in other, adding any which aren't in this, using default value
203     DataMapType::const_iterator pos;
204     for (pos=otherTemp->m_offsetLookup.begin();pos!=otherTemp->m_offsetLookup.end();pos++) {
205     if (!isCurrentTag(pos->first)) {
206     addTaggedValue(pos->first,getDefaultValue());
207     }
208     }
209    
210 jgs 513 // loop through the tag values copying slices from other to this
211 jgs 121 for (pos=m_offsetLookup.begin();pos!=m_offsetLookup.end();pos++) {
212 jgs 513 getDataPointByTag(pos->first).copySliceFrom(otherTemp->getDataPointByTag(pos->first), regionLoopRange);
213 jgs 121 }
214 jgs 513
215 jgs 82 }
216    
217 jgs 149 int
218     DataTagged::getTagNumber(int dpno)
219     {
220     //
221     // Get the number of samples and data-points per sample
222     int numSamples = getNumSamples();
223     int numDataPointsPerSample = getNumDPPSample();
224     int numDataPoints = numSamples * numDataPointsPerSample;
225    
226     if (numDataPointsPerSample==0) {
227     throw DataException("DataTagged::getTagNumber error: no data-points associated with this object.");
228     }
229    
230 jgs 496 if (dpno<0 || dpno>numDataPoints-1) {
231 jgs 149 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 jgs 82 void
248 jgs 509 DataTagged::setTaggedValues(const TagListType& tagKeys,
249     const ValueListType& values)
250     {
251     addTaggedValues(tagKeys,values);
252     }
253    
254     void
255 jgs 82 DataTagged::setTaggedValue(int tagKey,
256     const DataArrayView& value)
257     {
258 jgs 121 if (!getPointDataView().checkShape(value.getShape())) {
259     throw DataException(getPointDataView().createShapeErrorMessage(
260     "Error - Cannot setTaggedValue due to shape mismatch.", value.getShape()));
261     }
262 jgs 82 DataMapType::iterator pos(m_offsetLookup.find(tagKey));
263     if (pos==m_offsetLookup.end()) {
264 jgs 121 // tag couldn't be found so use addTaggedValue
265 jgs 82 addTaggedValue(tagKey,value);
266     } else {
267 jgs 121 // 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 jgs 82 }
272     }
273     }
274    
275     void
276 jgs 509 DataTagged::addTaggedValues(const TagListType& tagKeys,
277     const ValueListType& values)
278     {
279     if (values.size()==0) {
280     // copy the current default value for each of the tags
281     TagListType::const_iterator iT;
282     for (iT=tagKeys.begin();iT!=tagKeys.end();iT++) {
283     // the point data view for DataTagged points at the default value
284     addTaggedValue(*iT,getPointDataView());
285     }
286     } else if (values.size()==1 && tagKeys.size()>1) {
287     // assume the one given value will be used for all tag values
288     TagListType::const_iterator iT;
289     for (iT=tagKeys.begin();iT!=tagKeys.end();iT++) {
290     addTaggedValue(*iT,values[0]);
291     }
292     } else {
293     if (tagKeys.size()!=values.size()) {
294     stringstream temp;
295     temp << "Error - (addTaggedValue) Number of tags: " << tagKeys.size()
296     << " doesn't match number of values: " << values.size();
297     throw DataException(temp.str());
298     } else {
299     for (int i=0;i<tagKeys.size();i++) {
300     addTaggedValue(tagKeys[i],values[i]);
301     }
302     }
303     }
304     }
305    
306     void
307 jgs 82 DataTagged::addTaggedValue(int tagKey,
308     const DataArrayView& value)
309     {
310     if (!getPointDataView().checkShape(value.getShape())) {
311     throw DataException(getPointDataView().createShapeErrorMessage(
312 jgs 121 "Error - Cannot addTaggedValue due to shape mismatch.", value.getShape()));
313 jgs 82 }
314 jgs 121 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 jgs 151 m_data.resize(newSize,0.,newSize);
328 jgs 121 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 jgs 82 }
336    
337     double*
338     DataTagged::getSampleDataByTag(int tag)
339     {
340     DataMapType::iterator pos(m_offsetLookup.find(tag));
341     if (pos==m_offsetLookup.end()) {
342     // tag couldn't be found so return the default value
343     return &(m_data[0]);
344     } else {
345     // return the data-point corresponding to the given tag
346     return &(m_data[pos->second]);
347     }
348     }
349    
350     string
351     DataTagged::toString() const
352     {
353     stringstream temp;
354     DataMapType::const_iterator i;
355     temp << "Tag(Default)" << endl;
356     temp << getDefaultValue().toString() << endl;
357     // create a temporary view as the offset will be changed
358     DataArrayView tempView(getPointDataView().getData(), getPointDataView().getShape());
359     for (i=m_offsetLookup.begin();i!=m_offsetLookup.end();++i) {
360     temp << "Tag(" << i->first << ")" << endl;
361     tempView.setOffset(i->second);
362     temp << tempView.toString() << endl;
363     }
364     return temp.str();
365     }
366    
367 jgs 496 DataArrayView::ValueType::size_type
368     DataTagged::getPointOffset(int sampleNo,
369     int dataPointNo) const
370 jgs 82 {
371 jgs 496 int tagKey=getFunctionSpace().getTagFromSampleNo(sampleNo);
372     DataMapType::const_iterator pos(m_offsetLookup.find(tagKey));
373 jgs 82 DataArrayView::ValueType::size_type offset=m_defaultValueOffset;
374     if (pos!=m_offsetLookup.end()) {
375     offset=pos->second;
376     }
377 jgs 496 return offset;
378 jgs 82 }
379    
380 jgs 496 DataArrayView
381     DataTagged::getDataPointByTag(int tag) const
382 jgs 82 {
383 jgs 496 DataMapType::const_iterator pos(m_offsetLookup.find(tag));
384 jgs 82 DataArrayView::ValueType::size_type offset=m_defaultValueOffset;
385     if (pos!=m_offsetLookup.end()) {
386     offset=pos->second;
387     }
388 jgs 496 DataArrayView temp(getPointDataView());
389     temp.setOffset(offset);
390     return temp;
391 jgs 82 }
392    
393     DataArrayView
394     DataTagged::getDataPoint(int sampleNo,
395     int dataPointNo)
396     {
397     EsysAssert(validSampleNo(sampleNo),"(getDataPoint) Invalid sampleNo: " << sampleNo);
398     int tagKey=getFunctionSpace().getTagFromSampleNo(sampleNo);
399     return getDataPointByTag(tagKey);
400     }
401    
402 jgs 123 int
403     DataTagged::archiveData(ofstream& archiveFile,
404     const DataArrayView::ValueType::size_type noValues) const
405     {
406     return(m_data.archiveData(archiveFile, noValues));
407     }
408    
409     int
410     DataTagged::extractData(ifstream& archiveFile,
411     const DataArrayView::ValueType::size_type noValues)
412     {
413     return(m_data.extractData(archiveFile, noValues));
414     }
415 gross 580 void
416 ksteube 775 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     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 gross 800 DataTagged::trace(DataAbstract* ev, int axis_offset)
453 ksteube 775 {
454     DataTagged* temp_ev=dynamic_cast<DataTagged*>(ev);
455     if (temp_ev==0) {
456 gross 800 throw DataException("Error - DataTagged::trace casting to DataTagged failed (probably a programming error).");
457 ksteube 775 }
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 gross 800 DataArrayView::trace(thisView,0,evView,0, axis_offset);
466 ksteube 775 }
467 gross 800 DataArrayView::trace(getDefaultValue(),0,temp_ev->getDefaultValue(),0,axis_offset);
468 ksteube 775 }
469 gross 800
470 ksteube 775 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 gross 800
489 ksteube 775 void
490 gross 804 DataTagged::swapaxes(DataAbstract* ev, int axis0, int axis1)
491 gross 800 {
492     DataTagged* temp_ev=dynamic_cast<DataTagged*>(ev);
493     if (temp_ev==0) {
494 gross 804 throw DataException("Error - DataTagged::swapaxes casting to DataTagged failed (probably a programming error).");
495 gross 800 }
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 gross 804 DataArrayView::swapaxes(thisView,0,evView,0,axis0,axis1);
504 gross 800 }
505 gross 804 DataArrayView::swapaxes(getDefaultValue(),0,temp_ev->getDefaultValue(),0,axis0,axis1);
506 gross 800 }
507    
508     void
509 gross 580 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 jgs 123
553 gross 580
554     }
555    
556 gross 950 void
557     DataTagged::dump(const std::string fileName) const
558     {
559     throw DataException("Error - DataTagged:: dump: not implemented.");
560     }
561 gross 580
562 gross 950
563 jgs 82 } // end of namespace

Properties

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

  ViewVC Help
Powered by ViewVC 1.1.26