lines 8-74 of file: include/cppad/core/atomic/three/afun.hpp

{xrst_begin atomic_three_afun}

Using AD Version of an Atomic Function
######################################

Syntax
******
*afun* ( *ax* , *ay* )

Prototype
*********
{xrst_literal
   // BEGIN_PROTOTYPE
   // END_PROTOTYPE
}

Purpose
*******
Given *ax* , this call computes the corresponding value of *ay* .
If ``AD`` < *Base* > operations are being recorded,
it enters the computation as an atomic operation in the recording;
see :ref:`Independent@Start Recording` .

Base
****
This is the *Base* type of the elements of *ax* and *ay*
in the call to the *afun* atomic operation.
To be specific, the elements of *ax* and *ay* have type
``AD`` < ``Base`` > .

ADVector
********
The type *ADVector* must be a
:ref:`simple vector class<SimpleVector-name>` with elements of type
``AD`` < *Base* > .

afun
****
is a :ref:`atomic_three_ctor@atomic_user` object
and this *afun* function call is implemented by the
:ref:`atomic_three_ctor@atomic_three` class.

ax
**
This argument has prototype

   ``const`` *ADVector* & *ax*

and size must be equal to *n* .
It specifies vector :math:`x \in \B{R}^n`
at which an ``AD`` < *Base* > version of
:math:`y = g(x)` is to be evaluated; see
:ref:`atomic_three_ctor@atomic_three@Base` .

ay
**
This argument has prototype

   *ADVector* & *ay*

and size must be equal to *m* .
The input values of its elements
are not specified (must not matter).
Upon return, it is an ``AD`` < *Base* > version of
:math:`y = g(x)`.

{xrst_end atomic_three_afun}