Automatic differentiation
From Wikipedia, the free encyclopedia
In mathematics and computer algebra, automatic differentiation (AD), also called algorithmic differentiation or computational differentiation,^{[1]}^{[2]} is a set of techniques to numerically evaluate the derivative of a function specified by a computer program. AD exploits the fact that every computer program, no matter how complicated, executes a sequence of elementary arithmetic operations (addition, subtraction, multiplication, division, etc.) and elementary functions (exp, log, sin, cos, etc.). By applying the chain rule repeatedly to these operations, derivatives of arbitrary order can be computed automatically, accurately to working precision, and using at most a small constant factor more arithmetic operations than the original program.
Automatic differentiation is not:
 Symbolic differentiation, nor
 Numerical differentiation (the method of finite differences).
These classical methods run into problems: symbolic differentiation leads to inefficient code (unless carefully done) and faces the difficulty of converting a computer program into a single expression, while numerical differentiation can introduce roundoff errors in the discretization process and cancellation. Both classical methods have problems with calculating higher derivatives, where the complexity and errors increase. Finally, both classical methods are slow at computing the partial derivatives of a function with respect to many inputs, as is needed for gradientbased optimization algorithms. Automatic differentiation solves all of these problems, at the expense of introducing more software dependencies.
Contents
The chain rule, forward and reverse accumulation[edit]
Fundamental to AD is the decomposition of differentials provided by the chain rule. For the simple composition y = g(h(x)) = g(w) the chain rule gives
Usually, two distinct modes of AD are presented, forward accumulation (or forward mode) and reverse accumulation (or reverse mode). Forward accumulation specifies that one traverses the chain rule from inside to outside (that is, first one computes dw/dx and then dy/dw, while reverse accumulation has the traversal from outside to inside.
Generally, both forward and reverse accumulation are specific manifestations of applying the operator of program composition, with the appropriate one of the two mappings being fixed.
Forward accumulation[edit]
In forward accumulation AD, one first fixes the independent variable to which differentiation is performed and computes the derivative of each subexpression recursively. In a penandpaper calculation, one can do so by repeatedly substituting the derivative of the inner functions in the chain rule:
This can be generalized to multiple variables as a matrix product of Jacobians.
Compared to reverse accumulation, forward accumulation is very natural and easy to implement as the flow of derivative information coincides with the order of evaluation. One simply augments each variable w with its derivative ẇ (stored as a numerical value, not a symbolic expression),
as denoted by the dot. The derivatives are then computed in sync with the evaluation steps and combined with other derivatives via the chain rule.
As an example, consider the function:
For clarity, the individual subexpressions have been labeled with the variables w_{i}.
The choice of the independent variable to which differentiation is performed affects the seed values ẇ_{1} and ẇ_{2}. Suppose one is interested in the derivative of this function with respect to x_{1}. In this case, the seed values should be set to:
With the seed values set, one may then propagate the values using the chain rule as shown in both the table below. Figure 2 shows a pictorial depiction of this process as a computational graph.
To compute the gradient of this example function, which requires the derivatives of f with respect to not only x_{1} but also x_{2}, one must perform an additional sweep over the computational graph using the seed values .
The computational complexity of one sweep of forward accumulation is proportional to the complexity of the original code.
Forward accumulation is more efficient than reverse accumulation for functions f : ℝ^{n} → ℝ^{m} with m ≫ n as only n sweeps are necessary, compared to m sweeps for reverse accumulation.
Reverse accumulation[edit]
In reverse accumulation AD, one first fixes the dependent variable to be differentiated and computes the derivative with respect to each subexpression recursively. In a penandpaper calculation, one can perform the equivalent by repeatedly substituting the derivative of the outer functions in the chain rule:
In reverse accumulation, the quantity of interest is the adjoint, denoted with a bar (w̄); it is a derivative of a chosen dependent variable with respect to a subexpression w:
Reverse accumulation traverses the chain rule from outside to inside, or in the case of the computational graph in Figure 3, from top to bottom. The example function is realvalued, and thus there is only one seed for the derivative computation, and only one sweep of the computational graph is needed in order to calculate the (twocomponent) gradient. This is only half the work when compared to forward accumulation, but reverse accumulation requires the storage of the intermediate variables w_{i} as well as the instructions that produced them in a data structure known as a Wengert list (or "tape"),^{[3]}^{[4]} which may represent a significant memory issue if the computational graph is large. This can be mitigated to some extent by storing only a subset of the intermediate variables and then reconstructing the necessary work variables by repeating the evaluations, a technique known as checkpointing.
The operations to compute the derivative using reverse accumulation are shown in the table below (note the reversed order):
The data flow graph of a computation can be manipulated to calculate the gradient of its original calculation. This is done by adding an adjoint node for each primal node, connected by adjoint edges which parallel the primal edges but flow in the opposite direction. The nodes in the adjoint graph represent multiplication by the derivatives of the functions calculated by the nodes in the primal. For instance, addition in the primal causes fanout in the adjoint; fanout in the primal causes addition in the adjoint; a unary function y = f(x) in the primal causes x̄ = ȳ f′(x) in the adjoint; etc.
Reverse accumulation is more efficient than forward accumulation for functions f : ℝ^{n} → ℝ^{m} with m ≪ n as only m sweeps are necessary, compared to n sweeps for forward accumulation.
Reverse mode AD was first published in 1970 by Seppo Linnainmaa in his master thesis.^{[5]}^{[6]}^{[7]}
Backpropagation of errors in multilayer perceptrons, a technique used in machine learning, is a special case of reverse mode AD.
Beyond forward and reverse accumulation[edit]
Forward and reverse accumulation are just two (extreme) ways of traversing the chain rule. The problem of computing a full Jacobian of f : ℝ^{n} → ℝ^{m} with a minimum number of arithmetic operations is known as the optimal Jacobian accumulation (OJA) problem, which is NPcomplete.^{[8]} Central to this proof is the idea that there may exist algebraic dependencies between the local partials that label the edges of the graph. In particular, two or more edge labels may be recognized as equal. The complexity of the problem is still open if it is assumed that all edge labels are unique and algebraically independent.
Automatic differentiation using dual numbers[edit]
Forward mode automatic differentiation is accomplished by augmenting the algebra of real numbers and obtaining a new arithmetic. An additional component is added to every number which will represent the derivative of a function at the number, and all arithmetic operators are extended for the augmented algebra. The augmented algebra is the algebra of dual numbers. This approach was generalized by the theory of operational calculus on programming spaces (see Analytic programming space), through tensor algebra of the dual space.
Replace every number with the number , where is a real number, but is an abstract number with the property (an infinitesimal; see Smooth infinitesimal analysis). Using only this, we get for the regular arithmetic
and likewise for subtraction and division.
Now, we may calculate polynomials in this augmented arithmetic. If , then
where denotes the derivative of with respect to its first argument, and , called a seed, can be chosen arbitrarily.
The new arithmetic consists of ordered pairs, elements written , with ordinary arithmetics on the first component, and first order differentiation arithmetic on the second component, as described above. Extending the above results on polynomials to analytic functions we obtain a list of the basic arithmetic and some standard functions for the new arithmetic:
and in general for the primitive function ,
where and are the derivatives of with respect to its first and second arguments, respectively.
When a binary basic arithmetic operation is applied to mixed arguments—the pair and the real number —the real number is first lifted to . The derivative of a function at the point is now found by calculating using the above arithmetic, which gives as the result.
Vector arguments and functions[edit]
Multivariate functions can be handled with the same efficiency and mechanisms as univariate functions by adopting a directional derivative operator. That is, if it is sufficient to compute , the directional derivative of at in the direction , this may be calculated as using the same arithmetic as above. If all the elements of are desired, then function evaluations are required. Note that in many optimization applications, the directional derivative is indeed sufficient.
High order and many variables[edit]
The above arithmetic can be generalized to calculate second order and higher derivatives of multivariate functions. However, the arithmetic rules quickly grow very complicated: complexity will be quadratic in the highest derivative degree. Instead, truncated Taylor polynomial algebra can be used. The resulting arithmetic, defined on generalized dual numbers, allows to efficiently compute using functions as if they were a new data type. Once the Taylor polynomial of a function is known, the derivatives are easily extracted. A rigorous, general formulation is achieved through the tensor series expansion using operational calculus on programming spaces. Currently there are a few software projects that implement the Taylor polynomial truncated algebra. AuDi, CTaylor and COSY infinity. Only the first two are open source.
Operational calculus on programming spaces[edit]
Operational calculus on programming spaces ^{[9]} generalizes concepts of automatic differentiation and provides a framework that enables analytic conclusions about programs through algebraic means. This formulation using Tensor algebra is a broad generalization of the dual numbers approach. Theory allows computations on the operator level, before the operator is applied to a particular program, favoring efficient implementation.
Operational calculus on programming spaces ^{[9]} was first proposed by Žiga Sajovic, mentored by Martin Vuk, to unify existing approaches under a single theory and provide a rigorous framework for program analysis through calculus.
Analytic programming space[edit]
A differentiable programming space is any subspace of such that
When all elements of are analytic, we call an analytic programming space.
 Theorem.
 Any differentiable programming space is an infinitely differentiable programming space, meaning that
for any . If all elements of are analytic, than so are the elements of .  Definition.
 Let be a differentiable programming space. The space spanned by over , where , is called a differentiable programming space of order .
 Corollary.
 A differentiable programming space of order , , can be embedded into the tensor product of the function space and the subspace of the tensor algebra of the dual of the virtual space .
 By taking the limit as , we consider
where is the tensor series algebra, the algebra of the infinite formal tensor series, which is a completion of the tensor algebra in suitable topology.
Proofs can be found in.^{[9]}
This means that we can represent calculation of derivatives of the map , with only one mapping . We define the operator as a direct sum of operators
The image is a multitensor of order , which is a direct sum of the maps value and all derivatives of order , all evaluated at the point :
The operator satisfies the recursive relation.
that can be used to recursively construct programming spaces of arbitrary order. Only explicit knowledge of is required for the construction of from , which is evident from the above theorem.
Analytic virtual machine[edit]
The paper ^{[9]} proposed an abstract computational model, a virtual machine capable of constructing and implementing the theory. Such a machine provides a framework for analytic study of algorithmic procedures through algebraic means.
 Claim
 The tuple and the belonging tensor series algebra are sufficient conditions for the existence and construction of infinitely differentiable programing spaces , through linear combinations of elements of .
This claim allows a simple definition of such a machine.
 Definition(Analytic virtual machine)
 The tuple is an analytic, infinitely differentiable virtual machine, where
 is a finite dimensional vector space
 is the virtual memory space
 is an analytic programming space over
 When is a differentiable programming space, this defines an infinitely differentiable virtual machine.
An illustrative open source implementation dCpp is available, closely following the theorems, intended as an educational guide.
Tensor series expansion[edit]
Expansion into a series offers valuable insights into programs through methods of analysis.
There exists a space spanned by the set over a field . Thus, the expression
is well defined. The operator is a mapping between function spaces
It also defines a map
by taking the image of the map at a certain point .
We may construct a map from the space of programs, to the space of polynomials. Note that the space of multivariate polynomials is isomorphic to symmetric algebra , which is in turn a quotient of tensor algebra . To any element of one can attach corresponding element of namely a polynomial map . Thus, we consider the completion of the symmetric algebra as the Formal power series , which is in turn isomorphic to a quotient of tensor series algebra , arriving at
For any element , the expression is a map , mapping a program to a Formal power series. We can express the correspondence between multitensors in and polynomial maps given by multiple contractions for all possible indices.
 Theorem.
 For a program the expansion into an infinite tensor series at the point is expressed by multiple contractions
Proof can be found in.^{[9]} Evaluated at , the operator is a generalization of the Shift operator widely used in physics. For a specific it is heron denoted by
When the choice of is arbitrary, we omit it from expressions for brevity.
Operator of program composition[edit]
Theory offers a generalization of both forward and reverse mode of automatic differentiation to arbitrary order, under a single invariant operator in the theory. This condenses complex notions to simple expressions allowing meaningful manipulations before being applied to a particular programming space.
 Theorem.
 Composition of maps is expressed as

 where is an operator on pairs of maps , where is applied to and to .
Proof can be found in.^{[9]}
Both forward and reverse mode (generalized to arbitrary order) are obtainable using this operator, by fixing the appropriate one of the two maps. This generalizes both concepts under a single operator in the theory. For example, by considering projections of the operator onto the space spanned by , and fixing the second map , we retrieve the basic first order forward mode of automatic differentiation, or reverse mode, by fixing .
Thus the operator alleviates the need for explicit implementation of the higher order chain rule (see Faà di Bruno's formula), as it is encoded in the structure of the operator itself, which can be efficiently implemented by manipulating its generating map (see ^{[9]}).
Order reduction for nested applications[edit]
It is useful to be able to use the th derivative of a program as part of a different differentiable program . As such, we must be able to treat the derivative itself as a differentiable program , while only coding the original program .
 Theorem
 There exists a reduction of order map satisfying

 for each , where is the projection of the operator onto the set .
By the above Theorem, differentiable th derivatives of a program can be extracted by
Thus, we gained the ability of writing a differentiable program acting on derivatives of another program, stressed as crucial by other authors.^{[10]}
Implementation[edit]
Forwardmode AD is implemented by a nonstandard interpretation of the program in which real numbers are replaced by dual numbers, constants are lifted to dual numbers with a zero epsilon coefficient, and the numeric primitives are lifted to operate on dual numbers. This nonstandard interpretation is generally implemented using one of two strategies: source code transformation or operator overloading.
Source code transformation (SCT)[edit]
The source code for a function is replaced by an automatically generated source code that includes statements for calculating the derivatives interleaved with the original instructions.
Source code transformation can be implemented for all programming languages, and it is also easier for the compiler to do compile time optimizations. However, the implementation of the AD tool itself is more difficult.
Operator overloading (OO)[edit]
Operator overloading is a possibility for source code written in a language supporting it. Objects for real numbers and elementary mathematical operations must be overloaded to cater for the augmented arithmetic depicted above. This requires no change in the form or sequence of operations in the original source code for the function to be differentiated, but often requires changes in basic data types for numbers and vectors to support overloading and often also involves the insertion of special flagging operations.
Operator overloading for forward accumulation is easy to implement, and also possible for reverse accumulation. However, current compilers lag behind in optimizing the code when compared to forward accumulation.
Operator overloading, for both forward and reverse accumulation, can be wellsuited to applications where the objects are vectors of real numbers rather than scalars. This is because the tape then comprises vector operations; this can facilitate computationally efficient implementations where each vector operation performs many scalar operations. Vector adjoint algorithmic differentiation (vector AAD) techniques may be used, for example, to differentiate values calculated by MonteCarlo simulation.
Software[edit]
 C/C++

Package License Approach Brief info ADC Version 4.0 nonfree OO ADEL MIT OO Forward and reverse modes. Templatebased with CUDA support. Adept Apache 2.0 OO Firstorder forward and reverse modes. Very fast due to its use of expression templates and an efficient tape structure. ADIC free for noncommercial SCT forward mode ADMB BSD SCT+OO Uses a template approach. See http://admbproject.org/ ADNumber dual license OO arbitrary order forward/reverse ADOLC CPL 1.0 or GPL 2.0 OO arbitrary order forward/reverse, part of COINOR AuDi GNU GPL 2.0 OO AuDi is an open source, header only, C++ library that allows for AUtomated DIfferentiation implementing the Taylor truncated polynomial algebra (forward mode automated differentiation). It was created with the aim to offer a generic solution to the user in need of a generic automated differentiation system. AuDi is threadsafe and, when possible, uses finegrained parallelization of the truncated polynomial multiplication. The benefits of this fine grained parallelization are well visible for many variables and high orders. AuDi implements vectorized polynomial multiplication offering the most efficient implementation of a differential algebra for vectorized computations (i.e. computing the derivatives of the same expression on multiple points). AMPL free for students SCT CasADi GNU LGPL SCT Forward/reverse modes, matrixvalued atomic operations, code generation. ceressolver BSD OO A portable C++ library that allows for modeling and solving large complicated nonlinear least squares problems CppAD EPL 1.0 or GPL 3.0 OO arbitrary order forward/reverse, AD<Base> for arbitrary Base including AD<Other_Base>, part of COINOR; can also be used to produce C source code using the CppADCodeGen library. CTaylor free OO truncated taylor series, multi variable, high performance, calculating and storing only potentially nonzero derivatives, calculates higher order derivatives, order of derivatives increases when using matching operations until maximum order (parameter) is reached, example source code and executable available for testing performance Eigen Auto Diff MPL2 OO FADBAD++ free for
noncommercialOO uses operator new OpenAD depends on components SCT ReverseAD free OO High order reverse mode which evaluates the high order derivative tensor directly instead of a forward/reverse modes hierarchy. Sacado GNU GPL OO A part of the Trilinos collection, forward/reverse modes. Stan (software) BSD OO forward and reversemode automatic differentiation with library of special functions, probability functions, matrix operators, and linear algebra solvers; interfaces to MATLAB, R and Python. TAPENADE Free for noncommercial SCT Tensorflow Apache 2.0 OO TensorFlow is a Googledeveloped Python and C++ library that allows you to define, optimize, and evaluate mathematical expressions involving multidimensional arrays both on CPU and GPU efficiently.
 Fortran

Package License Approach Brief info ADF Version 4.0 nonfree OO ADIFOR >>>
(free for noncommercial)SCT AUTO_DERIV free for noncommercial OO OpenAD depends on components SCT TAF nonfree SCT TAPENADE Free for noncommercial SCT GADfit Free (GPL 3) OO First (forward, reverse) and second (forward) order, principal use is nonlinear curve fitting, includes the differentiation of integrals
 Matlab

Package License Approach Brief info AD for MATLAB GNU GPL OO Forward (1st & 2nd derivative, Uses MEX files & Windows DLLs) Adiff BSD OO Forward (1st derivative) MAD Proprietary OO Forward (1st derivative) full/sparse storage of derivatives ADiMat Proprietary SCT Forward (1st & 2nd derivative) & Reverse (1st), proprietary server side transform MADiff GNU GPL OO Reverse AutoDiff BSD OO CasADi GNU LGPL SCT Forward/reverse modes, matrixvalued atomic operations, code generation.
 Python

Package License Approach Brief info ad BSD OO first and secondorder, reverse accumulation, transparent onthefly calculations, basic NumPy support, written in pure python FuncDesigner BSD OO uses NumPy arrays and SciPy sparse matrices,
also allows to solve linear/nonlinear/ODE systems and
to perform numerical optimizations by OpenOptScientificPython CeCILL OO see modules Scientific.Functions.FirstDerivatives and
Scientific.Functions.Derivativespycppad BSD OO arbitrary order forward/reverse, implemented as wrapper for CppAD including AD<double> and AD< AD<double> >. pyadolc BSD OO wrapper for ADOLC, hence arbitrary order derivatives in the (combined) forward/reverse mode of AD, supports sparsity pattern propagation and sparse derivative computations uncertainties BSD OO firstorder derivatives, reverse mode, transparent calculations algopy BSD OO same approach as pyadolc and thus compatible, support to differentiate through numerical linear algebra functions like the matrixmatrix product, solution of linear systems, QR and Cholesky decomposition, etc. pyderiv GNU GPL OO automatic differentiation and (co)variance calculation CasADi GNU LGPL SCT Python frontend to CasADi. Forward/reverse modes, matrixvalued atomic operations, code generation. Tensorflow Apache 2.0 OO TensorFlow is a Googledeveloped Python and C++ library that allows you to define, optimize, and evaluate mathematical expressions involving multidimensional arrays both on CPU and GPU efficiently. CNTK Apache 2.0 OO CNTK is a Microsoftdeveloped C++ library which supports Productionquality, Open Source, Multimachine, MultiGPU, Highly efficient RNN training, Speech, Image, Text Theano BSD OO Theano is a Python library that allows you to define, optimize, and evaluate mathematical expressions involving multidimensional arrays both on CPU and GPU efficiently. Autograd MIT OO Autograd can reversemode differentiate native Python and Numpy code. It can handle a large subset of Python's features, including loops, ifs, recursion and closures. It is closed under its own operation and hence can compute derivatives of any order. Chainer MIT OO pyaudi GNU GPL 2.0 OO Python frontend to AuDi. A fully functional and most efficient implementation of Taylor truncated polynomial algebra (a differential algebra) with the possibility of vectorized computations reaching great efficiency.
 Lua

Package License Approach Brief info Torch BSD OO Torch is a LuaJIT library used for Deep Learning. Its nn package is divided into modular objects that share a common Module
interface. Modules have aforward
andbackward
function that allow them to feedforward and backpropagate (firstorder derivatives). Modules can be joined together using module composites to create complex tasktailored graphs.Torchautograd Apache 2.0 OO SciLua MIT OO SciLua, a framework for general purpose scientific computing in LuaJIT, features complete and transparent support for forwardmode automatic differentiation.
 .NET

Package License Approach Brief info AutoDiff GNU LGPL OO Automatic differentiation with C# operator overloading. FuncLib MIT OO Automatic differentiation and numerical optimization, operator overloading, unlimited order of differentiation, compilation to IL code for very fast evaluation. DiffSharp GNU LGPL OO An automatic differentiation library implemented in the F# language. It supports C# and the other CLI languages. The library provides gradients, Hessians, Jacobians, directional derivatives, and matrixfree Hessian and Jacobianvector products, which can be incorporated with minimal change into existing algorithms. Operations can be nested to any level, meaning that you can compute exact higherorder derivatives and differentiate functions that are internally making use of differentiation. Vector Accelerator MIT OO C# library for performing vector adjoint (reverse mode) algorithmic differentiation (also known as 'vector AAD'). Vector Accelerator uses operator overloading of vector operations, accelerated using processoroptimised libraries (e.g. Intel MKL).
 Haskell

Package License Approach Brief info ad BSD OO Forward Mode (1st derivative or arbitrary order derivatives via lazy lists and sparse tries)
Reverse Mode
Combined forwardonreverse Hessians.
Uses Quantification to allow the implementation automatically choose appropriate modes.
Quantification prevents perturbation/sensitivity confusion at compile time.fad BSD OO Forward Mode (lazy list). Quantification prevents perturbation confusion at compile time. rad BSD OO Reverse Mode. (Subsumed by 'ad').
Quantification prevents sensitivity confusion at compile time.
 Java

Package License Approach Brief info JAutoDiff MIT OO Provides a framework to compute derivatives of functions on arbitrary types of field using generics. Coded in 100% pure Java. Apache Commons Math Apache License v2 OO This class is an implementation of the extension to Rall's numbers described in Dan Kalman's paper^{[11]} Deriva Eclipse Public License v1.0 DSL+Code Generation Deriva automates algorithmic differentiation in Java and Clojure projects. It defines DSL for building extended arithmetic expressions (the extension being support for conditionals, allowing to express non analytic functions). The DSL is used to generate flat bytecode at runtime, providing implementation without overhead of function calls. Jap Public OO/SCT Jap is a tools using Virtual Operator Overloading for java class. Jap was developed in the thesis of Phuong PHAMQUANG 20082011.

Package License Approach Brief info AutoDiffSource.jl MIT SCT Fast reverse mode differentiation for scalar and tensor functions using source code transformation. ForwardDiff.jl MIT OO A unified package for forwardmode automatic differentiation, combining both DualNumbers and vectorbased gradient accumulations. DualNumbers.jl MIT OO Implements a Dual number type which can be used for forwardmode automatic differentiation of first derivatives via operator overloading. HyperDualNumers.jl MIT OO Implements a Hyper number type which can be used for forwardmode automatic differentiation of first and second derivatives via operator overloading. ReverseDiffSource.jl MIT SCT Implements reversemode automatic differentiation for gradients and highorder derivatives given usersupplied expressions or generic functions. Accepts a subset of valid Julia syntax, including intermediate assignments. TaylorSeries.jl MIT OO Implements truncated multivariate power series for highorder integration of ODEs and forwardmode automatic differentiation of arbitrary order derivatives via operator overloading.
 Clojure

Package License Approach Brief info Deriva Eclipse Public License v1.0 DSL+Code Generation Deriva automates algorithmic differentiation in Java and Clojure projects. It defines DSL for building extended arithmetic expressions (the extension being support for conditionals, allowing to express non analytic functions). The DSL is used to generate flat bytecode at runtime, providing implementation without overhead of function calls.

Package License Approach Brief info ad Apache 2.0 DSL+Code Generation Creates source code corresponding to algebraic expressions. See https://autodiff.info for a demo.

Package License Approach Brief info PBSadmb GNU GPL SCT+OO Uses a template approach. See http://admbproject.org/ .
References[edit]
 ^ Neidinger, Richard D. (2010). "Introduction to Automatic Differentiation and MATLAB ObjectOriented Programming" (PDF). SIAM Review. 52 (3): 545–563. doi:10.1137/080743627.
 ^ http://www.ecsecurehost.com/SIAM/SE24.html
 ^ R.E. Wengert (1964). "A simple automatic derivative evaluation program". Comm. ACM. 7: 463–464. doi:10.1145/355586.364791.
 ^ BartholomewBiggs, Michael; Brown, Steven; Christianson, Bruce; Dixon, Laurence (2000). "Automatic differentiation of algorithms" (PDF). Journal of Computational and Applied Mathematics. 124 (12): 171–190. doi:10.1016/S03770427(00)004222.
 ^ Linnainmaa, Seppo (1970). The representation of the cumulative rounding error of an algorithm as a Taylor expansion of the local rounding errors. Master's Thesis (in Finnish), Univ. Helsinki, 67.
 ^ Linnainmaa, Seppo (1976). Taylor expansion of the accumulated rounding error. BIT Numerical Mathematics, 16(2), 146160.
 ^ Griewank, Andreas (2012). Who Invented the Reverse Mode of Differentiation?. Optimization Stories, Documenta Matematica, Extra Volume ISMP (2012), 389400.
 ^ Naumann, Uwe (April 2008). "Optimal Jacobian accumulation is NPcomplete". Mathematical Programming. 112 (2): 427–441. doi:10.1007/s101070060042z.
contribution=
ignored (help)  ^ ^{a} ^{b} ^{c} ^{d} ^{e} ^{f} ^{g} Sajovic, Žiga; Vuk, Martin (2016). "Operational calculus on programming spaces and generalized tensor networks". arXiv:1610.07690 [math.FA].
 ^ Pearlmutter, Barak A.; Siskind, Jeffrey M (May 2008). "PPutting the Automatic Back into AD: Part II". ECE Technical Reports.
 ^ Kalman, Dan (June 2002). "Doubly Recursive Multivariate Automatic Differentiation" (PDF). Mathematics Magazine. 75 (3): 187–202. doi:10.2307/3219241.
Literature[edit]
 Rall, Louis B. (1981). Automatic Differentiation: Techniques and Applications. Lecture Notes in Computer Science. 120. Springer. ISBN 3540108610.
 Griewank, Andreas; Walther, Andrea (2008). Evaluating Derivatives: Principles and Techniques of Algorithmic Differentiation. Other Titles in Applied Mathematics. 105 (2nd ed.). SIAM. ISBN 9780898716597.
 Neidinger, Richard (2010). "Introduction to Automatic Differentiation and MATLAB ObjectOriented Programming" (PDF). SIAM Review. 52 (3): 545–563. doi:10.1137/080743627. Retrieved 20130315.
External links[edit]
 www.autodiff.org, An "entry site to everything you want to know about automatic differentiation"
 Autograd, An automatically differentiation library for native Python and Numpy code
 Automatic Differentiation of Parallel OpenMP Programs
 Automatic Differentiation, C++ Templates and Photogrammetry
 Automatic Differentiation, Operator Overloading Approach
 Compute analytic derivatives of any Fortran77, Fortran95, or C program through a webbased interface Automatic Differentiation of Fortran programs
 Description and example code for forward Automatic Differentiation in Scala
 Adjoint Algorithmic Differentiation: Calibration and Implicit Function Theorem
 [1], Exact First and SecondOrder Greeks by Algorithmic Differentiation
 [2], Adjoint Algorithmic Differentiation of a GPU Accelerated Application
 [3], Adjoint Methods in Computational Finance Software Tool Support for Algorithmic Differentiation