casacore
FunctionTraits.h
Go to the documentation of this file.
1//# FunctionTraits.h: Function data types for parameters and arguments
2//# Copyright (C) 2001,2002
3//# Associated Universities, Inc. Washington DC, USA.
4//#
5//# This library is free software; you can redistribute it and/or modify it
6//# under the terms of the GNU Library General Public License as published by
7//# the Free Software Foundation; either version 2 of the License, or (at your
8//# option) any later version.
9//#
10//# This library is distributed in the hope that it will be useful, but WITHOUT
11//# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12//# FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library General Public
13//# License for more details.
14//#
15//# You should have received a copy of the GNU Library General Public License
16//# along with this library; if not, write to the Free Software Foundation,
17//# Inc., 675 Massachusetts Ave, Cambridge, MA 02139, USA.
18//#
19//# Correspondence concerning AIPS++ should be addressed as follows:
20//# Internet email: aips2-request@nrao.edu.
21//# Postal address: AIPS++ Project Office
22//# National Radio Astronomy Observatory
23//# 520 Edgemont Road
24//# Charlottesville, VA 22903-2475 USA
25//#
26//# $Id$
27
28#ifndef SCIMATH_FUNCTIONTRAITS_H
29#define SCIMATH_FUNCTIONTRAITS_H
30
31//# Includes
32#include <casacore/casa/aips.h>
33#include <casacore/scimath/Mathematics/AutoDiff.h>
34#include <casacore/scimath/Mathematics/AutoDiffA.h>
35#include <casacore/scimath/Mathematics/AutoDiffX.h>
36
37namespace casacore { //# NAMESPACE CASACORE - BEGIN
38
39//
40// <summary> Function data types for parameters and arguments
41// </summary>
42// <use visibility=local>
43//
44// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="t">
45// </reviewed>
46
47// <prerequisite>
48// <li> <linkto class="Function">Function</linkto>
49// <li> <linkto class="AutoDiff">AutoDiff</linkto>
50// </prerequisite>
51
52// <etymology>
53// A trait is a characteristic feature. FunctionTraits defines relationships
54// between the data types of result, parameters and arguments of function
55// objects.
56// </etymology>
57//
58// <synopsis>
59// This templated class contains a number of typedefs that
60// describe the relationship between different numeric data types used for
61// the calculation of <src>Function</src> and the function parameter and
62// arguments.
63//
64// Its main use is to optimize the speed of the calculation of function
65// values and derivatives in the case of <src>AutoDiff</src> use and
66// manual calculation of derivatives, by allowing the data type of the
67// the arguments and/or parameters to be plain numeric in cases where the
68// derivatives wrt these are not needed.
69// To enable this, the following definitions are used for the use of the
70// Function template. Bear in mind that the Function operator is defined
71// as <src>result = f<T>(x; parameters)</src>.
72// <ol>
73// <li> Simple numeric type (Double, Complex, etc): result, parameters and
74// arguments: all the one defined templated type.
75// <li> <src>AutoDiff<T></src> indicates the calculation (either automatic or
76// with specialized implementations) of the result with a <src>T</src>
77// function value for <src>T</src> arg, and <src>AutoDiff<T></src>
78// parameters.
79// <li> <src>AutoDiffA</src> calculate form <src>AutoDiff<T></src>
80// arguments and parameters (note that either could be simple
81// values with zero derivatives)
82// <li> <src>AutoDiffX<T></src> : calculate only with respect to
83// the arguments the derivatives, by using <src>T</src>
84// parameters
85// </ol>
86// The following types are defined:
87// <dl>
88// <dt> <src>Type</src>
89// <dd> The template argument
90// <dt> <src>BaseType</src>
91// <dd> One down in the template hierarchy if possible (e.g. <src>Double</src>
92// for <src>AutoDiff<Double></src>)
93// <dt> <src>NumericType</src>
94// <dd> Ultimate numeric type (e.g. <src>Double</src> for
95// <src>AutoDiff<AutoDiff<Double> ></src>
96// <dt> <src>ParamType</src>
97// <dd> Type used for parameters
98// <dt> <src>ArgType</src>
99// <dd> Type used for arguments
100// <dt> <src>DiffType</src>
101// <dd> The default differentiation type (e.g. <src>AutoDiff<Double></src>
102// for <src>AutoDiff<Double></src>)
103// <dt> <src>getValue()</src>
104// <dd> get the value of a simple numeric or of an <src>AutoDiff</src>
105// <dt> <src>setValue()</src>
106// <dd> set the value of a simple numeric or of an <src>AutoDiff</src>
107// </dl>
108//
109// The specializations are done in such a way that higher order
110// derivatives (e.g. <src>AutoDiff<AutoDiff<Double> ></src>) are catered for.
111//
112// Note that the class names in the following definitions are extended with
113// some individual id (like <src>_PA</src>): do not use them in programming,
114// they are only necessary for the <src>cxx2html</src> interpreter)
115//
116// This class is implemented as a number of specializations for the
117// following data types.
118// <ul>
119// <li> <src>T</src>
120// <li> <src>AutoDiff<T></src>
121// <li> <src>AutoDiffA<T></src>
122// <li> <src>AutoDiffX<T></src>
123// </ul>
124// </synopsis>
125//
126// <example>
127// See the <linkto class=Function>Function</linkto> class code.
128// </example>
129//
130// <motivation>
131// To keep the Function class single templated
132// </motivation>
133//
134// <todo asof="2002/06/19">
135// <li> Additional <src>AutoDiff*</src> classes if and when needed
136// </todo>
137//
138
139template <class T> class FunctionTraits {
140public:
141 // Actual template type
142 typedef T Type;
143 // Template base type
144 typedef T BaseType;
145 // Numeric type of template
146 typedef T NumericType;
147 // Type for parameters
148 typedef T ParamType;
149 // Type for arguments
150 typedef T ArgType;
151 // Default type for differentiation
153 // Get the value
154 static const T &getValue(const T &in) { return in; }
155 // Set a value (and possible derivative)
156 static void setValue(T &out, const T &val, const uInt,
157 const uInt) { out = val; }
158};
159
160//# Following are specializations. Naming only for documentation
161//# purposes (a problem with cxx2html)
162
163#define FunctionTraits_P FunctionTraits
164
165// <summary> FunctionTraits specialization for AutoDiff
166// </summary>
167
168template <class T> class FunctionTraits_P<AutoDiff<T> > {
169public:
170 // Actual template type
172 // Template base type
173 typedef T BaseType;
174 // Template numeric type
175 typedef typename FunctionTraits_P<T>::NumericType NumericType;
176 // Type for parameters
178 // Type for arguments
179 typedef T ArgType;
180 // Default type for differentiation
182 // Get the value
183 static const T &getValue(const Type &in) {
184 return FunctionTraits<T>::getValue(in.value()); }
185 // Set a value (and possible derivative)
186 static void setValue(Type &out, const T &val, const uInt nder,
187 const uInt i) { out = Type(val, nder, i); }
188};
189
190#undef FunctionTraits_P
191
192#define FunctionTraits_PA FunctionTraits
193
194// <summary> FunctionTraits specialization for AutoDiffA
195// </summary>
196
197template <class T> class FunctionTraits_PA<AutoDiffA<T> > {
198public:
199 // Actual template type
201 // Template base type
202 typedef T BaseType;
203 // Template numeric type
204 typedef typename FunctionTraits_PA<T>::NumericType NumericType;
205 // Type for parameters
207 // Type for arguments
209 // Default type for differentiation
211 // Get the value
212 static const T &getValue(const Type &in) {
213 return FunctionTraits<T>::getValue(in.value()); }
214 // Set a value (and possible derivative)
215 static void setValue(Type &out, const T &val, const uInt nder,
216 const uInt i) { out = Type(val, nder, i); }
217};
218
219#undef FunctionTraits_PA
220
221#define FunctionTraits_PX FunctionTraits
222
223// <summary> FunctionTraits specialization for AutoDiffX
224// </summary>
225
226template <class T> class FunctionTraits_PX<AutoDiffX<T> > {
227public:
228 // Actual template type
230 // Template base type
231 typedef T BaseType;
232 // Template numeric type
233 typedef typename FunctionTraits_PX<T>::NumericType NumericType;
234 // Type for parameters
235 typedef T ParamType;
236 // Type for arguments
238 // Default type for differentiation
240 // Get the value
241 static const T &getValue(const Type &in) {
242 return FunctionTraits<T>::getValue(in.value()); }
243 // Set a value (and possible derivative)
244 static void setValue(Type &out, const T &val, const uInt nder,
245 const uInt i) { out = Type(val, nder, i); }
246};
247
248#undef FunctionTraits_PX
249
250
251} //# NAMESPACE CASACORE - END
252
253#endif
#define FunctionTraits_PA
#define FunctionTraits_P
#define FunctionTraits_PX
T & value()
Returns the value of the function.
Definition: AutoDiff.h:313
AutoDiffA< T > ArgType
Type for arguments.
static void setValue(Type &out, const T &val, const uInt nder, const uInt i)
Set a value (and possible derivative)
static const T & getValue(const Type &in)
Get the value.
AutoDiffA< T > DiffType
Default type for differentiation.
AutoDiffA< T > Type
Actual template type.
AutoDiffA< T > ParamType
Type for parameters.
FunctionTraits_PA< T >::NumericType NumericType
Template numeric type.
static const T & getValue(const Type &in)
Get the value.
AutoDiffX< T > Type
Actual template type.
AutoDiffX< T > DiffType
Default type for differentiation.
FunctionTraits_PX< T >::NumericType NumericType
Template numeric type.
AutoDiffX< T > ArgType
Type for arguments.
static void setValue(Type &out, const T &val, const uInt nder, const uInt i)
Set a value (and possible derivative)
AutoDiff< T > Type
Actual template type.
static void setValue(Type &out, const T &val, const uInt nder, const uInt i)
Set a value (and possible derivative)
AutoDiff< T > DiffType
Default type for differentiation.
static const T & getValue(const Type &in)
Get the value.
AutoDiff< T > ParamType
Type for parameters.
FunctionTraits_P< T >::NumericType NumericType
Template numeric type.
static void setValue(T &out, const T &val, const uInt, const uInt)
Set a value (and possible derivative)
AutoDiff< T > DiffType
Default type for differentiation.
T ArgType
Type for arguments.
T Type
Actual template type.
T BaseType
Template base type.
T ParamType
Type for parameters.
T NumericType
Numeric type of template.
static const T & getValue(const T &in)
Get the value.
this file contains all the compiler specific defines
Definition: mainpage.dox:28
unsigned int uInt
Definition: aipstype.h:51