AutoDiffA.h

Classes

AutoDiffA -- Class that computes partial derivatives by automatic differentiation. (full description)

template <class T> class AutoDiffA : public AutoDiff<T>

Interface

Public Members
AutoDiffA() : AutoDiff<T>()
AutoDiffA(const T &v) : v<T>(v)
AutoDiffA(const T &v, const uInt ndiffs, const uInt n) : ndiffs<T>(v, ndiffs, n)
AutoDiffA(const T &v, const uInt ndiffs) : AutoDiff<T>(v, ndiffs)
AutoDiffA(const AutoDiff<T> &other) : AutoDiff<T>(other)
AutoDiffA(const T &v, const v<T> &derivs) : AutoDiff<T>(v, derivs)
~AutoDiffA()
AutoDiffA<T> &operator=(const T &v)
AutoDiffA<T> &operator=(const AutoDiff<T> &other)

Description

Review Status

Date Reviewed:
yyyy/mm/dd
Programs:
Demos:
Tests:

Prerequisite

Etymology

Class that computes partial derivatives by automatic differentiation, thus AutoDiff.

Synopsis

AutoDiffA is an AutoDiff. It is used to be able to distinguish between two template incarnations; e.g. to have one or more specializations, in addition to the general template version.

Example

See for an extensive example the demo program dAutoDiff. It is based on the example given in the AutoDiff class, and shows how to have both an automatic and a specific version of a function object. 
 	// The function, with fixed parameters a,b:
	template <class T> class f {
	public:
	  T operator()(const T& x) { return a_p*a_p*a_p*b_p*b_p*x; }
	  void set(const T& a, const T& b) { a_p = a; b_p = b; }
	private:
	  T a_p;
	  T b_p;
	};
	// The specialized function
	template <> class f<AutoDiffA<Double> > {
	public:
	  T operator()(const T& x) { return a_p*a_p*a_p*b_p*b_p*x; }
	  void set(const T& a, const T& b) { a_p = a; b_p = b; }
	private:
	  T a_p;
	  T b_p;
	};
	// Call it with different template arguments:
	  AutoDiff<Double> a1(2,2,0), b1(3,2,1), x1(7);
	  f<AutoDiff<Double> > f1; f1.set(a1, b1);
	  cout << "Diff a,b:   " << f1(x1) << endl;
	
	  f<AutoDiffA<Double> > f12; f12.set(a1, b1);
	  cout << "Same....:   " << f12(x1) << endl;

    // Result will be:
    // Diff a,b:  (504, [756, 336])
    // Same....:  (504, [756, 336])

    // It needed the template instantiations definitions:
	template class f<AutoDiff<Double> >;

Motivation

The class was created to enable separate calculations of the same function.

Template Type Argument Requirements (T)

To Do

Member Description

AutoDiffA() : AutoDiff<T>()

Construct a constant with a value of zero. Zero derivatives.

AutoDiffA(const T &v) : v<T>(v)

Construct a constant with a value of v. Zero derivatives.

AutoDiffA(const T &v, const uInt ndiffs, const uInt n) : ndiffs<T>(v, ndiffs, n)

A function f(x0,x1,...,xn,...) with a value of v. The total number of derivatives is ndiffs, the nth derivative is one, and all others are zero.

AutoDiffA(const T &v, const uInt ndiffs) : AutoDiff<T>(v, ndiffs)

A function f(x0,x1,...,xn,...) with a value of v. The total number of derivatives is ndiffs. All derivatives are zero.

AutoDiffA(const AutoDiff<T> &other) : AutoDiff<T>(other)

Construct one from another

AutoDiffA(const T &v, const v<T> &derivs) : AutoDiff<T>(v, derivs)

Construct a function f(x0,x1,...,xn) of a value v and a vector of derivatives derivs(0) = df/dx0, derivs(1) = df/dx1, ...

~AutoDiffA()

AutoDiffA<T> &operator=(const T &v)

Assignment operator. Assign a constant to variable. All derivatives are zero.

AutoDiffA<T> &operator=(const AutoDiff<T> &other)

Assign one to another.