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	jgs	82	// $Id$
2	jgs	121
3			/*
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	jgs	121
15	jgs	82	#if !defined escript_DataTagged_20040615_H
16			#define escript_DataTagged_20040615_H
17	woo409	757	#include "system_dep.h"
18	jgs	82
19	jgs	474	#include "DataAbstract.h"
20			#include "DataArrayView.h"
21	jgs	82
22			#include <vector>
23			#include <map>
24
25			namespace escript {
26
27			class DataConstant;
28
29			/**
30			\brief
31	jgs	496	Simulates a full dataset accessible via sampleNo and dataPointNo.
32	jgs	82
33			Description:
34	jgs	496	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	jgs	82	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	jgs	119	//
45	jgs	496	// Types for the lists of tags and values.
46	jgs	121	typedef std::vector<int> TagListType;
47	jgs	82	typedef std::vector<DataArrayView> ValueListType;
48	jgs	121	typedef DataArrayView::ValueType ValueType;
49	jgs	82
50			//
51	jgs	496	// Map from a tag to an offset into the data array.
52	jgs	82	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	jgs	509	the default data-point is a scalar data-point with value 0.0, and no other
61			tag values are stored.
62	jgs	507	T
63	jgs	82	*/
64	woo409	757	ESCRIPT_DLL_API
65	jgs	82	DataTagged();
66
67			/**
68			\brief
69			Constructor for DataTagged.
70
71			Description:
72			Constructor for DataTagged.
73	jgs	509	\param tagKeys - Input - A vector of integer tags.
74	jgs	82	\param values - Input - A vector of DataArrayViews. If this is empty
75	jgs	509	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	jgs	496	will be generated.
81	jgs	82	\param defaultValue - Input - Value returned if a requested tag doesn't exist.
82			\param what - Input - A description of what this data represents.
83	jgs	507	T
84	jgs	82	*/
85	woo409	757	ESCRIPT_DLL_API
86	jgs	82	DataTagged(const TagListType& tagKeys,
87			const ValueListType& values,
88			const DataArrayView& defaultValue,
89			const FunctionSpace& what);
90
91			/**
92			\brief
93	jgs	496	Alternative Constructor for DataTagged.
94	jgs	119
95			Description:
96	jgs	496	Alternative Constructor for DataTagged.
97	jgs	119	\param what - Input - A description of what this data object represents.
98	jgs	496	\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	jgs	535	NB: no unit testing yet
102	jgs	119	*/
103	woo409	757	ESCRIPT_DLL_API
104	jgs	119	DataTagged(const FunctionSpace& what,
105			const DataArrayView::ShapeType &shape,
106			const int tags[],
107	jgs	500	const ValueType& data);
108	jgs	119
109			/**
110			\brief
111	woo409	757	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	jgs	496	Copy Constructor for DataTagged.
130	jgs	82	Performs a deep copy from the given DataTagged object.
131	jgs	507	T
132	jgs	82	*/
133	woo409	757	ESCRIPT_DLL_API
134	jgs	82	DataTagged(const DataTagged& other);
135
136			/**
137			\brief
138	jgs	496	Copy Constructor for DataTagged.
139	jgs	509	Construct a DataTagged object from a DataConstant object.
140			The default value will be the value of the DataConstant object.
141	jgs	507	T
142	jgs	82	*/
143	woo409	757	ESCRIPT_DLL_API
144	jgs	82	DataTagged(const DataConstant& other);
145
146			/**
147			\brief
148			getSampleDataByTag
149
150			Description:
151	jgs	496	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	jgs	507	** NB: need to do array bounds checking when accessing returned value!
156			T
157	jgs	82	*/
158	woo409	757	ESCRIPT_DLL_API
159	jgs	82	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	jgs	507	T
169	jgs	82	*/
170	woo409	757	ESCRIPT_DLL_API
171	jgs	82	virtual
172			std::string
173			toString() const;
174	gross	950	/**
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	jgs	82
183			/**
184			\brief
185	jgs	496	Return the tag number associated with the given data-point number
186			according to the associated function space.
187	jgs	507	T
188	jgs	149	*/
189	woo409	757	ESCRIPT_DLL_API
190	jgs	149	virtual
191			int
192			getTagNumber(int dpno);
193
194			/**
195			\brief
196	jgs	82	getPointOffset
197
198			Description:
199	jgs	496	Return the offset to the given data-point value in the underlying
200			data vector.
201	jgs	82
202			\param sampleNo - Input - sample number.
203			\param dataPointNo - Input - data-point number.
204	jgs	507	T
205			*/
206	woo409	757	ESCRIPT_DLL_API
207	jgs	82	virtual
208	jgs	121	ValueType::size_type
209	jgs	82	getPointOffset(int sampleNo,
210			int dataPointNo) const;
211
212			/**
213			\brief
214			addTaggedValues
215
216			Description:
217	jgs	509	Add the given tags and values to this DataTagged object.
218	jgs	507	\param tagKeys - Input - A vector of integer tags.
219	jgs	82	\param values - Input - A vector of DataArrayViews. If this is empty
220	jgs	509	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	jgs	507	T
227	jgs	82	*/
228	woo409	757	ESCRIPT_DLL_API
229	jgs	82	void
230			addTaggedValues(const TagListType& tagKeys,
231			const ValueListType& values);
232
233			/**
234			\brief
235			addTaggedValue
236
237			Description:
238	jgs	121	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	jgs	509	\param tagKey - Input - Integer tag.
241	jgs	121	\param value - Input - Single DataArrayView value to be assigned to the tag.
242	jgs	507	T
243	jgs	82	*/
244	woo409	757	ESCRIPT_DLL_API
245	jgs	82	void
246			addTaggedValue(int tagKey,
247			const DataArrayView& value);
248
249			/**
250			\brief
251			setTaggedValues
252
253			Description:
254	jgs	509	Set the given tags to the given values in this DataTagged object.
255			\param tagKeys - Input - A vector of integer tag.
256	jgs	82	\param values - Input - A vector of DataArrayViews. If this is empty
257	jgs	509	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	jgs	507	T
264	jgs	82	*/
265	woo409	757	ESCRIPT_DLL_API
266	jgs	82	void
267			setTaggedValues(const TagListType& tagKeys,
268			const ValueListType& values);
269
270			/**
271			\brief
272			setTaggedValue
273
274			Description:
275	jgs	509	Assign the given value to the given tag.
276			\param tagKey - Input - Integer tag.
277	jgs	82	\param value - Input - Single DataArrayView value to be assigned to the tag.
278	jgs	507	T
279	jgs	82	*/
280	woo409	757	ESCRIPT_DLL_API
281	jgs	82	virtual
282			void
283			setTaggedValue(int tagKey,
284			const DataArrayView& value);
285
286			/**
287			\brief
288			getDataPointByTag
289
290			Description:
291	jgs	509	Return data-point associated with the given tag as a DataArrayView.
292	jgs	82	\param tag - Input - Integer key.
293	jgs	507	T
294	jgs	82	*/
295	woo409	757	ESCRIPT_DLL_API
296	jgs	82	DataArrayView
297			getDataPointByTag(int tag) const;
298
299			/**
300			\brief
301			getDataPoint
302
303			Description:
304	jgs	509	Return the data-point specified by the given sample and data-point
305			numbers as a DataArrayView.
306	jgs	82	\param sampleNo - Input.
307			\param dataPointNo - Input.
308	jgs	507	T
309	jgs	82	*/
310	woo409	757	ESCRIPT_DLL_API
311	jgs	82	virtual
312			DataArrayView
313			getDataPoint(int sampleNo,
314			int dataPointNo);
315
316			/**
317	gross	983	\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	gross	984	getData() const;
327	gross	983
328			/**
329	jgs	82	\brief
330			getTagLookup
331
332			Description:
333			Return a reference to the tag offset lookup table.
334	jgs	507	T
335	jgs	82	*/
336	woo409	757	ESCRIPT_DLL_API
337	jgs	82	const DataMapType&
338			getTagLookup() const;
339
340			/**
341			\brief
342			isCurrentTag
343
344			Description:
345	jgs	496	Return true if the given tag exists within the DataTagged tag map.
346
347	jgs	509	*** NB: The DataTagged tag map does not necessarily coincide with the tag
348	jgs	496	keys in the associated function space.
349	jgs	507	T
350			*/
351	woo409	757	ESCRIPT_DLL_API
352	jgs	82	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	jgs	496	is not explicitly recorded in this DataTagged object's tag map.
362	jgs	507	T
363	jgs	82	*/
364	woo409	757	ESCRIPT_DLL_API
365	jgs	82	DataArrayView&
366			getDefaultValue();
367
368	woo409	757	ESCRIPT_DLL_API
369	jgs	82	const DataArrayView&
370			getDefaultValue() const;
371
372			/**
373			\brief
374			getLength
375
376			Description:
377	jgs	509	Return the total number of doubles stored for this DataTagged object.
378	jgs	507	T
379	jgs	82	*/
380	woo409	757	ESCRIPT_DLL_API
381	jgs	82	virtual
382			ValueType::size_type
383			getLength() const;
384
385			/**
386			\brief
387			getSlice
388
389			Description:
390	jgs	513	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	jgs	535	T
394	jgs	82	*/
395	woo409	757	ESCRIPT_DLL_API
396	jgs	82	virtual
397			DataAbstract*
398			getSlice(const DataArrayView::RegionType& region) const;
399
400			/**
401			\brief
402	jgs	513	Slice Constructor for DataTagged.
403	jgs	82
404			Description:
405	jgs	513	Creates a DataTagged object which is the specified slice
406	jgs	519	from the given DataTagged object.
407			\param other - Input - DataTagged object to slice from.
408			\param region - Input - Region to slice.
409	jgs	535	T
410	jgs	82	*/
411	woo409	757	ESCRIPT_DLL_API
412	jgs	513	DataTagged(const DataTagged& other,
413			const DataArrayView::RegionType& region);
414
415			/**
416			\brief
417			setSlice
418
419			Description:
420	jgs	519	Copy the given Data object into the specified region in this object.
421	jgs	513	\param other - Input - Data object to copy from.
422	jgs	519	\param region - Input - Region to copy into (NB: must have same shape as other!).
423	jgs	535	T
424	jgs	513	*/
425	woo409	757	ESCRIPT_DLL_API
426	jgs	82	virtual
427			void
428	jgs	513	setSlice(const DataAbstract* other,
429	jgs	82	const DataArrayView::RegionType& region);
430
431			/**
432			\brief
433	jgs	509	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	jgs	123
437	jgs	509	The return value indicates success (0) or otherwise (1).
438	jgs	123	*/
439	woo409	757	ESCRIPT_DLL_API
440	jgs	123	int
441			archiveData(std::ofstream& archiveFile,
442			const DataArrayView::ValueType::size_type noValues) const;
443
444			/**
445	jgs	509	\brief
446			Extract the number of values specified by noValues from the file
447			referenced by ifstream to the underlying data structure.
448	jgs	123
449	jgs	509	The return value indicates success (0) or otherwise (1).
450	jgs	123	*/
451	woo409	757	ESCRIPT_DLL_API
452	jgs	123	int
453			extractData(std::ifstream& archiveFile,
454			const DataArrayView::ValueType::size_type noValues);
455
456	gross	580	/**
457			\brief
458	ksteube	775	Computes a symmetric matrix (A + AT) / 2
459
460			\param ev - Output - symmetric matrix
461
462			*/
463	gross	800	ESCRIPT_DLL_API
464	ksteube	775	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	gross	800	ESCRIPT_DLL_API
475	ksteube	775	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	gross	800	ESCRIPT_DLL_API
486	ksteube	775	virtual void
487	gross	800	trace(DataAbstract* ev, int axis_offset);
488	ksteube	775
489			/**
490			\brief
491	gross	804	swaps components axis0 and axis1
492	gross	800
493			\param ev - Output - swapped components
494
495			*/
496			ESCRIPT_DLL_API
497			virtual void
498	gross	804	swapaxes(DataAbstract* ev, int axis0, int axis1);
499	gross	800
500			/**
501			\brief
502	ksteube	775	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	gross	800	ESCRIPT_DLL_API
508	ksteube	775	virtual void
509			transpose(DataAbstract* ev, int axis_offset);
510
511			/**
512			\brief
513	gross	580	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	woo409	757	ESCRIPT_DLL_API
519	gross	580	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	woo409	757	ESCRIPT_DLL_API
534	gross	580	virtual void
535			eigenvalues_and_eigenvectors(DataAbstract* ev,DataAbstract* V,const double tol=1.e-13);
536
537
538	jgs	82	protected:
539
540			private:
541
542			//
543			// The offset lookup table
544			DataMapType m_offsetLookup;
545
546			//
547	jgs	496	// the offset to the default value
548	jgs	119	static const int m_defaultValueOffset = 0;
549
550			//
551	jgs	82	// The actual data
552	jgs	121	ValueType m_data;
553	jgs	82
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	jgs	496	inline
581	gross	983	const DataArrayView::ValueType::ElementType*
582			DataTagged::getData() const
583			{
584			return &(m_data[0]);
585			}
586
587			inline
588	jgs	496	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	jgs	82	} // end of namespace
602
603			#endif
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision