escript/src/DataTagged.h


/* $Id$ */

/*******************************************************
 *
 *           Copyright 2003-2007 by ACceSS MNRF
 *       Copyright 2007 by University of Queensland
 *
 *                http://esscc.uq.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
    sets all values to zero
  */
  ESCRIPT_DLL_API
  virtual
  void
  setToZero();

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