casacore
AutoDiffX.h
Go to the documentation of this file.
1 //# AutoDiffX.h: An automatic differentiating class for functions
2 //# Copyright (C) 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 //#
27 //# $Id$
28 
29 #ifndef SCIMATH_AUTODIFFX_H
30 #define SCIMATH_AUTODIFFX_H
31 
32 //# Includes
33 #include <casacore/casa/aips.h>
34 #include <casacore/casa/Arrays/ArrayFwd.h>
35 #include <casacore/scimath/Mathematics/AutoDiff.h>
36 
37 namespace casacore { //# NAMESPACE CASACORE - BEGIN
38 
39 // <summary>
40 // Class that computes partial derivatives by automatic differentiation.
41 // </summary>
42 //
43 // <use visibility=export>
44 //
45 // <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="tAutoDiff.cc" demos="dAutoDiff.cc">
46 // </reviewed>
47 //
48 // <prerequisite>
49 // <li> <linkto class=AutoDiff>AutoDiff</linkto>
50 // </prerequisite>
51 //
52 // <etymology>
53 // Class that computes partial derivatives by automatic differentiation, thus
54 // AutoDiff.
55 // </etymology>
56 //
57 // <synopsis>
58 // AutoDiffX is an <linkto class=AutoDiff>AutoDiff</linkto>. It is used
59 // to be able to distinguish between two template incarnations; e.g. to
60 // have one or more specializations, in addition to the general template
61 // version.
62 // </synopsis>
63 //
64 // <example>
65 // See for an extensive example the demo program dAutoDiff. It is
66 // based on the example given in the <linkto class=AutoDiff>AutoDiff</linkto>
67 // class, and shows how to have both an automatic and a specific version
68 // of a function object.
69 // <srcblock>
70 // // The function, with fixed parameters a,b:
71 // template <class T> class f {
72 // public:
73 // T operator()(const T& x) { return a_p*a_p*a_p*b_p*b_p*x; }
74 // void set(const T& a, const T& b) { a_p = a; b_p = b; }
75 // private:
76 // T a_p;
77 // T b_p;
78 // };
79 // // The specialized function
80 // template <> class f<AutoDiffX<Double> > {
81 // public:
82 // T operator()(const T& x) { return a_p*a_p*a_p*b_p*b_p*x; }
83 // void set(const T& a, const T& b) { a_p = a; b_p = b; }
84 // private:
85 // T a_p;
86 // T b_p;
87 // };
88 // // Call it with different template arguments:
89 // AutoDiff<Double> a1(2,2,0), b1(3,2,1), x1(7);
90 // f<AutoDiff<Double> > f1; f1.set(a1, b1);
91 // cout << "Diff a,b: " << f1(x1) << endl;
92 //
93 // f<AutoDiffX<Double> > f12; f12.set(a1, b1);
94 // cout << "Same....: " << f12(x1) << endl;
95 //
96 // // Result will be:
97 // // Diff a,b: (504, [756, 336])
98 // // Same....: (504, [756, 336])
99 //
100 // // It needed the template instantiations definitions:
101 // template class f<AutoDiff<Double> >;
102 // </srcblock>
103 // </example>
104 //
105 // <motivation>
106 // The class was created to enable separate calculations of the same
107 // function.
108 // </motivation>
109 //
110 // <templating arg=T>
111 // <li> any class that has the standard mathematical and comparisons
112 // defined
113 // </templating>
114 //
115 // <todo asof="2001/06/07">
116 // <li> Nothing I know
117 // </todo>
118 
119 template <class T> class AutoDiffX : public AutoDiff<T> {
120  public:
121  //# Constructors
122  // Construct a constant with a value of zero. Zero derivatives.
123  AutoDiffX() : AutoDiff<T>() {}
124 
125  // Construct a constant with a value of v. Zero derivatives.
126  AutoDiffX(const T &v) : AutoDiff<T>(v) {}
127 
128  // A function f(x0,x1,...,xn,...) with a value of v. The
129  // total number of derivatives is ndiffs, the nth derivative is one, and all
130  // others are zero.
131  AutoDiffX(const T &v, const uInt ndiffs, const uInt n) :
132  AutoDiff<T>(v, ndiffs, n) {}
133 
134  // A function f(x0,x1,...,xn,...) with a value of v. The
135  // total number of derivatives is ndiffs.
136  // All derivatives are zero.
137  AutoDiffX(const T &v, const uInt ndiffs) : AutoDiff<T>(v, ndiffs) {}
138 
139  // Construct one from another
140  AutoDiffX(const AutoDiff<T> &other) : AutoDiff<T>(other) {}
141 
142  // Construct a function f(x0,x1,...,xn) of a value v and a vector of
143  // derivatives derivs(0) = df/dx0, derivs(1) = df/dx1, ...
144  AutoDiffX(const T &v, const Vector<T> &derivs) : AutoDiff<T>(v, derivs) {}
145 
147 
148  // Assignment operator. Assign a constant to variable. All derivatives
149  // are zero.
150  AutoDiffX<T> &operator=(const T &v) {
152  return *this;
153  }
154 
155  // Assign one to another.
157  AutoDiff<T>::operator=(other);
158  return *this;
159  }
160 
161  private:
162  //# Data
163 
164 };
165 
166 
167 } //# NAMESPACE CASACORE - END
168 
169 #endif
AutoDiffX(const T &v, const uInt ndiffs)
A function f(x0,x1,...,xn,...) with a value of v.
Definition: AutoDiffX.h:137
AutoDiffX< T > & operator=(const AutoDiff< T > &other)
Assign one to another.
Definition: AutoDiffX.h:156
AutoDiffX(const T &v)
Construct a constant with a value of v.
Definition: AutoDiffX.h:126
AutoDiffX(const T &v, const uInt ndiffs, const uInt n)
A function f(x0,x1,...,xn,...) with a value of v.
Definition: AutoDiffX.h:131
AutoDiffX(const T &v, const Vector< T > &derivs)
Construct a function f(x0,x1,...,xn) of a value v and a vector of derivatives derivs(0) = df/dx0,...
Definition: AutoDiffX.h:144
AutoDiffX< T > & operator=(const T &v)
Assignment operator.
Definition: AutoDiffX.h:150
AutoDiffX(const AutoDiff< T > &other)
Construct one from another.
Definition: AutoDiffX.h:140
AutoDiffX()
Construct a constant with a value of zero.
Definition: AutoDiffX.h:123
AutoDiff< T > & operator=(const T &v)
Assignment operator.
this file contains all the compiler specific defines
Definition: mainpage.dox:28
unsigned int uInt
Definition: aipstype.h:51