escript/src/DataTagged.h

// $Id$

/*
 ************************************************************
 *          Copyright 2006 by ACcESS MNRF                   *
 *                                                          *
 *              http://www.access.edu.au                    *
 *       Primary Business: Queensland, Australia            *
 *  Licensed under the Open Software License version 3.0    *
 *     http://www.opensource.org/licenses/osl-3.0.php       *
 *                                                          *
 ************************************************************
*/

#if !defined escript_DataTagged_20040615_H
#define escript_DataTagged_20040615_H
#include "system_dep.h"

#include "DataAbstract.h"
#include "DataArrayView.h"

#include <vector>
#include <map>

namespace escript {

class DataConstant;

/**
   \brief
   Simulates a full dataset accessible via sampleNo and dataPointNo. 

   Description:
   Each data-point has an associated tag number, and a given tag can represent a
   range of dataPointNo and sampleNo. Each tag indexes only a single data-point.
   Thus only a single data-point needs to be stored for a range of sampleNo and
   dataPointNo values.
*/

class DataTagged : public DataAbstract {

 public:

  //
  // Types for the lists of tags and values.
  typedef std::vector<int>           TagListType;
  typedef std::vector<DataArrayView> ValueListType;
  typedef DataArrayView::ValueType   ValueType;

  //
  // Map from a tag to an offset into the data array. 
  typedef std::map<int, int> DataMapType;

  /**
     \brief
     Default constructor for DataTagged.

     Description:
     Default constructor for DataTagged. Creates a DataTagged object for which
     the default data-point is a scalar data-point with value 0.0, and no other
     tag values are stored.
    T
  */
  ESCRIPT_DLL_API
  DataTagged();

  /**
     \brief
     Constructor for DataTagged.

     Description:
     Constructor for DataTagged.
     \param tagKeys - Input - A vector of integer tags.
     \param values - Input - A vector of DataArrayViews. If this is empty
                     all tag values will be assigned a scalar data-point of value
                     0. If it contains one value all tag values will be assigned
             this value. Otherwise consecutive tags will be assigned 
                     consecutive values.  If there is a mismatch between  the
             number of keys and the number of values an exception 
             will be generated.
     \param defaultValue - Input - Value returned if a requested tag doesn't exist.
     \param what - Input - A description of what this data represents.
    T
  */
  ESCRIPT_DLL_API
  DataTagged(const TagListType& tagKeys,
             const ValueListType& values,
         const DataArrayView& defaultValue,
         const FunctionSpace& what);

  /**
     \brief
     Alternative Constructor for DataTagged.

     Description:
     Alternative Constructor for DataTagged.
     \param what - Input - A description of what this data object represents.
     \param shape - Input - The shape of each data-point.
     \param tags - Input - An array of tags, one for each sample number.
     \param data - The data values for each tag.
    NB: no unit testing yet
  */
  ESCRIPT_DLL_API
  DataTagged(const FunctionSpace& what,
             const DataArrayView::ShapeType &shape,
             const int tags[],
             const ValueType& data);

  /**
     \brief
     Alternative Constructor for DataTagged.

     Description:
     Alternative Constructor for DataTagged.
     \param what - Input - A description of what this data object represents.
     \param shape - Input - The shape of each data-point.
     \param tags - Input - An vector of tags, one for each sample number.
     \param data - The data values for each tag.
    NB: no unit testing yet
  */
  ESCRIPT_DLL_API
  DataTagged(const FunctionSpace& what,
             const DataArrayView::ShapeType &shape,
             const TagListType& tags,
             const ValueType& data);

  /**
     \brief
     Copy Constructor for DataTagged.
     Performs a deep copy from the given DataTagged object.
    T
  */
  ESCRIPT_DLL_API
  DataTagged(const DataTagged& other);

  /**
     \brief
     Copy Constructor for DataTagged.
     Construct a DataTagged object from a DataConstant object.
     The default value will be the value of the DataConstant object.
    T
  */
  ESCRIPT_DLL_API
  DataTagged(const DataConstant& other);

  /**
     \brief
     getSampleDataByTag

     Description:
     Return the data-point for the given tag. All of the data for the
     sample will be visible via the returned pointer.

     ** This provides an interface into the data suitable for legacy C code.
     ** NB: need to do array bounds checking when accessing returned value!
    T
  */
  ESCRIPT_DLL_API
  virtual
  double*
  getSampleDataByTag(int tag);

  /**
     \brief
     Write the data as a string.
     Writes out each tag, including the default, and the data-point which is
     associated with each tag.
    T
  */
  ESCRIPT_DLL_API
  virtual
  std::string
  toString() const;
 /**
     \brief
     dumps the object into a netCDF file
  */
  ESCRIPT_DLL_API
  virtual
  void
  dump(const std::string fileName) const;

  /**
     \brief
     Return the tag number associated with the given data-point number
     according to the associated function space.
    T
  */
  ESCRIPT_DLL_API
  virtual
  int
  getTagNumber(int dpno);

  /**
     \brief
     getPointOffset

     Description:
     Return the offset to the given data-point value in the underlying
     data vector.

     \param sampleNo - Input - sample number.
     \param dataPointNo - Input - data-point number.
    T
  */
  ESCRIPT_DLL_API
  virtual
  ValueType::size_type
  getPointOffset(int sampleNo,
                 int dataPointNo) const;

  /**
     \brief
     addTaggedValues

     Description:
     Add the given tags and values to this DataTagged object.
     \param tagKeys - Input - A vector of integer tags.
     \param values - Input - A vector of DataArrayViews. If this is empty
                     all tag values will be assigned a scalar data-point of value
                     0. If it contains one value all tag values will be assigned
             this value. Otherwise consecutive tags will be assigned 
                     consecutive values.  If there is a mismatch between  the
             number of keys and the number of values an exception 
             will be generated.
    T
  */
  ESCRIPT_DLL_API
  void
  addTaggedValues(const TagListType& tagKeys,
                  const ValueListType& values);  

  /**
     \brief
     addTaggedValue

     Description:
     Add a single tag and value to this DataTagged object. If this tag already has
     a value associated with it, setTaggedValue will be used to update this value.
     \param tagKey - Input - Integer tag.
     \param value - Input - Single DataArrayView value to be assigned to the tag.
    T
  */
  ESCRIPT_DLL_API
  void
  addTaggedValue(int tagKey,
                 const DataArrayView& value);

  /**
     \brief
     setTaggedValues

     Description:
     Set the given tags to the given values in this DataTagged object.
     \param tagKeys - Input - A vector of integer tag.
     \param values - Input - A vector of DataArrayViews. If this is empty
                     all tag values will be assigned a scalar data-point of value
                     0. If it contains one value all tag values will be assigned
             this value. Otherwise consecutive tags will be assigned 
                     consecutive values.  If there is a mismatch between  the
             number of keys and the number of values an exception 
             will be generated.
    T
  */
  ESCRIPT_DLL_API
  void
  setTaggedValues(const TagListType& tagKeys,
                  const ValueListType& values); 

  /**
     \brief
     setTaggedValue

     Description:
     Assign the given value to the given tag.
     \param tagKey - Input - Integer tag.
     \param value - Input - Single DataArrayView value to be assigned to the tag.
    T
  */
  ESCRIPT_DLL_API
  virtual
  void
  setTaggedValue(int tagKey,
                 const DataArrayView& value);

  /**
     \brief
     getDataPointByTag

     Description:
     Return data-point associated with the given tag as a DataArrayView.
     \param tag - Input - Integer key.
    T
  */
  ESCRIPT_DLL_API
  DataArrayView
  getDataPointByTag(int tag) const;

  /**
     \brief
     getDataPoint

     Description:
     Return the data-point specified by the given sample and data-point
     numbers as a DataArrayView.
     \param sampleNo - Input.
     \param dataPointNo - Input.
    T
  */
  ESCRIPT_DLL_API
  virtual
  DataArrayView
  getDataPoint(int sampleNo,
               int dataPointNo);

  /**
     \brief
     getData

     Description:
     Return pointer to the data
    T
  */
  ESCRIPT_DLL_API
  const DataArrayView::ValueType::ElementType*
  getData() const;

  /**
     \brief 
     getTagLookup

     Description:
     Return a reference to the tag offset lookup table.
    T
  */
  ESCRIPT_DLL_API
  const DataMapType&
  getTagLookup() const;

  /**
     \brief
     isCurrentTag

     Description:
     Return true if the given tag exists within the DataTagged tag map.

     *** NB: The DataTagged tag map does not necessarily coincide with the tag
     keys in the associated function space.
    T
  */
  ESCRIPT_DLL_API
  bool
  isCurrentTag(int tag) const;

  /**
     \brief
     getDefaultValue

     Description:
     Return the default value. This value is associated with any tag which
     is not explicitly recorded in this DataTagged object's tag map.
    T
  */
  ESCRIPT_DLL_API
  DataArrayView&
  getDefaultValue();

  ESCRIPT_DLL_API
  const DataArrayView&
  getDefaultValue() const;

  /**
     \brief
     getLength

     Description:
     Return the total number of doubles stored for this DataTagged object.
    T
  */
  ESCRIPT_DLL_API
  virtual
  ValueType::size_type
  getLength() const;

  /**
     \brief
     getSlice

     Description:
     Factory method that returns a newly created DataTagged object generated
     by taking the specified slice from this DataTagged object.
     The caller is reponsible for managing the returned object.
    T
  */
  ESCRIPT_DLL_API
  virtual
  DataAbstract*
  getSlice(const DataArrayView::RegionType& region) const;

  /**
     \brief
     Slice Constructor for DataTagged.

     Description:
     Creates a DataTagged object which is the specified slice
     from the given DataTagged object.
     \param other - Input - DataTagged object to slice from.
     \param region - Input - Region to slice.
    T
  */
  ESCRIPT_DLL_API
  DataTagged(const DataTagged& other, 
         const DataArrayView::RegionType& region);

  /**
     \brief
     setSlice

     Description:
     Copy the given Data object into the specified region in this object.
     \param other - Input - Data object to copy from.
     \param region - Input - Region to copy into (NB: must have same shape as other!).
    T
  */
  ESCRIPT_DLL_API
  virtual
  void
  setSlice(const DataAbstract* other,
           const DataArrayView::RegionType& region);

  /**
     \brief
     Archive the underlying data values to the file referenced
     by ofstream. A count of the number of values expected to be written
     is provided as a cross-check.

     The return value indicates success (0) or otherwise (1).
  */
  ESCRIPT_DLL_API
  int
  archiveData(std::ofstream& archiveFile,
              const DataArrayView::ValueType::size_type noValues) const;

  /**
     \brief
     Extract the number of values specified by noValues from the file
     referenced by ifstream to the underlying data structure.

     The return value indicates success (0) or otherwise (1).
  */
  ESCRIPT_DLL_API
  int
  extractData(std::ifstream& archiveFile,
              const DataArrayView::ValueType::size_type noValues);

  /**
     \brief
     Computes a symmetric matrix (A + AT) / 2

     \param ev - Output - symmetric matrix

  */
  ESCRIPT_DLL_API
  virtual void
  symmetric(DataAbstract* ev);

  /**
     \brief
     Computes a nonsymmetric matrix (A - AT) / 2

     \param ev - Output - nonsymmetric matrix

  */
  ESCRIPT_DLL_API
  virtual void
  nonsymmetric(DataAbstract* ev);

  /**
     \brief
     Computes the trace of a matrix

     \param ev - Output - the trace of a matrix

  */
  ESCRIPT_DLL_API
  virtual void
  trace(DataAbstract* ev, int axis_offset);

  /**
     \brief
     swaps components axis0 and axis1

     \param ev - Output - swapped components

  */
  ESCRIPT_DLL_API
  virtual void
  swapaxes(DataAbstract* ev, int axis0, int axis1);

  /**
     \brief
     Transpose each data point of this Data object around the given axis.

     \param ev - Output - the transpose of a matrix

  */
  ESCRIPT_DLL_API
  virtual void
  transpose(DataAbstract* ev, int axis_offset);

  /**
     \brief
     solves the eigenvalue problem this*V=ev*V for the eigenvalues ev

     \param ev - Output - eigenvalues in increasing order at each data point

  */
  ESCRIPT_DLL_API
  virtual void
  eigenvalues(DataAbstract* ev);

  /**
     \brief
     solves the eigenvalue problem this*V=ev*V for the eigenvalues ev and eigenvectors V

     \param ev - Output - eigenvalues in increasing order at each data point
     \param V - Output - corresponding eigenvectors. They are normalized such that their length is one
                         and the first nonzero component is positive.
     \param tol - Input - eigenvalue with relative distance tol are treated as equal.

  */

  ESCRIPT_DLL_API
  virtual void
  eigenvalues_and_eigenvectors(DataAbstract* ev,DataAbstract* V,const double tol=1.e-13);


 protected:

 private:

  //
  // The offset lookup table
  DataMapType m_offsetLookup;

  //
  // the offset to the default value
  static const int m_defaultValueOffset = 0;

  //
  // The actual data
  ValueType m_data;

};

inline
bool
DataTagged::isCurrentTag(int tag) const
{
  DataMapType::const_iterator pos(m_offsetLookup.find(tag));
  return (pos!=m_offsetLookup.end());
}

inline
DataArrayView&
DataTagged::getDefaultValue()
{
  // The default value is always the first value.
  return getPointDataView();
}

inline
const DataArrayView&
DataTagged::getDefaultValue() const
{
  // The default value is always the first value.
  return getPointDataView();
}

inline
const DataArrayView::ValueType::ElementType*
DataTagged::getData() const
{
   return &(m_data[0]);
}

inline
const DataTagged::DataMapType&
DataTagged::getTagLookup() const
{
  return m_offsetLookup;
}

inline
DataArrayView::ValueType::size_type
DataTagged::getLength() const
{
  return m_data.size();
}

} // end of namespace

#endif
1	// $Id$
2
3	/*
4	************************************************************
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	*/
14
15	#if !defined escript_DataTagged_20040615_H
16	#define escript_DataTagged_20040615_H
17	#include "system_dep.h"
18
19	#include "DataAbstract.h"
20	#include "DataArrayView.h"
21
22	#include <vector>
23	#include <map>
24
25	namespace escript {
26
27	class DataConstant;
28
29	/**
30	\brief
31	Simulates a full dataset accessible via sampleNo and dataPointNo.
32
33	Description:
34	Each data-point has an associated tag number, and a given tag can represent a
35	range of dataPointNo and sampleNo. Each tag indexes only a single data-point.
36	Thus only a single data-point needs to be stored for a range of sampleNo and
37	dataPointNo values.
38	*/
39
40	class DataTagged : public DataAbstract {
41
42	public:
43
44	//
45	// Types for the lists of tags and values.
46	typedef std::vector<int> TagListType;
47	typedef std::vector<DataArrayView> ValueListType;
48	typedef DataArrayView::ValueType ValueType;
49
50	//
51	// Map from a tag to an offset into the data array.
52	typedef std::map<int, int> DataMapType;
53
54	/**
55	\brief
56	Default constructor for DataTagged.
57
58	Description:
59	Default constructor for DataTagged. Creates a DataTagged object for which
60	the default data-point is a scalar data-point with value 0.0, and no other
61	tag values are stored.
62	T
63	*/
64	ESCRIPT_DLL_API
65	DataTagged();
66
67	/**
68	\brief
69	Constructor for DataTagged.
70
71	Description:
72	Constructor for DataTagged.
73	\param tagKeys - Input - A vector of integer tags.
74	\param values - Input - A vector of DataArrayViews. If this is empty
75	all tag values will be assigned a scalar data-point of value
76	0. If it contains one value all tag values will be assigned
77	this value. Otherwise consecutive tags will be assigned
78	consecutive values. If there is a mismatch between the
79	number of keys and the number of values an exception
80	will be generated.
81	\param defaultValue - Input - Value returned if a requested tag doesn't exist.
82	\param what - Input - A description of what this data represents.
83	T
84	*/
85	ESCRIPT_DLL_API
86	DataTagged(const TagListType& tagKeys,
87	const ValueListType& values,
88	const DataArrayView& defaultValue,
89	const FunctionSpace& what);
90
91	/**
92	\brief
93	Alternative Constructor for DataTagged.
94
95	Description:
96	Alternative Constructor for DataTagged.
97	\param what - Input - A description of what this data object represents.
98	\param shape - Input - The shape of each data-point.
99	\param tags - Input - An array of tags, one for each sample number.
100	\param data - The data values for each tag.
101	NB: no unit testing yet
102	*/
103	ESCRIPT_DLL_API
104	DataTagged(const FunctionSpace& what,
105	const DataArrayView::ShapeType &shape,
106	const int tags[],
107	const ValueType& data);
108
109	/**
110	\brief
111	Alternative Constructor for DataTagged.
112
113	Description:
114	Alternative Constructor for DataTagged.
115	\param what - Input - A description of what this data object represents.
116	\param shape - Input - The shape of each data-point.
117	\param tags - Input - An vector of tags, one for each sample number.
118	\param data - The data values for each tag.
119	NB: no unit testing yet
120	*/
121	ESCRIPT_DLL_API
122	DataTagged(const FunctionSpace& what,
123	const DataArrayView::ShapeType &shape,
124	const TagListType& tags,
125	const ValueType& data);
126
127	/**
128	\brief
129	Copy Constructor for DataTagged.
130	Performs a deep copy from the given DataTagged object.
131	T
132	*/
133	ESCRIPT_DLL_API
134	DataTagged(const DataTagged& other);
135
136	/**
137	\brief
138	Copy Constructor for DataTagged.
139	Construct a DataTagged object from a DataConstant object.
140	The default value will be the value of the DataConstant object.
141	T
142	*/
143	ESCRIPT_DLL_API
144	DataTagged(const DataConstant& other);
145
146	/**
147	\brief
148	getSampleDataByTag
149
150	Description:
151	Return the data-point for the given tag. All of the data for the
152	sample will be visible via the returned pointer.
153
154	** This provides an interface into the data suitable for legacy C code.
155	** NB: need to do array bounds checking when accessing returned value!
156	T
157	*/
158	ESCRIPT_DLL_API
159	virtual
160	double*
161	getSampleDataByTag(int tag);
162
163	/**
164	\brief
165	Write the data as a string.
166	Writes out each tag, including the default, and the data-point which is
167	associated with each tag.
168	T
169	*/
170	ESCRIPT_DLL_API
171	virtual
172	std::string
173	toString() const;
174	/**
175	\brief
176	dumps the object into a netCDF file
177	*/
178	ESCRIPT_DLL_API
179	virtual
180	void
181	dump(const std::string fileName) const;
182
183	/**
184	\brief
185	Return the tag number associated with the given data-point number
186	according to the associated function space.
187	T
188	*/
189	ESCRIPT_DLL_API
190	virtual
191	int
192	getTagNumber(int dpno);
193
194	/**
195	\brief
196	getPointOffset
197
198	Description:
199	Return the offset to the given data-point value in the underlying
200	data vector.
201
202	\param sampleNo - Input - sample number.
203	\param dataPointNo - Input - data-point number.
204	T
205	*/
206	ESCRIPT_DLL_API
207	virtual
208	ValueType::size_type
209	getPointOffset(int sampleNo,
210	int dataPointNo) const;
211
212	/**
213	\brief
214	addTaggedValues
215
216	Description:
217	Add the given tags and values to this DataTagged object.
218	\param tagKeys - Input - A vector of integer tags.
219	\param values - Input - A vector of DataArrayViews. If this is empty
220	all tag values will be assigned a scalar data-point of value
221	0. If it contains one value all tag values will be assigned
222	this value. Otherwise consecutive tags will be assigned
223	consecutive values. If there is a mismatch between the
224	number of keys and the number of values an exception
225	will be generated.
226	T
227	*/
228	ESCRIPT_DLL_API
229	void
230	addTaggedValues(const TagListType& tagKeys,
231	const ValueListType& values);
232
233	/**
234	\brief
235	addTaggedValue
236
237	Description:
238	Add a single tag and value to this DataTagged object. If this tag already has
239	a value associated with it, setTaggedValue will be used to update this value.
240	\param tagKey - Input - Integer tag.
241	\param value - Input - Single DataArrayView value to be assigned to the tag.
242	T
243	*/
244	ESCRIPT_DLL_API
245	void
246	addTaggedValue(int tagKey,
247	const DataArrayView& value);
248
249	/**
250	\brief
251	setTaggedValues
252
253	Description:
254	Set the given tags to the given values in this DataTagged object.
255	\param tagKeys - Input - A vector of integer tag.
256	\param values - Input - A vector of DataArrayViews. If this is empty
257	all tag values will be assigned a scalar data-point of value
258	0. If it contains one value all tag values will be assigned
259	this value. Otherwise consecutive tags will be assigned
260	consecutive values. If there is a mismatch between the
261	number of keys and the number of values an exception
262	will be generated.
263	T
264	*/
265	ESCRIPT_DLL_API
266	void
267	setTaggedValues(const TagListType& tagKeys,
268	const ValueListType& values);
269
270	/**
271	\brief
272	setTaggedValue
273
274	Description:
275	Assign the given value to the given tag.
276	\param tagKey - Input - Integer tag.
277	\param value - Input - Single DataArrayView value to be assigned to the tag.
278	T
279	*/
280	ESCRIPT_DLL_API
281	virtual
282	void
283	setTaggedValue(int tagKey,
284	const DataArrayView& value);
285
286	/**
287	\brief
288	getDataPointByTag
289
290	Description:
291	Return data-point associated with the given tag as a DataArrayView.
292	\param tag - Input - Integer key.
293	T
294	*/
295	ESCRIPT_DLL_API
296	DataArrayView
297	getDataPointByTag(int tag) const;
298
299	/**
300	\brief
301	getDataPoint
302
303	Description:
304	Return the data-point specified by the given sample and data-point
305	numbers as a DataArrayView.
306	\param sampleNo - Input.
307	\param dataPointNo - Input.
308	T
309	*/
310	ESCRIPT_DLL_API
311	virtual
312	DataArrayView
313	getDataPoint(int sampleNo,
314	int dataPointNo);
315
316	/**
317	\brief
318	getData
319
320	Description:
321	Return pointer to the data
322	T
323	*/
324	ESCRIPT_DLL_API
325	const DataArrayView::ValueType::ElementType*
326	getData() const;
327
328	/**
329	\brief
330	getTagLookup
331
332	Description:
333	Return a reference to the tag offset lookup table.
334	T
335	*/
336	ESCRIPT_DLL_API
337	const DataMapType&
338	getTagLookup() const;
339
340	/**
341	\brief
342	isCurrentTag
343
344	Description:
345	Return true if the given tag exists within the DataTagged tag map.
346
347	*** NB: The DataTagged tag map does not necessarily coincide with the tag
348	keys in the associated function space.
349	T
350	*/
351	ESCRIPT_DLL_API
352	bool
353	isCurrentTag(int tag) const;
354
355	/**
356	\brief
357	getDefaultValue
358
359	Description:
360	Return the default value. This value is associated with any tag which
361	is not explicitly recorded in this DataTagged object's tag map.
362	T
363	*/
364	ESCRIPT_DLL_API
365	DataArrayView&
366	getDefaultValue();
367
368	ESCRIPT_DLL_API
369	const DataArrayView&
370	getDefaultValue() const;
371
372	/**
373	\brief
374	getLength
375
376	Description:
377	Return the total number of doubles stored for this DataTagged object.
378	T
379	*/
380	ESCRIPT_DLL_API
381	virtual
382	ValueType::size_type
383	getLength() const;
384
385	/**
386	\brief
387	getSlice
388
389	Description:
390	Factory method that returns a newly created DataTagged object generated
391	by taking the specified slice from this DataTagged object.
392	The caller is reponsible for managing the returned object.
393	T
394	*/
395	ESCRIPT_DLL_API
396	virtual
397	DataAbstract*
398	getSlice(const DataArrayView::RegionType& region) const;
399
400	/**
401	\brief
402	Slice Constructor for DataTagged.
403
404	Description:
405	Creates a DataTagged object which is the specified slice
406	from the given DataTagged object.
407	\param other - Input - DataTagged object to slice from.
408	\param region - Input - Region to slice.
409	T
410	*/
411	ESCRIPT_DLL_API
412	DataTagged(const DataTagged& other,
413	const DataArrayView::RegionType& region);
414
415	/**
416	\brief
417	setSlice
418
419	Description:
420	Copy the given Data object into the specified region in this object.
421	\param other - Input - Data object to copy from.
422	\param region - Input - Region to copy into (NB: must have same shape as other!).
423	T
424	*/
425	ESCRIPT_DLL_API
426	virtual
427	void
428	setSlice(const DataAbstract* other,
429	const DataArrayView::RegionType& region);
430
431	/**
432	\brief
433	Archive the underlying data values to the file referenced
434	by ofstream. A count of the number of values expected to be written
435	is provided as a cross-check.
436
437	The return value indicates success (0) or otherwise (1).
438	*/
439	ESCRIPT_DLL_API
440	int
441	archiveData(std::ofstream& archiveFile,
442	const DataArrayView::ValueType::size_type noValues) const;
443
444	/**
445	\brief
446	Extract the number of values specified by noValues from the file
447	referenced by ifstream to the underlying data structure.
448
449	The return value indicates success (0) or otherwise (1).
450	*/
451	ESCRIPT_DLL_API
452	int
453	extractData(std::ifstream& archiveFile,
454	const DataArrayView::ValueType::size_type noValues);
455
456	/**
457	\brief
458	Computes a symmetric matrix (A + AT) / 2
459
460	\param ev - Output - symmetric matrix
461
462	*/
463	ESCRIPT_DLL_API
464	virtual void
465	symmetric(DataAbstract* ev);
466
467	/**
468	\brief
469	Computes a nonsymmetric matrix (A - AT) / 2
470
471	\param ev - Output - nonsymmetric matrix
472
473	*/
474	ESCRIPT_DLL_API
475	virtual void
476	nonsymmetric(DataAbstract* ev);
477
478	/**
479	\brief
480	Computes the trace of a matrix
481
482	\param ev - Output - the trace of a matrix
483
484	*/
485	ESCRIPT_DLL_API
486	virtual void
487	trace(DataAbstract* ev, int axis_offset);
488
489	/**
490	\brief
491	swaps components axis0 and axis1
492
493	\param ev - Output - swapped components
494
495	*/
496	ESCRIPT_DLL_API
497	virtual void
498	swapaxes(DataAbstract* ev, int axis0, int axis1);
499
500	/**
501	\brief
502	Transpose each data point of this Data object around the given axis.
503
504	\param ev - Output - the transpose of a matrix
505
506	*/
507	ESCRIPT_DLL_API
508	virtual void
509	transpose(DataAbstract* ev, int axis_offset);
510
511	/**
512	\brief
513	solves the eigenvalue problem thisV=evV for the eigenvalues ev
514
515	\param ev - Output - eigenvalues in increasing order at each data point
516
517	*/
518	ESCRIPT_DLL_API
519	virtual void
520	eigenvalues(DataAbstract* ev);
521
522	/**
523	\brief
524	solves the eigenvalue problem thisV=evV for the eigenvalues ev and eigenvectors V
525
526	\param ev - Output - eigenvalues in increasing order at each data point
527	\param V - Output - corresponding eigenvectors. They are normalized such that their length is one
528	and the first nonzero component is positive.
529	\param tol - Input - eigenvalue with relative distance tol are treated as equal.
530
531	*/
532
533	ESCRIPT_DLL_API
534	virtual void
535	eigenvalues_and_eigenvectors(DataAbstract* ev,DataAbstract* V,const double tol=1.e-13);
536
537
538	protected:
539
540	private:
541
542	//
543	// The offset lookup table
544	DataMapType m_offsetLookup;
545
546	//
547	// the offset to the default value
548	static const int m_defaultValueOffset = 0;
549
550	//
551	// The actual data
552	ValueType m_data;
553
554	};
555
556	inline
557	bool
558	DataTagged::isCurrentTag(int tag) const
559	{
560	DataMapType::const_iterator pos(m_offsetLookup.find(tag));
561	return (pos!=m_offsetLookup.end());
562	}
563
564	inline
565	DataArrayView&
566	DataTagged::getDefaultValue()
567	{
568	// The default value is always the first value.
569	return getPointDataView();
570	}
571
572	inline
573	const DataArrayView&
574	DataTagged::getDefaultValue() const
575	{
576	// The default value is always the first value.
577	return getPointDataView();
578	}
579
580	inline
581	const DataArrayView::ValueType::ElementType*
582	DataTagged::getData() const
583	{
584	return &(m_data[0]);
585	}
586
587	inline
588	const DataTagged::DataMapType&
589	DataTagged::getTagLookup() const
590	{
591	return m_offsetLookup;
592	}
593
594	inline
595	DataArrayView::ValueType::size_type
596	DataTagged::getLength() const
597	{
598	return m_data.size();
599	}
600
601	} // end of namespace
602
603	#endif
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision