A.D.

La diferenciación automática, tanto como diferencias divididas, requiere solamente el programa original P. Pero en vez de ejecutar P con diversos conjuntos de entradas, se construye un nuevo, aumentado programa P', que computa las derivadas analíticas junto con el programa original. Este nuevo programa se llama el programa diferenciado. Precisamente, cada vez que el programa original lleva valor v, el programa diferenciado lleva un valor adicional dv, el diferencial del v. Por otra parte, cada vez que el programa original realiza una cierta operación, el programa diferenciado realiza las operaciones adicionales que se ocupan de los valores diferenciados. Por ejemplo, si el programa original, en un cierta momento durante la ejecución, ejecuta la instrucción siguiente en las variables a, b, c, y arreglo T:

$a = b*T(10) + c$

entonces el programa diferenciado debe ejecutar operaciones adicionales en las variables y en sus diferenciales, da, db, dc, y arreglo dT, que debe llegar de alguna manera a:

$da = db*T(10) + b*dT(10) + dc$

Los derivadas ahora se calculan analíticamente, usando las fórmulas bien conocidas en la derivación de operaciones elementales. Los errores de aproximación desaparecen.

Los programas se identifican con secuencias de instrucciones, estas secuencias se identifican como funciones compuestas. Por ejemplo, la secuencia de instrucciones:

$I_{1}; I_{2}; \ldots; I_{p-1}; I_{p}$

se identifica a la función:

$f = f_{p} \circ f_{p-1} \circ \ldots \circ f_{1}$

Por supuesto cada uno de estas funciones se amplían para operar en el dominio de todas las variables del programa, pero las variables no sobreescritas por la instrucción apenas se transmiten sin cambiar al resultado de la función. Podemos entonces utilizar la regla de cadena para escribir formalmente el derivada del programa para una vector dado X:

$f'(x) = (f'_{p} \circ f_{p-1} \circ \ldots \circ f_{1}(x))$
$. (f'_{p-1} \circ; \ldots \circ f_{1}(x))$
$. \ldots$
$. (f'_{1}(x))$
$= f'_{x_{p-1}} . f'_{x_{p-2}} \ldots f'_{1}(x_{0})$

Escribimos $f'_{n}$ como las derivadas de la función $f_{n}$. Así $f'_{n}$ son Jacobianos. Para escribir lo anterior en una forma más corta, introducimos el $x_{n}$, que son los valores de las variables enseguida después de ejecutar la primera funciona n (fijamos $x_{0} = x$).

Por lo tanto, computar las derivados es sólo computar y multiplicar estas matrices Jacobianas elementales $f'_{n}(x_{n-1})$.

Hay básicamente dos maneras de poner A.D en práctica:

• Sobrecarga de Variables

  El sobrecargar consiste en decir al copilador que cada número real será substituido por un par de números reales, el segundo es el diferencial. Cada operación elemental en números reales es sobrecargada, es decir internamente substituido por una nueva, que trabaja sobre pares de reales. La ventaja es que el programa original queda virtualmente sin cambios, puesto que todo se hace en tiempo de compilación. La desventaja es que el programa que resulta funciona lentamente porque debe constantemente crear y destruir pares de números reales. Por otra parte, es muy duro implementar el "modo reverso" con sobrecarga.

• Transformación de Código Fuente

  La transformación del código fuente consiste en la adición en el programa de las nuevas variables, órdenes, y estructuras de datos que manejeran las derivadas, y en la adición de las nuevas instrucciones que calculan estas derivadas. La ventaja es que el programa que resulta se puede compilar eficientemente, y el "modo reverso" es posible. La desventaja es que esto es una transformación enorme, eso no se puede hacer a mano en programas grandes. Son necesarias herramientas para realizar esta transformación correctamente y rápidamente. Nuestro equipo estudia esta clase de herramientas. Nuestra aplicación TAPENADE es una herramienta para diferenciación automática que utiliza transformación del código fuente.