casacore
Loading...
Searching...
No Matches
AutoDiffA.h
Go to the documentation of this file.
1//# AutoDiffA.h: An automatic differentiating class for functions
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//#
27//# $Id$
28
29#ifndef SCIMATH_AUTODIFFA_H
30#define SCIMATH_AUTODIFFA_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
37namespace 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// AutoDiffA 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<AutoDiffA<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<AutoDiffA<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
119template <class T> class AutoDiffA : public AutoDiff<T> {
120 public:
121 //# Constructors
122 // Construct a constant with a value of zero. Zero derivatives.
123 AutoDiffA() : AutoDiff<T>() {}
124
125 // Construct a constant with a value of v. Zero derivatives.
126 AutoDiffA(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 AutoDiffA(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 AutoDiffA(const T &v, const uInt ndiffs) : AutoDiff<T>(v, ndiffs) {}
138
139 // Construct one from another
140 AutoDiffA(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 AutoDiffA(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 AutoDiffA<T> &operator=(const T &v) {
152 return *this;
153 }
154
155 // Assign one to another.
158 return *this;
159 }
160
161 private:
162 //# Data
163
164};
165
166
167} //# NAMESPACE CASACORE - END
168
169#endif
AutoDiffA(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 AutoDiffA.h:144
AutoDiffA< T > & operator=(const AutoDiff< T > &other)
Assign one to another.
Definition AutoDiffA.h:156
AutoDiffA(const AutoDiff< T > &other)
Construct one from another.
Definition AutoDiffA.h:140
AutoDiffA(const T &v, const uInt ndiffs)
A function f(x0,x1,...,xn,...) with a value of v.
Definition AutoDiffA.h:137
AutoDiffA(const T &v, const uInt ndiffs, const uInt n)
A function f(x0,x1,...,xn,...) with a value of v.
Definition AutoDiffA.h:131
AutoDiffA< T > & operator=(const T &v)
Assignment operator.
Definition AutoDiffA.h:150
AutoDiffA()
Construct a constant with a value of zero.
Definition AutoDiffA.h:123
AutoDiffA(const T &v)
Construct a constant with a value of v.
Definition AutoDiffA.h:126
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