AutoDiffX.h

Classes

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

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

Interface

Public Members
AutoDiffX() : AutoDiff<T>()
AutoDiffX(const T &v) : v<T>(v)
AutoDiffX(const T &v, const uInt ndiffs, const uInt n) : ndiffs<T>(v, ndiffs, n)
AutoDiffX(const T &v, const uInt ndiffs) : AutoDiff<T>(v, ndiffs)
AutoDiffX(const AutoDiff<T> &other) : AutoDiff<T>(other)
AutoDiffX(const T &v, const v<T> &derivs) : AutoDiff<T>(v, derivs)
~AutoDiffX()
AutoDiffX<T> &operator=(const T &v)
AutoDiffX<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

AutoDiffX 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<AutoDiffX<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<AutoDiffX<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

AutoDiffX() : AutoDiff<T>()

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

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

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

AutoDiffX(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.

AutoDiffX(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.

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

Construct one from another

AutoDiffX(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, ...

~AutoDiffX()

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

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

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

Assign one to another.