escript/src/DataConstant.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_DataConstant_20040323_H
#define escript_DataConstant_20040323_H
#include "system_dep.h"

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

#include <boost/python/numeric.hpp>

namespace escript {

/**
   \brief
   DataConstant stores a single data point which represents the entire
   function space.

   Description:
   DataConstant stores a single data point which represents the entire
   function space.
*/
class DataConstant : public DataAbstract  {

 public:

  /**
     \brief
     Constructor for DataConstant objects.

     Description:
     Constructor for DataConstant objects.

     \param value - Input - Data value for a single point.
     \param what - Input - A description of what this data object represents.
  */
  ESCRIPT_DLL_API
  DataConstant(const boost::python::numeric::array& value,
               const FunctionSpace& what);

  /**
     \brief
     Copy constructor. Performs a deep copy.
  */
  ESCRIPT_DLL_API
  DataConstant(const DataConstant& other);

  /**
     \brief
     Alternative constructor for DataConstant objects.

     Description:
     Alternative Constructor for DataConstant objects.
     \param value - Input - Data value for a single point.
     \param what - Input - A description of what this data object represents.
  */
  ESCRIPT_DLL_API
  DataConstant(const DataArrayView& value,
               const FunctionSpace& what);

  /**
     \brief
     Alternative constructor for DataConstant objects.

     Description:
     Alternative Constructor for DataConstant objects.
     \param other - Input - Data object to copy from.
     \param region - Input - region to copy.
  */
  ESCRIPT_DLL_API
  DataConstant(const DataConstant& other,
               const DataArrayView::RegionType& region);

  /**
     \brief
     Alternative constructor for DataConstant objects.

     Description:
     Alternative Constructor for DataConstant objects.
     \param what - Input - A description of what this data object represents.
     \param shape - Input - the shape of each data-point.
     \param data - the data values for each data-point.
  */
  ESCRIPT_DLL_API
  DataConstant(const FunctionSpace& what,
               const DataArrayView::ShapeType &shape,
               const DataArrayView::ValueType &data);

  /**
     \brief
     Write the data as a string.
  */
  ESCRIPT_DLL_API
  std::string
  toString() const;

  /**
     \brief
     Return the offset for the given sample. This is a somewhat artificial notion
     but returns the offset in bytes for the given point into the container
     holding the point data. Only really necessary to avoid many DataArrayView
     objects.
     \param sampleNo - Input - sample number.
     \param dataPointNo - Input - data point number for the sample.
   */
  ESCRIPT_DLL_API
  virtual
  DataArrayView::ValueType::size_type
  getPointOffset(int sampleNo,
                 int dataPointNo) const;

  /**
     \brief
     Return a view into the data for the data point specified.
     \param sampleNo - Input - sample number.
     \param dataPointNo - Input - data point number for the sample.
  */
  ESCRIPT_DLL_API
  virtual
  DataArrayView
  getDataPoint(int sampleNo,
               int dataPointNo);

  /**
     \brief
     Return the number of doubles stored for the Data object.
  */
  ESCRIPT_DLL_API
  virtual
  DataArrayView::ValueType::size_type
  getLength() const;

  /**
     \brief
     Factory method that returns a newly created DataConstant object
     sliced from the specified region of this object.
     The caller is reponsible for managing the object created.
     \param region - Input - region to slice from this object.
  */
  ESCRIPT_DLL_API
  virtual
  DataAbstract*
  getSlice(const DataArrayView::RegionType& region) const;

  /**
     \brief
     Copy the specified region from the given value.
     \param value - Input - Data object to copy from.
     \param region - Input - Region to copy.
  */
  ESCRIPT_DLL_API
  virtual
  void
  setSlice(const DataAbstract* value,
           const DataArrayView::RegionType& region);

  /**
     \brief
     Reshape the data point if the data point is currently rank 0.
     The original data point value is used for all values of the new
     data point.
  */
  ESCRIPT_DLL_API
  void
  reshapeDataPoint(const DataArrayView::ShapeType& shape);

  /**
    \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 - trace of matrix

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

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

     \param ev - Output - transpose of matrix

  */
  ESCRIPT_DLL_API
  virtual void
  transpose(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
     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 actual data
  DataArrayView::ValueType m_data;

};

} // end of namespace
#endif
1	//$Id$
2	/*
3	************************************************************
4	* Copyright 2006 by ACcESS MNRF *
5	* *
6	* http://www.access.edu.au *
7	* Primary Business: Queensland, Australia *
8	* Licensed under the Open Software License version 3.0 *
9	* http://www.opensource.org/licenses/osl-3.0.php *
10	* *
11	************************************************************
12	*/
13
14	#if !defined escript_DataConstant_20040323_H
15	#define escript_DataConstant_20040323_H
16	#include "system_dep.h"
17
18	#include "DataAbstract.h"
19	#include "DataArrayView.h"
20
21	#include <boost/python/numeric.hpp>
22
23	namespace escript {
24
25	/**
26	\brief
27	DataConstant stores a single data point which represents the entire
28	function space.
29
30	Description:
31	DataConstant stores a single data point which represents the entire
32	function space.
33	*/
34	class DataConstant : public DataAbstract {
35
36	public:
37
38	/**
39	\brief
40	Constructor for DataConstant objects.
41
42	Description:
43	Constructor for DataConstant objects.
44
45	\param value - Input - Data value for a single point.
46	\param what - Input - A description of what this data object represents.
47	*/
48	ESCRIPT_DLL_API
49	DataConstant(const boost::python::numeric::array& value,
50	const FunctionSpace& what);
51
52	/**
53	\brief
54	Copy constructor. Performs a deep copy.
55	*/
56	ESCRIPT_DLL_API
57	DataConstant(const DataConstant& other);
58
59	/**
60	\brief
61	Alternative constructor for DataConstant objects.
62
63	Description:
64	Alternative Constructor for DataConstant objects.
65	\param value - Input - Data value for a single point.
66	\param what - Input - A description of what this data object represents.
67	*/
68	ESCRIPT_DLL_API
69	DataConstant(const DataArrayView& value,
70	const FunctionSpace& what);
71
72	/**
73	\brief
74	Alternative constructor for DataConstant objects.
75
76	Description:
77	Alternative Constructor for DataConstant objects.
78	\param other - Input - Data object to copy from.
79	\param region - Input - region to copy.
80	*/
81	ESCRIPT_DLL_API
82	DataConstant(const DataConstant& other,
83	const DataArrayView::RegionType& region);
84
85	/**
86	\brief
87	Alternative constructor for DataConstant objects.
88
89	Description:
90	Alternative Constructor for DataConstant objects.
91	\param what - Input - A description of what this data object represents.
92	\param shape - Input - the shape of each data-point.
93	\param data - the data values for each data-point.
94	*/
95	ESCRIPT_DLL_API
96	DataConstant(const FunctionSpace& what,
97	const DataArrayView::ShapeType &shape,
98	const DataArrayView::ValueType &data);
99
100	/**
101	\brief
102	Write the data as a string.
103	*/
104	ESCRIPT_DLL_API
105	std::string
106	toString() const;
107
108	/**
109	\brief
110	Return the offset for the given sample. This is a somewhat artificial notion
111	but returns the offset in bytes for the given point into the container
112	holding the point data. Only really necessary to avoid many DataArrayView
113	objects.
114	\param sampleNo - Input - sample number.
115	\param dataPointNo - Input - data point number for the sample.
116	*/
117	ESCRIPT_DLL_API
118	virtual
119	DataArrayView::ValueType::size_type
120	getPointOffset(int sampleNo,
121	int dataPointNo) const;
122
123	/**
124	\brief
125	Return a view into the data for the data point specified.
126	\param sampleNo - Input - sample number.
127	\param dataPointNo - Input - data point number for the sample.
128	*/
129	ESCRIPT_DLL_API
130	virtual
131	DataArrayView
132	getDataPoint(int sampleNo,
133	int dataPointNo);
134
135	/**
136	\brief
137	Return the number of doubles stored for the Data object.
138	*/
139	ESCRIPT_DLL_API
140	virtual
141	DataArrayView::ValueType::size_type
142	getLength() const;
143
144	/**
145	\brief
146	Factory method that returns a newly created DataConstant object
147	sliced from the specified region of this object.
148	The caller is reponsible for managing the object created.
149	\param region - Input - region to slice from this object.
150	*/
151	ESCRIPT_DLL_API
152	virtual
153	DataAbstract*
154	getSlice(const DataArrayView::RegionType& region) const;
155
156	/**
157	\brief
158	Copy the specified region from the given value.
159	\param value - Input - Data object to copy from.
160	\param region - Input - Region to copy.
161	*/
162	ESCRIPT_DLL_API
163	virtual
164	void
165	setSlice(const DataAbstract* value,
166	const DataArrayView::RegionType& region);
167
168	/**
169	\brief
170	Reshape the data point if the data point is currently rank 0.
171	The original data point value is used for all values of the new
172	data point.
173	*/
174	ESCRIPT_DLL_API
175	void
176	reshapeDataPoint(const DataArrayView::ShapeType& shape);
177
178	/**
179	\brief
180	Archive the underlying data values to the file referenced
181	by ofstream. A count of the number of values expected to be written
182	is provided as a cross-check.
183
184	The return value indicates success (0) or otherwise (1).
185	*/
186	ESCRIPT_DLL_API
187	int
188	archiveData(std::ofstream& archiveFile,
189	const DataArrayView::ValueType::size_type noValues) const;
190
191	/**
192	\brief
193	Extract the number of values specified by noValues from the file
194	referenced by ifstream to the underlying data structure.
195
196	The return value indicates success (0) or otherwise (1).
197	*/
198	ESCRIPT_DLL_API
199	int
200	extractData(std::ifstream& archiveFile,
201	const DataArrayView::ValueType::size_type noValues);
202
203	/**
204	\brief
205	Computes a symmetric matrix (A + AT) / 2
206
207	\param ev - Output - symmetric matrix
208
209	*/
210	ESCRIPT_DLL_API
211	virtual void
212	symmetric(DataAbstract* ev);
213
214	/**
215	\brief
216	Computes a nonsymmetric matrix (A - AT) / 2
217
218	\param ev - Output - nonsymmetric matrix
219
220	*/
221	ESCRIPT_DLL_API
222	virtual void
223	nonsymmetric(DataAbstract* ev);
224
225	/**
226	\brief
227	Computes the trace of a matrix
228
229	\param ev - Output - trace of matrix
230
231	*/
232	ESCRIPT_DLL_API
233	virtual void
234	trace(DataAbstract* ev, int axis_offset);
235
236	/**
237	\brief
238	Transpose each data point of this Data object around the given axis.
239
240	\param ev - Output - transpose of matrix
241
242	*/
243	ESCRIPT_DLL_API
244	virtual void
245	transpose(DataAbstract* ev, int axis_offset);
246
247	/**
248	\brief
249	swaps components axis0 and axis1
250
251	\param ev - Output - swapped components
252
253	*/
254	ESCRIPT_DLL_API
255	virtual void
256	swapaxes(DataAbstract* ev, int axis0, int axis1);
257
258
259	/**
260	\brief
261	solves the eigenvalue problem thisV=evV for the eigenvalues ev
262
263	\param ev - Output - eigenvalues in increasing order at each data point
264
265	*/
266	ESCRIPT_DLL_API
267	virtual void
268	eigenvalues(DataAbstract* ev);
269
270	/**
271	\brief
272	solves the eigenvalue problem thisV=evV for the eigenvalues ev and eigenvectors V
273
274	\param ev - Output - eigenvalues in increasing order at each data point
275	\param V - Output - corresponding eigenvectors. They are normalized such that their length is one
276	and the first nonzero component is positive.
277	\param tol - Input - eigenvalue with relative distance tol are treated as equal.
278
279	*/
280
281	ESCRIPT_DLL_API
282	virtual void
283	eigenvalues_and_eigenvectors(DataAbstract* ev,DataAbstract* V,const double tol=1.e-13);
284
285
286	protected:
287
288	private:
289	//
290	// the actual data
291	DataArrayView::ValueType m_data;
292
293	};
294
295	} // end of namespace
296	#endif
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision