SparseDiffA.h

Go to the documentation of this file.

// # SparseDiff!A.h: An automatic differentiating class for functions
// # Copyright (C) 2001,2002
// # Associated Universities, Inc. Washington DC, USA.
// #
// # This library is free software; you can redistribute it and/or modify it
// # under the terms of the GNU Library General Public License as published by
// # the Free Software Foundation; either version 2 of the License, or (at your
// # option) any later version.
// #
// # This library is distributed in the hope that it will be useful, but WITHOUT
// # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
// # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library General Public
// # License for more details.
// #
// # You should have received a copy of the GNU Library General Public License
// # along with this library; if not, write to the Free Software Foundation,
// # Inc., 675 Massachusetts Ave, Cambridge, MA 02139, USA.
// #
// # Correspondence concerning AIPS++ should be addressed as follows:
// #        Internet email: casa-feedback@nrao.edu.
// #        Postal address: AIPS++ Project Office
// #                        National Radio Astronomy Observatory
// #                        520 Edgemont Road
// #                        Charlottesville, VA 22903-2475 USA
 
#ifndef SCIMATH_SPARSEDIFFA_H
#define SCIMATH_SPARSEDIFFA_H
 
// # Includes
#include <casacore/casa/aips.h>
#include <casacore/casa/Arrays/ArrayFwd.h>
#include <casacore/scimath/Mathematics/SparseDiff.h>
 
namespace casacore {  // # NAMESPACE CASACORE - BEGIN
 
// <summary>
// Class that computes partial derivatives by automatic differentiation.
// </summary>
//
// <use visibility=export>
//
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="tSparseDiff.cc"
// demos="dSparseDiff.cc">
// </reviewed>
//
// <prerequisite>
// <li> <linkto class=SparseDiff>SparseDiff</linkto>
// </prerequisite>
//
// <etymology>
// Class that computes partial derivatives by automatic differentiation, thus
// SparseDiff.
// </etymology>
//
// <synopsis>
// SparseDiffA is an <linkto class=SparseDiff>SparseDiff</linkto>. 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.
// </synopsis>
//
// <example>
// See for an extensive example the demo program dSparseDiff. It is
// based on the example given in the <linkto class=SparseDiff>SparseDiff</linkto>
// class, and shows how to have both an automatic and a specific version
// of a function object.
// <srcblock>
//  // 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<SparseDiffA<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:
//    SparseDiff<Double> a1(2,0), b1(3,1), x1(7);
//    f<SparseDiff<Double> > f1; f1.set(a1, b1);
//    cout << "Diff a,b:   " << f1(x1) << endl;
//
//    f<SparseDiffA<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<SparseDiff<Double> >;
// </srcblock>
// </example>
//
// <motivation>
// The class was created to enable separate calculations of the same
// function.
// </motivation>
//
// <templating arg=T>
//  <li> any class that has the standard mathematical and comparisons
//  defined
// </templating>
//
// <todo asof="2001/06/07">
// <li> Nothing I know
// </todo>
 
template <class T>
class SparseDiffA : public SparseDiff<T> {
 public:
  // # Constructors
  //  Construct a constant with a value of zero.  Zero derivatives.
  SparseDiffA() : SparseDiff<T>() {}
 
  // Construct a constant with a value of v.  Zero derivatives.
  SparseDiffA(const T &v) : SparseDiff<T>(v) {}
 
  // A function f(x0,x1,...,xn,...) with a value of v.
  // The nth derivative is one, and all others are zero.
  SparseDiffA(const T &v, const uInt n) : SparseDiff<T>(v, n) {}
 
  // A function f(x0,x1,...,xn,...) with a value of v.  The
  // nth derivative is der, and all other derivatives are zero.
  SparseDiffA(const T &v, const uInt n, const T &der) : SparseDiff<T>(v, n, der) {}
 
  // Construct one from another
  SparseDiffA(const SparseDiff<T> &other) : SparseDiff<T>(other) {}
 
  ~SparseDiffA() {}
 
  // Assignment operator.  Assign a constant to variable.  All derivatives
  // are zero.
  SparseDiffA<T> &operator=(const T &v) {
    SparseDiff<T>::operator=(v);
    return *this;
  }
 
  // Assignment operator.  Add a gradient to variable.
  SparseDiffA<T> &operator=(const pair<uInt, T> &der) {
    SparseDiff<T>::operator=(der);
    return *this;
  }
 
  // Assignment operator.  Assign gradients to variable.
  SparseDiffA<T> &operator=(const vector<pair<uInt, T>> &der) {
    SparseDiff<T>::operator=(der);
    return *this;
  }
 
  // Assign one to another (deep copy).
  SparseDiffA<T> &operator=(const SparseDiff<T> &other) {
    SparseDiff<T>::operator=(other);
    return *this;
  }
 
 private:
  // # Data
};
 
}  // namespace casacore
 
#endif