Changeset 3682


Ignore:
Timestamp:
May 8, 2015 5:59:05 PM (5 years ago)
Author:
bradbell
Message:

merge to branch: trunk
from repository: https://github.com/coin-or/CppAD
start hash code: c85ed888ce93510f0df134d9fec6b7e185552f41
end hash code: febe930d34888cf37df862a1bf118229b9bf37a5

commit febe930d34888cf37df862a1bf118229b9bf37a5
Author: Brad Bell <bradbell@…>
Date: Fri May 8 14:21:47 2015 -0700

  1. Automatically generated changes for deprecated auto-tools install.
  2. Fix bug in acosh_op multiple direction forward mode.


configure.ac: Add new symbols for acosh and atanh detection (this install never detects them).
acosh_op.hpp: fix bug in multiple direction forward mode.
whats_new_15.omh: mention bug fix.
forward_dir.cpp: test asinh, acosh, and atanh.

commit 5d007c969a1e8bb0f983629f8134022a47ff2d75
Author: Brad Bell <bradbell@…>
Date: Fri May 8 12:27:18 2015 -0700

Remove trialing white space.

commit d88357106a95ee156ecf2101334dc51b22162950
Author: Brad Bell <bradbell@…>
Date: Fri May 8 12:26:58 2015 -0700

Add atanh operator.

commit 03890672ea394862373e4b1aa19a79cf04a71e73
Author: Brad Bell <bradbell@…>
Date: Fri May 8 11:57:45 2015 -0700

Change order to erf asinh acosh.

commit 9657e6dae7b5ef30ea1ea79d344f655e4db4498e
Author: Brad Bell <bradbell@…>
Date: Fri May 8 05:56:33 2015 -0700

Remove trialing white space.

commit cca1d8b8f344582f4c27c3c9c16745625e7e395e
Author: Brad Bell <bradbell@…>
Date: Fri May 8 05:56:06 2015 -0700

Change Atan -> atan.

commit ffa1894b1f97ca342aa84b65b171baad03568f58
Author: Brad Bell <bradbell@…>
Date: Fri May 8 05:37:49 2015 -0700

  1. Extend atan to include atanh.
  2. Remove index commands for words in headings.
  3. Change AtanForward? -> atan_forward.
  4. Remove trailing white space.


acos_forward.omh: add heading as in tan_forward.
asin_forward.omh: add heading as in tan_forward.
atan_forward.omh: change AtanForward? -> atan_forward.

Location:
trunk
Files:
4 added
66 edited

Legend:

Unmodified
Added
Removed
  • trunk/compare_c/makefile.in

    r3679 r3682  
    265265cppad_SOURCE_DIR = @cppad_SOURCE_DIR@
    266266cppad_boostvector = @cppad_boostvector@
     267cppad_compiler_has_acosh = @cppad_compiler_has_acosh@
    267268cppad_compiler_has_asinh = @cppad_compiler_has_asinh@
     269cppad_compiler_has_atanh = @cppad_compiler_has_atanh@
    268270cppad_compiler_has_erf = @cppad_compiler_has_erf@
    269271cppad_cppadvector = @cppad_cppadvector@
  • trunk/configure

    r3679 r3682  
    667667GREP
    668668CPP
     669cppad_compiler_has_atanh
     670cppad_compiler_has_acosh
    669671cppad_compiler_has_asinh
    670672cppad_compiler_has_erf
     
    54795481cppad_compiler_has_asinh=0
    54805482
     5483cppad_compiler_has_acosh=0
     5484
     5485cppad_compiler_has_atanh=0
     5486
    54815487
    54825488ac_ext=c
  • trunk/configure.ac

    r3679 r3682  
    494494AC_SUBST(cppad_compiler_has_erf, 0)
    495495AC_SUBST(cppad_compiler_has_asinh, 0)
     496AC_SUBST(cppad_compiler_has_acosh, 0)
     497AC_SUBST(cppad_compiler_has_atanh, 0)
    496498
    497499dnl Determine if size_t has same size as unsigned int
  • trunk/cppad/CMakeLists.txt

    r3680 r3682  
    147147# -----------------------------------------------------------------------------
    148148# cppad_compiler_has_erf
     149# cppad_compiler_has_asinh
    149150# cppad_compiler_has_acosh
    150 # cppad_compiler_has_asinh
     151# cppad_compiler_has_atanh
    151152#
    152153SET(source_template "
     
    158159"
    159160)
    160 FOREACH(c11_function erf acosh asinh)
     161FOREACH(c11_function erf asinh acosh atanh)
    161162        STRING(REPLACE "c11_function" ${c11_function} source "${source_template}" )
    162163        # really only checking if program compiles
  • trunk/cppad/configure.hpp.in

    r3680 r3682  
    7373# if __cplusplus >= 201100
    7474/*!
     75\def CPPAD_COMPILER_HAS_ASINH
     76C++11: Does compiler support std::asinh(double)
     77*/
     78# define CPPAD_COMPILER_HAS_ASINH @cppad_compiler_has_asinh@
     79# endif
     80
     81# if __cplusplus >= 201100
     82/*!
    7583\def CPPAD_COMPILER_HAS_ACOSH
    7684C++11: Does compiler support std::acosh(double)
     
    8189# if __cplusplus >= 201100
    8290/*!
    83 \def CPPAD_COMPILER_HAS_ASINH
    84 C++11: Does compiler support std::asinh(double)
    85 */
    86 # define CPPAD_COMPILER_HAS_ASINH @cppad_compiler_has_asinh@
     91\def CPPAD_COMPILER_HAS_ATANH
     92C++11: Does compiler support std::atanh(double)
     93*/
     94# define CPPAD_COMPILER_HAS_ATANH @cppad_compiler_has_atanh@
    8795# endif
    8896
  • trunk/cppad/example/base_adolc.hpp

    r3680 r3682  
    1515$begin base_adolc.hpp$$
    1616$spell
     17        atanh
    1718        acosh
    1819        asinh
     
    218219$code tan$$.
    219220
    220 $head erf, asin$$
     221$head erf, asinh, acosh, atanh$$
    221222If the
    222 $cref/erf, asinh, acosh/base_std_math/erf, asinh, acosh/$$,
     223$cref/erf, asinh, acosh, atanh
     224        /base_std_math
     225        /erf, asinh, acosh, atanh
     226/$$,
    223227functions are supported by the compiler,
    224228they must also be supported by a $icode Base$$ type;
     
    238242        CPPAD_BASE_ADOLC_NO_SUPPORT(erf)
    239243# endif
     244# if CPPAD_COMPILER_HAS_ASINH
     245        CPPAD_BASE_ADOLC_NO_SUPPORT(asinh)
     246# endif
    240247# if CPPAD_COMPILER_HAS_ACOSH
    241248        CPPAD_BASE_ADOLC_NO_SUPPORT(acosh)
    242249# endif
    243 # if CPPAD_COMPILER_HAS_ASINH
    244         CPPAD_BASE_ADOLC_NO_SUPPORT(asinh)
     250# if CPPAD_COMPILER_HAS_ATANH
     251        CPPAD_BASE_ADOLC_NO_SUPPORT(atanh)
    245252# endif
    246253# undef CPPAD_BASE_ADOLC_NO_SUPPORT
  • trunk/cppad/local/acosh_op.hpp

    r3680 r3682  
    127127        size_t m = (q-1) * r + 1;
    128128        for(ell = 0; ell < r; ell ++)
    129         {       Base uq = - 2.0 * x[m + ell] * x[0];
     129        {       Base uq = 2.0 * x[m + ell] * x[0];
    130130                for(k = 1; k < q; k++)
    131131                        uq += x[(k-1)*r+1+ell] * x[(q-k-1)*r+1+ell];
  • trunk/cppad/local/ad.hpp

    r3680 r3682  
    206206        inline AD tan(void) const;
    207207        inline AD tanh(void) const;
     208# if CPPAD_COMPILER_HAS_ERF
     209        inline AD erf(void) const;
     210# endif
    208211# if CPPAD_COMPILER_HAS_ASINH
    209212        inline AD asinh(void) const;
    210213# endif
    211 # if CPPAD_COMPILER_HAS_ERF
    212         inline AD erf(void) const;
    213 # endif
    214214# if CPPAD_COMPILER_HAS_ACOSH
    215215        inline AD acosh(void) const;
     216# endif
     217# if CPPAD_COMPILER_HAS_ATANH
     218        inline AD atanh(void) const;
    216219# endif
    217220
  • trunk/cppad/local/base_complex.hpp

    r3680 r3682  
    2222$begin base_complex.hpp$$
    2323$spell
     24        atanh
    2425        acosh
    2526        asinh
     
    168169/* $$
    169170
    170 $head erf$$
    171 Complex types do not support the error function
    172 (use CPPAD_USER_MACRO define above).
    173 $codep */
    174 # if CPPAD_COMPILER_HAS_ERF
    175 namespace CppAD {
    176         CPPAD_USER_MACRO(erf)
    177 }
    178 # endif
    179 /* $$
    180 
    181 
    182171$head Integer$$
    183172The implementation of this function must agree
     
    246235        CPPAD_USER_MACRO(atan)
    247236        CPPAD_USER_MACRO(sign)
     237# if CPPAD_COMPILER_HAS_ERF
     238        CPPAD_USER_MACRO(erf)
     239# endif
    248240# if CPPAD_COMPILER_HAS_ASINH
    249241        CPPAD_USER_MACRO(asinh)
     
    251243# if CPPAD_COMPILER_HAS_ACOSH
    252244        CPPAD_USER_MACRO(acosh)
     245# endif
     246# if CPPAD_COMPILER_HAS_ATANH
     247        CPPAD_USER_MACRO(atanh)
    253248# endif
    254249}
  • trunk/cppad/local/base_double.hpp

    r3680 r3682  
    1818$begin base_double.hpp$$
    1919$spell
     20        atanh
    2021        acosh
    2122        asinh
     
    148149        CPPAD_STANDARD_MATH_UNARY(double, tan)
    149150        CPPAD_STANDARD_MATH_UNARY(double, tanh)
     151# if CPPAD_COMPILER_HAS_ERF
     152        CPPAD_STANDARD_MATH_UNARY(double, erf)
     153# endif
    150154# if CPPAD_COMPILER_HAS_ASINH
    151155        CPPAD_STANDARD_MATH_UNARY(double, asinh)
     
    154158        CPPAD_STANDARD_MATH_UNARY(double, acosh)
    155159# endif
    156 # if CPPAD_COMPILER_HAS_ERF
    157         CPPAD_STANDARD_MATH_UNARY(double, erf)
     160# if CPPAD_COMPILER_HAS_ATANH
     161        CPPAD_STANDARD_MATH_UNARY(double, atanh)
    158162# endif
    159163}
  • trunk/cppad/local/base_float.hpp

    r3680 r3682  
    1818$begin base_float.hpp$$
    1919$spell
     20        atanh
    2021        acosh
    2122        asinh
     
    149150        CPPAD_STANDARD_MATH_UNARY(float, tan)
    150151        CPPAD_STANDARD_MATH_UNARY(float, tanh)
     152# if CPPAD_COMPILER_HAS_ERF
     153        CPPAD_STANDARD_MATH_UNARY(float, erf)
     154# endif
    151155# if CPPAD_COMPILER_HAS_ASINH
    152156        CPPAD_STANDARD_MATH_UNARY(float, asinh)
     
    155159        CPPAD_STANDARD_MATH_UNARY(float, acosh)
    156160# endif
    157 # if CPPAD_COMPILER_HAS_ERF
    158         CPPAD_STANDARD_MATH_UNARY(float, erf)
     161# if CPPAD_COMPILER_HAS_ATANH
     162        CPPAD_STANDARD_MATH_UNARY(float, atanh)
    159163# endif
    160164}
  • trunk/cppad/local/base_std_math.hpp

    r3680 r3682  
    1717$begin base_std_math$$
    1818$spell
     19        atanh
    1920        acosh
    2021        asinh
     
    9293$cref/float/base_float.hpp/Unary Standard Math/$$.
    9394
    94 $head erf, asinh, acosh$$
     95$head erf, asinh, acosh, atanh$$
    9596The following preprocessor symbols are one (true) and zero (false)
    9697if the corresponding function is supported by the compiler.
     
    9899$icode%fun%   %$$ $cnext  $icode symbol$$                $rnext
    99100$code erf$$       $cnext  $code CPPAD_COMPILER_HAS_ERF$$ $rnext
    100 $code asinh$$     $cnext  $code CPPAD_COMPILER_HAS_ASINH$$
    101 $code acosh$$     $cnext  $code CPPAD_COMPILER_HAS_ACOSH$$
     101$code asinh$$     $cnext  $code CPPAD_COMPILER_HAS_ASINH$$ $rnext
     102$code acosh$$     $cnext  $code CPPAD_COMPILER_HAS_ACOSH$$ $rnext
     103$code atanh$$     $cnext  $code CPPAD_COMPILER_HAS_ATANH$$
    102104$tend
    103105If the corresponding symbol is true,
     
    108110where $icode x$$ and $icode y$$ have the same prototype as above.
    109111For example, see
    110 $cref/base_alloc/base_alloc.hpp/erf, asinh, acosh/$$.
     112$cref/base_alloc/base_alloc.hpp/erf, asinh, acosh, atanh/$$.
    111113
    112114$head sign$$
  • trunk/cppad/local/for_jac_sweep.hpp

    r3680 r3682  
    270270                        );
    271271                        break;
     272                        // -------------------------------------------------
     273
     274# if CPPAD_COMPILER_HAS_ATANH
     275                        case AtanhOp:
     276                        // 1 - x * x, atanh(x)
     277                        CPPAD_ASSERT_NARG_NRES(op, 1, 2);
     278                        forward_sparse_jacobian_unary_op(
     279                                i_var, arg[0], var_sparsity
     280                        );
     281                        break;
     282# endif
    272283                        // -------------------------------------------------
    273284
  • trunk/cppad/local/forward0sweep.hpp

    r3680 r3682  
    342342                        // -------------------------------------------------
    343343
     344# if CPPAD_COMPILER_HAS_ATANH
     345                        case AtanhOp:
     346                        // 1 - x * x, atanh(x)
     347                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
     348                        forward_atanh_op_0(i_var, arg[0], J, taylor);
     349                        break;
     350# endif
     351                        // -------------------------------------------------
     352
    344353                        case CExpOp:
    345354                        // Use the general case with d == 0
  • trunk/cppad/local/forward1sweep.hpp

    r3680 r3682  
    390390                        forward_atan_op(p, q, i_var, arg[0], J, taylor);
    391391                        break;
     392                        // -------------------------------------------------
     393
     394# if CPPAD_COMPILER_HAS_ATANH
     395                        case AtanhOp:
     396                        // 1 - x * x, atanh(x)
     397                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
     398                        forward_atanh_op(p, q, i_var, arg[0], J, taylor);
     399                        break;
     400# endif
    392401                        // -------------------------------------------------
    393402
  • trunk/cppad/local/forward2sweep.hpp

    r3680 r3682  
    299299                        forward_atan_op_dir(q, r, i_var, arg[0], J, taylor);
    300300                        break;
     301                        // -------------------------------------------------
     302
     303# if CPPAD_COMPILER_HAS_ATANH
     304                        case AtanhOp:
     305                        // 1 - x * x, atanh(x)
     306                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
     307                        forward_atanh_op_dir(q, r, i_var, arg[0], J, taylor);
     308                        break;
     309# endif
    301310                        // -------------------------------------------------
    302311
  • trunk/cppad/local/hash_code.hpp

    r3680 r3682  
    8080
    8181\li unary operators:
    82 AbsOp, AcosOp, AcoshOp, AsinOp, AsinhOp, AtanOp, CosOp, CoshOp
     82AbsOp, AcosOp, AcoshOp, AsinOp, AsinhOp, AtanOp, AtanhOp, CosOp, CoshOp
    8383ExpOp, LogOp, SinOp, SinhOp, SqrtOp, TanOp, TanhOp
    8484
     
    218218                case AsinhOp:
    219219                case AtanOp:
     220                case AtanhOp:
    220221                case CosOp:
    221222                case CoshOp:
  • trunk/cppad/local/math_other.hpp

    r3680 r3682  
    2727$childtable%
    2828        cppad/local/abs.hpp%
     29        cppad/local/erf.hpp%
    2930        cppad/local/asinh.hpp%
    3031        cppad/local/acosh.hpp%
     32        cppad/local/atanh.hpp%
    3133        cppad/local/sign.hpp%
    3234        cppad/local/atan2.hpp%
    33         cppad/local/erf.hpp%
    3435        cppad/local/pow.hpp%
    3536        cppad/local/limits.hpp
     
    4041
    4142# include <cppad/local/abs.hpp>
     43# include <cppad/local/erf.hpp>
    4244# include <cppad/local/asinh.hpp>
    4345# include <cppad/local/acosh.hpp>
     46# include <cppad/local/atanh.hpp>
    4447# include <cppad/local/sign.hpp>
    4548# include <cppad/local/atan2.hpp>
    46 # include <cppad/local/erf.hpp>
    4749# include <cppad/local/pow.hpp>
    4850
  • trunk/cppad/local/op.hpp

    r3680 r3682  
    2626# include <cppad/local/asinh_op.hpp>
    2727# include <cppad/local/atan_op.hpp>
     28# include <cppad/local/atanh_op.hpp>
    2829# include <cppad/local/comp_op.hpp>
    2930# include <cppad/local/cond_op.hpp>
  • trunk/cppad/local/op_code.hpp

    r3680 r3682  
    5656        AsinhOp,  // asinh(variable)
    5757        AtanOp,   // atan(variable)
     58        AtanhOp,   // atanh(variable)
    5859        BeginOp,  // used to mark the beginning of the tape
    5960        CExpOp,   // CondExpRel(left, right, trueCase, falseCase)
     
    177178                1, // AsinhOp
    178179                1, // AtanOp
     180                1, // AtanhOp
    179181                1, // BeginOp  offset first real argument to have index 1
    180182                6, // CExpOp
     
    279281                2, // AsinhOp
    280282                2, // AtanOp
     283                2, // AtanhOp
    281284                1, // BeginOp  offsets first variable to have index one (not zero)
    282285                1, // CExpOp
     
    364367                "Asinh"  ,
    365368                "Atan"  ,
     369                "Atanh" ,
    366370                "Begin" ,
    367371                "CExp"  ,
     
    692696                case AsinhOp:
    693697                case AtanOp:
     698                case AtanhOp:
    694699                case CosOp:
    695700                case CoshOp:
     
    890895                case AsinhOp:
    891896                case AtanOp:
     897                case AtanhOp:
    892898                case CosOp:
    893899                case CoshOp:
  • trunk/cppad/local/optimize.hpp

    r3680 r3682  
    15501550                        case AsinhOp:
    15511551                        case AtanOp:
     1552                        case AtanhOp:
    15521553                        case CosOp:
    15531554                        case CoshOp:
     
    23152316                        case AsinhOp:
    23162317                        case AtanOp:
     2318                        case AtanhOp:
    23172319                        case CosOp:
    23182320                        case CoshOp:
  • trunk/cppad/local/rev_hes_sweep.hpp

    r3680 r3682  
    292292                        );
    293293                        break;
     294                        // -------------------------------------------------
     295
     296# if CPPAD_COMPILER_HAS_ATANH
     297                        case AtanhOp:
     298                        // 1 - x * x, atanh(x)
     299                        CPPAD_ASSERT_NARG_NRES(op, 1, 2)
     300                        reverse_sparse_hessian_nonlinear_unary_op(
     301                        i_var, arg[0], RevJac, for_jac_sparse, rev_hes_sparse
     302                        );
     303                        break;
     304# endif
    294305                        // -------------------------------------------------
    295306
  • trunk/cppad/local/rev_jac_sweep.hpp

    r3680 r3682  
    281281                        );
    282282                        break;
     283                        // -------------------------------------------------
     284
     285# if CPPAD_COMPILER_HAS_ATANH
     286                        case AtanhOp:
     287                        // 1 - x * x, atanh(x)
     288                        CPPAD_ASSERT_NARG_NRES(op, 1, 2);
     289                        reverse_sparse_jacobian_unary_op(
     290                                i_var, arg[0], var_sparsity
     291                        );
     292                        break;
     293# endif
    283294                        // -------------------------------------------------
    284295
  • trunk/cppad/local/reverse_sweep.hpp

    r3680 r3682  
    364364                        // -------------------------------------------------
    365365
     366# if CPPAD_COMPILER_HAS_ATANH
     367                        case AtanhOp:
     368                        // 1 - x * x, atanh(x)
     369                        CPPAD_ASSERT_UNKNOWN( i_var < numvar );
     370                        reverse_atanh_op(
     371                                d, i_var, arg[0], J, Taylor, K, Partial
     372                        );
     373                        break;
     374# endif
     375                        // -------------------------------------------------
     376
    366377                        case BeginOp:
    367378                        CPPAD_ASSERT_NARG_NRES(op, 1, 1);
  • trunk/cppad/local/std_math_ad.hpp

    r3680 r3682  
    1717$begin std_math_ad$$
    1818$spell
    19         acosh
    2019        Vec
    2120        std
     
    322321     CPPAD_STANDARD_MATH_UNARY_AD(acosh, AcoshOp)
    323322# endif
     323# if CPPAD_COMPILER_HAS_ATANH
     324     CPPAD_STANDARD_MATH_UNARY_AD(atanh, AtanhOp)
     325# endif
    324326
    325327# if CPPAD_COMPILER_HAS_ERF
  • trunk/cppad/local/undef.hpp

    r3680 r3682  
    2626# undef CPPAD_BOOL_BINARY         in user api
    2727# undef CPPAD_BOOL_UNARY          in user api
     28# undef CPPAD_COMPILER_HAS_ERF    in user api
    2829# undef CPPAD_COMPILER_HAS_ASINH  in user api
    2930# undef CPPAD_COMPILER_HAS_ACOSH  in user api
    30 # undef CPPAD_COMPILER_HAS_ERF    in user api
     31# undef CPPAD_COMPILER_HAS_ATANH  in user api
    3132# undef CPPAD_DISCRETE_FUNCTION   in user api
    3233# undef CPPAD_EIGENVECTOR         in user api
  • trunk/cppad_ipopt/example/makefile.in

    r3679 r3682  
    280280cppad_SOURCE_DIR = @cppad_SOURCE_DIR@
    281281cppad_boostvector = @cppad_boostvector@
     282cppad_compiler_has_acosh = @cppad_compiler_has_acosh@
    282283cppad_compiler_has_asinh = @cppad_compiler_has_asinh@
     284cppad_compiler_has_atanh = @cppad_compiler_has_atanh@
    283285cppad_compiler_has_erf = @cppad_compiler_has_erf@
    284286cppad_cppadvector = @cppad_cppadvector@
  • trunk/cppad_ipopt/speed/makefile.in

    r3679 r3682  
    282282cppad_SOURCE_DIR = @cppad_SOURCE_DIR@
    283283cppad_boostvector = @cppad_boostvector@
     284cppad_compiler_has_acosh = @cppad_compiler_has_acosh@
    284285cppad_compiler_has_asinh = @cppad_compiler_has_asinh@
     286cppad_compiler_has_atanh = @cppad_compiler_has_atanh@
    285287cppad_compiler_has_erf = @cppad_compiler_has_erf@
    286288cppad_cppadvector = @cppad_cppadvector@
  • trunk/cppad_ipopt/src/makefile.in

    r3679 r3682  
    318318cppad_SOURCE_DIR = @cppad_SOURCE_DIR@
    319319cppad_boostvector = @cppad_boostvector@
     320cppad_compiler_has_acosh = @cppad_compiler_has_acosh@
    320321cppad_compiler_has_asinh = @cppad_compiler_has_asinh@
     322cppad_compiler_has_atanh = @cppad_compiler_has_atanh@
    321323cppad_compiler_has_erf = @cppad_compiler_has_erf@
    322324cppad_cppadvector = @cppad_cppadvector@
  • trunk/cppad_ipopt/test/makefile.in

    r3679 r3682  
    268268cppad_SOURCE_DIR = @cppad_SOURCE_DIR@
    269269cppad_boostvector = @cppad_boostvector@
     270cppad_compiler_has_acosh = @cppad_compiler_has_acosh@
    270271cppad_compiler_has_asinh = @cppad_compiler_has_asinh@
     272cppad_compiler_has_atanh = @cppad_compiler_has_atanh@
    271273cppad_compiler_has_erf = @cppad_compiler_has_erf@
    272274cppad_cppadvector = @cppad_cppadvector@
  • trunk/example/CMakeLists.txt

    r3680 r3682  
    8989        asinh.cpp
    9090        atan.cpp
     91        atanh.cpp
    9192        atan2.cpp
    9293        base_alloc.hpp
  • trunk/example/atan.cpp

    r2506 r3682  
    11/* $Id$ */
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
    6 the terms of the 
     6the terms of the
    77                    Eclipse Public License Version 1.0.
    88
     
    3434# include <cppad/cppad.hpp>
    3535
    36 bool Atan(void)
     36bool atan(void)
    3737{       bool ok = true;
    3838
     
    5252        AD<double> tan_of_x0 = CppAD::tan(x[0]);
    5353
    54         // range space vector 
     54        // range space vector
    5555        size_t m = 1;
    5656        CPPAD_TESTVECTOR(AD<double>) y(m);
     
    5858
    5959        // create f: x -> y and stop tape recording
    60         CppAD::ADFun<double> f(x, y); 
     60        CppAD::ADFun<double> f(x, y);
    6161
    62         // check value 
     62        // check value
    6363        ok &= NearEqual(y[0] , x0,  1e-10 , 1e-10);
    6464
  • trunk/example/atan2.cpp

    r2506 r3682  
    11/* $Id$ */
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
    6 the terms of the 
     6the terms of the
    77                    Eclipse Public License Version 1.0.
    88
     
    3434# include <cppad/cppad.hpp>
    3535
    36 bool Atan2(void)
     36bool atan2(void)
    3737{       bool ok = true;
    3838
     
    5353        AD<double> cos_of_x0 = CppAD::cos(x[0]);
    5454
    55         // range space vector 
     55        // range space vector
    5656        size_t m = 1;
    5757        CPPAD_TESTVECTOR(AD<double>) y(m);
     
    5959
    6060        // create f: x -> y and stop tape recording
    61         CppAD::ADFun<double> f(x, y); 
     61        CppAD::ADFun<double> f(x, y);
    6262
    63         // check value 
     63        // check value
    6464        ok &= NearEqual(y[0] , x0,  1e-10 , 1e-10);
    6565
  • trunk/example/atomic/makefile.in

    r3679 r3682  
    279279cppad_SOURCE_DIR = @cppad_SOURCE_DIR@
    280280cppad_boostvector = @cppad_boostvector@
     281cppad_compiler_has_acosh = @cppad_compiler_has_acosh@
    281282cppad_compiler_has_asinh = @cppad_compiler_has_asinh@
     283cppad_compiler_has_atanh = @cppad_compiler_has_atanh@
    282284cppad_compiler_has_erf = @cppad_compiler_has_erf@
    283285cppad_cppadvector = @cppad_cppadvector@
  • trunk/example/base_alloc.hpp

    r3680 r3682  
    1515$begin base_alloc.hpp$$
    1616$spell
     17        atanh
    1718        acosh
    1819        asinh
     
    303304/* $$
    304305
    305 $head erf, asinh, acosh$$
     306$head erf, asinh, acosh, atanh$$
    306307The following defines the
    307 $cref/erf, asinh, acosh/base_std_math/erf, asinh, acosh/$$ functions
     308$cref/erf, asinh, acosh, atanh
     309        /base_std_math
     310        /erf, asinh, acosh, atanh
     311/$$ functions
    308312required by $code AD<base_alloc>$$:
    309313$codep */
     
    311315        BASE_ALLOC_STD_MATH(erf)
    312316# endif
     317# if CPPAD_COMPILER_HAS_ASINH
     318        BASE_ALLOC_STD_MATH(asinh)
     319# endif
    313320# if CPPAD_COMPILER_HAS_ACOSH
    314321        BASE_ALLOC_STD_MATH(acosh)
    315322# endif
    316 # if CPPAD_COMPILER_HAS_ASINH
    317         BASE_ALLOC_STD_MATH(asinh)
     323# if CPPAD_COMPILER_HAS_ATANH
     324        BASE_ALLOC_STD_MATH(atanh)
    318325# endif
    319326/* $$
  • trunk/example/example.cpp

    r3680 r3682  
    5959extern bool asin(void);
    6060extern bool asinh(void);
    61 extern bool Atan(void);
    62 extern bool Atan2(void);
     61extern bool atan(void);
     62extern bool atanh(void);
     63extern bool atan2(void);
    6364extern bool base_require(void);
    6465extern bool BenderQuad(void);
     
    224225        ok &= Run( asin,              "asin"             );
    225226        ok &= Run( asinh,             "asinh"            );
    226         ok &= Run( Atan,              "Atan"             );
    227         ok &= Run( Atan2,             "Atan2"            );
     227        ok &= Run( atan,              "atan"             );
     228        ok &= Run( atanh,             "atanh"            );
     229        ok &= Run( atan2,             "atan2"            );
    228230        ok &= Run( BenderQuad,        "BenderQuad"       );
    229231        ok &= Run( BoolFun,           "BoolFun"          );
  • trunk/example/ipopt_solve/makefile.in

    r3679 r3682  
    267267cppad_SOURCE_DIR = @cppad_SOURCE_DIR@
    268268cppad_boostvector = @cppad_boostvector@
     269cppad_compiler_has_acosh = @cppad_compiler_has_acosh@
    269270cppad_compiler_has_asinh = @cppad_compiler_has_asinh@
     271cppad_compiler_has_atanh = @cppad_compiler_has_atanh@
    270272cppad_compiler_has_erf = @cppad_compiler_has_erf@
    271273cppad_cppadvector = @cppad_cppadvector@
  • trunk/example/makefile.am

    r3680 r3682  
    9595        asinh.cpp \
    9696        atan.cpp \
     97        atanh.cpp \
    9798        atan2.cpp \
    9899        base_alloc.hpp \
  • trunk/example/makefile.in

    r3681 r3682  
    106106        add.cpp add_eq.cpp ad_assign.cpp ad_ctor.cpp ad_fun.cpp \
    107107        ad_in_c.cpp ad_input.cpp ad_output.cpp asin.cpp asinh.cpp \
    108         atan.cpp atan2.cpp base_alloc.hpp base_require.cpp \
     108        atan.cpp atanh.cpp atan2.cpp base_alloc.hpp base_require.cpp \
    109109        bender_quad.cpp bool_fun.cpp capacity_order.cpp \
    110110        change_const.cpp check_for_nan.cpp check_numeric_type.cpp \
     
    143143        ad_assign.$(OBJEXT) ad_ctor.$(OBJEXT) ad_fun.$(OBJEXT) \
    144144        ad_in_c.$(OBJEXT) ad_input.$(OBJEXT) ad_output.$(OBJEXT) \
    145         asin.$(OBJEXT) asinh.$(OBJEXT) atan.$(OBJEXT) atan2.$(OBJEXT) \
    146         base_require.$(OBJEXT) bender_quad.$(OBJEXT) \
     145        asin.$(OBJEXT) asinh.$(OBJEXT) atan.$(OBJEXT) atanh.$(OBJEXT) \
     146        atan2.$(OBJEXT) base_require.$(OBJEXT) bender_quad.$(OBJEXT) \
    147147        bool_fun.$(OBJEXT) capacity_order.$(OBJEXT) \
    148148        change_const.$(OBJEXT) check_for_nan.$(OBJEXT) \
     
    381381cppad_SOURCE_DIR = @cppad_SOURCE_DIR@
    382382cppad_boostvector = @cppad_boostvector@
     383cppad_compiler_has_acosh = @cppad_compiler_has_acosh@
    383384cppad_compiler_has_asinh = @cppad_compiler_has_asinh@
     385cppad_compiler_has_atanh = @cppad_compiler_has_atanh@
    384386cppad_compiler_has_erf = @cppad_compiler_has_erf@
    385387cppad_cppadvector = @cppad_cppadvector@
     
    509511        asinh.cpp \
    510512        atan.cpp \
     513        atanh.cpp \
    511514        atan2.cpp \
    512515        base_alloc.hpp \
     
    698701@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/atan.Po@am__quote@
    699702@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/atan2.Po@am__quote@
     703@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/atanh.Po@am__quote@
    700704@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/base_require.Po@am__quote@
    701705@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/bender_quad.Po@am__quote@
  • trunk/introduction/exp_apx/makefile.in

    r3679 r3682  
    281281cppad_SOURCE_DIR = @cppad_SOURCE_DIR@
    282282cppad_boostvector = @cppad_boostvector@
     283cppad_compiler_has_acosh = @cppad_compiler_has_acosh@
    283284cppad_compiler_has_asinh = @cppad_compiler_has_asinh@
     285cppad_compiler_has_atanh = @cppad_compiler_has_atanh@
    284286cppad_compiler_has_erf = @cppad_compiler_has_erf@
    285287cppad_cppadvector = @cppad_cppadvector@
  • trunk/introduction/get_started/makefile.in

    r3679 r3682  
    264264cppad_SOURCE_DIR = @cppad_SOURCE_DIR@
    265265cppad_boostvector = @cppad_boostvector@
     266cppad_compiler_has_acosh = @cppad_compiler_has_acosh@
    266267cppad_compiler_has_asinh = @cppad_compiler_has_asinh@
     268cppad_compiler_has_atanh = @cppad_compiler_has_atanh@
    267269cppad_compiler_has_erf = @cppad_compiler_has_erf@
    268270cppad_cppadvector = @cppad_cppadvector@
  • trunk/makefile.am

    r3680 r3682  
    145145        cppad/local/atan2.hpp \
    146146        cppad/local/atan_op.hpp \
     147        cppad/local/atanh.hpp \
     148        cppad/local/atanh_op.hpp \
    147149        cppad/local/atomic_base.hpp \
    148150        cppad/local/base_complex.hpp \
  • trunk/makefile.in

    r3681 r3682  
    335335cppad_SOURCE_DIR = @cppad_SOURCE_DIR@
    336336cppad_boostvector = @cppad_boostvector@
     337cppad_compiler_has_acosh = @cppad_compiler_has_acosh@
    337338cppad_compiler_has_asinh = @cppad_compiler_has_asinh@
     339cppad_compiler_has_atanh = @cppad_compiler_has_atanh@
    338340cppad_compiler_has_erf = @cppad_compiler_has_erf@
    339341cppad_cppadvector = @cppad_cppadvector@
     
    525527        cppad/local/atan2.hpp \
    526528        cppad/local/atan_op.hpp \
     529        cppad/local/atanh.hpp \
     530        cppad/local/atanh_op.hpp \
    527531        cppad/local/atomic_base.hpp \
    528532        cppad/local/base_complex.hpp \
  • trunk/multi_thread/makefile.in

    r3679 r3682  
    305305cppad_SOURCE_DIR = @cppad_SOURCE_DIR@
    306306cppad_boostvector = @cppad_boostvector@
     307cppad_compiler_has_acosh = @cppad_compiler_has_acosh@
    307308cppad_compiler_has_asinh = @cppad_compiler_has_asinh@
     309cppad_compiler_has_atanh = @cppad_compiler_has_atanh@
    308310cppad_compiler_has_erf = @cppad_compiler_has_erf@
    309311cppad_cppadvector = @cppad_cppadvector@
  • trunk/multi_thread/test_multi/makefile.in

    r3679 r3682  
    263263cppad_SOURCE_DIR = @cppad_SOURCE_DIR@
    264264cppad_boostvector = @cppad_boostvector@
     265cppad_compiler_has_acosh = @cppad_compiler_has_acosh@
    265266cppad_compiler_has_asinh = @cppad_compiler_has_asinh@
     267cppad_compiler_has_atanh = @cppad_compiler_has_atanh@
    266268cppad_compiler_has_erf = @cppad_compiler_has_erf@
    267269cppad_cppadvector = @cppad_cppadvector@
  • trunk/omh/theory/acos_forward.omh

    r3680 r3682  
    5252$latex D [ X (t) ] $$,
    5353and $latex F [ X(t) ] $$ respectively.
    54 $pre
    5554
    56 $$
     55$head Taylor Coefficients Recursion$$
    5756We define $latex Q(x) = \mp ( x * x - 1 )$$
    5857and let $latex q$$ be the corresponding Taylor coefficients for
  • trunk/omh/theory/asin_forward.omh

    r3680 r3682  
    5151$latex D [ X (t) ] $$,
    5252and $latex F [ X(t) ] $$ respectively.
    53 $pre
    5453
    55 $$
     54$head Taylor Coefficients Recursion$$
    5655We define $latex Q(x) = 1 \mp x * x$$
    5756and let $latex q$$ be the corresponding Taylor coefficients for
  • trunk/omh/theory/atan_forward.omh

    r3169 r3682  
    22// BEGIN SHORT COPYRIGHT
    33/* --------------------------------------------------------------------------
    4 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
     4CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
    55
    66CppAD is distributed under multiple licenses. This distribution is under
    7 the terms of the 
     7the terms of the
    88                    Eclipse Public License Version 1.0.
    99
     
    1313// END SHORT COPYRIGHT
    1414
    15 $begin AtanForward$$
     15$begin atan_forward$$
    1616$spell
    1717        atan
    18         Arctangent
     18        atanh
    1919        Taylor
    2020$$
    2121
    22 $index atan, forward theory$$
    23 $index theory, atan forward$$
    24 $index forward, atan theory$$
     22$section Inverse Tangent and Hyperbolic Tangent Forward Mode Theory$$
     23$mindex atan, atanh$$
    2524
    26 $section Arctangent Function Forward Taylor Polynomial Theory$$
    27 
    28 If $latex F(x) = \arctan(x) $$
     25$head Derivatives$$
    2926$latex \[
    30         (1 + x * x ) * F^{(1)} (x) - 0 * F (x)  = 1
     27\begin{array}{rcl}
     28\R{atan}^{(1)} (x)  & = & 1 / ( 1 + x * x )
     29\\
     30\R{atanh}^{(1)} (x) & = & 1 / ( 1 - x * x )
     31\end{array}
     32\] $$
     33If $latex F(x)$$ is $latex \R{atan} (x)$$ or $latex \R{atanh} (x)$$,
     34the corresponding derivative satisfies the equation
     35$latex \[
     36        (1 \pm x * x ) * F^{(1)} (x) - 0 * F (x)  = 1
    3137\] $$
    3238and in the
    33 $xref/
    34         ForwardTheory/
    35         Standard Math Functions/
    36         Differential Equation/
    37         standard math function differential equation/
    38         1
     39$cref/standard math function differential equation
     40        /ForwardTheory
     41        /Standard Math Functions
     42        /Differential Equation
    3943/$$,
    4044$latex A(x) = 0$$,
    41 $latex B(x) = 1 + x * x $$,
     45$latex B(x) = 1 \pm x * x $$,
    4246and $latex D(x) = 1$$.
    43 We use $latex a$$, $latex b$$, $latex d$$ and $latex z$$ to denote the 
     47We use $latex a$$, $latex b$$, $latex d$$ and $latex z$$ to denote the
    4448Taylor coefficients for
    45 $latex A [ X (t) ] $$, 
    46 $latex B [ X (t) ]$$, 
     49$latex A [ X (t) ] $$,
     50$latex B [ X (t) ]$$,
    4751$latex D [ X (t) ] $$,
    4852and $latex F [ X(t) ] $$ respectively.
    49 It now follows from the general
    50 $xref/
    51         ForwardTheory/
    52         Standard Math Functions/
    53         Taylor Coefficients Recursion Formula/
    54         Taylor coefficients recursion formula/
    55         1
    56 /$$
    57 that for $latex j = 0 , 1, \ldots$$,
     53
     54$head Taylor Coefficients Recursion$$
     55For $latex j = 0 , 1, \ldots$$,
    5856$latex \[
    5957\begin{array}{rcl}
    60 z^{(0)} & = & \arctan ( x^{(0)} )
     58z^{(0)} & = & F( x^{(0)} )
    6159\\
    6260b^{(j)}
    6361& = &  \left\{ \begin{array}{ll}
    64         1 + x^{(0)} * x^{(0)}          & {\rm if} \; j = 0 \\
    65         \sum_{k=0}^j x^{(k)} x^{(j-k)} & {\rm otherwise}
     62        1 \pm x^{(0)} * x^{(0)}            & {\rm if} \; j = 0 \\
     63        \pm \sum_{k=0}^j x^{(k)} x^{(j-k)} & {\rm otherwise}
    6664\end{array} \right.
    6765\\
    68 e^{(j)} 
     66e^{(j)}
    6967& = & d^{(j)} + \sum_{k=0}^{j} a^{(j-k)} * z^{(k)}
    7068\\
     
    7472\end{array} \right.
    7573\\
    76 z^{(j+1)} & = & \frac{1}{j+1} \frac{1}{ b^{(0)} } 
     74z^{(j+1)} & = & \frac{1}{j+1} \frac{1}{ b^{(0)} }
    7775\left(
    78         \sum_{k=0}^j e^{(k)} (j+1-k) x^{(j+1-k)} 
    79         - \sum_{k=1}^j b^{(k)} (j+1-k) z^{(j+1-k)} 
     76        \sum_{k=0}^j e^{(k)} (j+1-k) x^{(j+1-k)}
     77        - \sum_{k=1}^j b^{(k)} (j+1-k) z^{(j+1-k)}
    8078\right)
    8179\\
    82 z^{(j+1)} & = & \frac{1}{j+1} \frac{1}{ b^{(0)} } 
     80z^{(j+1)} & = & \frac{1}{j+1} \frac{1}{ b^{(0)} }
    8381\left(
    8482        (j+1) x^{(j+1)}
    85         - \sum_{k=1}^j k z^{(k)}  b^{(j+1-k)} 
     83        - \sum_{k=1}^j k z^{(k)}  b^{(j+1-k)}
    8684\right)
    8785\end{array}
    88 \] $$ 
     86\] $$
    8987
    9088$end
  • trunk/omh/theory/atan_reverse.omh

    r3169 r3682  
    22// BEGIN SHORT COPYRIGHT
    33/* --------------------------------------------------------------------------
    4 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
     4CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
    55
    66CppAD is distributed under multiple licenses. This distribution is under
    7 the terms of the 
     7the terms of the
    88                    Eclipse Public License Version 1.0.
    99
     
    1313// END SHORT COPYRIGHT
    1414
    15 $begin AtanReverse$$
     15$begin atan_reverse$$
    1616$spell
    17         Arctangent
    1817        atan
     18        atanh
    1919        Taylor
    2020$$
    2121
    22 $index atan, reverse theory$$
    23 $index theory, atan reverse$$
    24 $index reverse, atan theory$$
    25 
    26 $section Arctangent Function Reverse Mode Theory$$
     22$section Inverse Tangent and Hyperbolic Tangent Reverse Mode Theory$$
    2723
    2824
    2925We use the reverse theory
    30 $xref%
    31         ReverseTheory%
    32         Standard Math Functions%
    33         standard math function
     26$cref%standard math function
     27        %ReverseTheory
     28        %Standard Math Functions
    3429%$$
    3530definition for the functions $latex H$$ and $latex G$$.
    36 In addition,
    37 
    38 we use $latex b$$
    39 for the $th p$$ order Taylor coefficient
    40 row vectors corresponding to
    41 $latex 1 + X(t) * X(t)$$
     31In addition, we use the forward mode notation in
     32$cref atan_forward$$ for
     33$latex \[
     34        B(t) = 1 \pm X(t) * X(t)
     35\] $$
     36We use $latex b$$
     37for the $th p$$ order Taylor coefficient
     38row vectors corresponding to $latex B(t)$$
    4239and replace $latex z^{(j)}$$ by
    4340$latex \[
    4441        ( z^{(j)} , b^{(j)} )
    45 \] $$ 
     42\] $$
    4643in the definition for $latex G$$ and $latex H$$.
    47 The forward mode formulas for the
    48 $cref/arctangent/AtanForward/$$
     44The zero order forward mode formulas for the
     45$cref/atan/atan_forward/$$
    4946function are
    5047$latex \[
    5148\begin{array}{rcl}
    52         z^{(j)}  & = & \arctan ( x^{(0)} ) \\
    53         b^{(j)}  & = & 1 + x^{(0)} x^{(0)}
     49        z^{(0)}  & = & F ( x^{(0)} ) \\
     50        b^{(0)}  & = & 1 \pm x^{(0)} x^{(0)}
     51\end{array}
     52\] $$
     53where $latex F(x) = \R{atan} (x)$$ for $latex +$$
     54and $latex F(x) = \R{atanh} (x)$$ for $latex -$$.
     55For orders $latex j$$ greater than zero we have
     56$latex \[
     57\begin{array}{rcl}
     58b^{(j)} & = &
     59        \pm \sum_{k=0}^j x^{(k)} x^{(j-k)}
     60\\
     61z^{(j)} & = & \frac{1}{j} \frac{1}{ b^{(0)} }
     62\left(
     63        j x^{(j)}
     64        - \sum_{k=1}^{j-1} k z^{(k)}  b^{(j-k)}
     65\right)
    5466\end{array}
    5567\] $$
    5668
    57 for the case $latex j = 0$$, and for $latex j > 0$$,
    5869
     70If $latex j = 0$$, we note that
     71$latex F^{(1)} ( x^{(0)} ) =  1 / b^{(0)}$$ and hence
    5972$latex \[
    6073\begin{array}{rcl}
    61 b^{(j)} & = & 
    62         \sum_{k=0}^j x^{(k)} x^{(j-k)}
    63 \\
    64 z^{(j)} & = & \frac{1}{j} \frac{1}{ b^{(0)} }
    65 \left(
    66         j x^{(j)}
    67         - \sum_{k=1}^{j-1} k z^{(k)}  b^{(j-k)}
    68 \right)
    69 \end{array}
    70 \] $$
    71 
    72 If $latex j = 0$$, we have the relation
    73 
    74 $latex \[
    75 \begin{array}{rcl}
    76 \D{H}{ x^{(j)} } & = &
    77 \D{G}{ x^{(j)} } 
     74\D{H}{ x^{(j)} } & = &
     75\D{G}{ x^{(j)} }
    7876+ \D{G}{ z^{(j)} } \D{ z^{(j)} }{ x^{(0)} }
    7977+ \D{G}{ b^{(j)} } \D{ b^{(j)} }{ x^{(0)} }
    8078\\
    8179& = &
    82 \D{G}{ x^{(j)} } 
     80\D{G}{ x^{(j)} }
    8381+ \D{G}{ z^{(j)} } \frac{1}{ b^{(0)} }
    84 + \D{G}{ b^{(j)} } 2 x^{(0)}
     82\pm \D{G}{ b^{(j)} } 2 x^{(0)}
    8583\end{array}
    86 \] $$ 
     84\] $$
    8785
    8886If $latex j > 0$$, then for $latex k = 1, \ldots , j-1$$
    89 
    9087$latex \[
    9188\begin{array}{rcl}
    92 \D{H}{ b^{(0)} } & = & 
    93 \D{G}{ b^{(0)} } 
    94 - \D{G}{ z^{(j)} } \D{ z^{(j)} }{ b^{(0)} }
     89\D{H}{ b^{(0)} } & = &
     90\D{G}{ b^{(0)} }
     91+ \D{G}{ z^{(j)} } \D{ z^{(j)} }{ b^{(0)} }
    9592\\
    9693& = &
    97 \D{G}{ b^{(0)} } 
    98 - \D{G}{ z^{(j)} } \frac{ z^{(j)} }{ b^{(0)} } 
     94\D{G}{ b^{(0)} }
     95- \D{G}{ z^{(j)} } \frac{ z^{(j)} }{ b^{(0)} }
    9996\\
    100 \D{H}{ x^{(j)} } & = & 
    101 \D{G}{ x^{(j)} } 
     97\D{H}{ x^{(j)} } & = &
     98\D{G}{ x^{(j)} }
    10299+ \D{G}{ z^{(j)} } \D{ z^{(j)} }{ x^{(j)} }
    103100+ \D{G}{ b^{(j)} } \D{ b^{(j)} }{ x^{(j)} }
    104101\\
    105102& = &
    106 \D{G}{ x^{(j)} } 
     103\D{G}{ x^{(j)} }
    107104+ \D{G}{ z^{(j)} } \frac{1}{ b^{(0)} }
    108 + \D{G}{ b^{(j)} } 2 x^{(0)}
     105\pm \D{G}{ b^{(j)} } 2 x^{(0)}
    109106\\
    110 \D{H}{ x^{(0)} } & = & 
    111 \D{G}{ x^{(0)} } 
     107\D{H}{ x^{(0)} } & = &
     108\D{G}{ x^{(0)} }
    112109+ \D{G}{ z^{(j)} } \D{ z^{(j)} }{ x^{(0)} }
    113110+ \D{G}{ b^{(j)} } \D{ b^{(j)} }{ x^{(0)} }
    114111\\
    115 & = & 
    116 \D{G}{ x^{(0)} } +
    117 \D{G}{ b^{(j)} } 2 x^{(j)}
     112& = &
     113\D{G}{ x^{(0)} }
     114\pm \D{G}{ b^{(j)} } 2 x^{(j)}
    118115\\
    119 \D{H}{ x^{(k)} } & = & 
    120 \D{G}{ x^{(k)} } 
     116\D{H}{ x^{(k)} } & = &
     117\D{G}{ x^{(k)} }
    121118+ \D{G}{ z^{(j)} } \D{ z^{(j)} }{ x^{(k)} }
    122119+ \D{G}{ b^{(j)} } \D{ b^{(j)} }{ x^{(k)} }
    123120\\
    124 & = & 
    125 \D{G}{ x^{(k)} } 
    126 + \D{G}{ b^{(j)} } 2 x^{(j-k)}
     121& = &
     122\D{G}{ x^{(k)} }
     123\pm \D{G}{ b^{(j)} } 2 x^{(j-k)}
    127124\\
    128 \D{H}{ z^{(k)} } & = & 
    129 \D{G}{ z^{(k)} } 
     125\D{H}{ z^{(k)} } & = &
     126\D{G}{ z^{(k)} }
    130127+ \D{G}{ z^{(j)} } \D{ z^{(j)} }{ z^{(k)} }
    131128+ \D{G}{ b^{(j)} } \D{ b^{(j)} }{ z^{(k)} }
    132129\\
    133 & = & 
    134 \D{G}{ z^{(k)} } 
     130& = &
     131\D{G}{ z^{(k)} }
    135132- \D{G}{ z^{(j)} } \frac{k b^{(j-k)} }{ j b^{(0)} }
    136133\\
    137 \D{H}{ b^{(j-k)} } & = & 
    138 \D{G}{ b^{(j-k)} } 
     134\D{H}{ b^{(j-k)} } & = &
     135\D{G}{ b^{(j-k)} }
    139136+ \D{G}{ z^{(j)} } \D{ z^{(j)} }{ b^{(j-k)} }
    140137+ \D{G}{ b^{(j)} } \D{ b^{(j)} }{ b^{(j-k)} }
    141138\\
    142 & = & 
    143 \D{G}{ b^{(j-k)} } 
    144 - \D{G}{ z^{(j)} } \frac{k z^{(k)} }{ j b^{(0)} } 
     139& = &
     140\D{G}{ b^{(j-k)} }
     141- \D{G}{ z^{(j)} } \frac{k z^{(k)} }{ j b^{(0)} }
    145142\end{array}
    146 \] $$ 
     143\] $$
    147144
    148145$end
  • trunk/omh/theory/forward_theory.omh

    r3679 r3682  
    210210$rref SqrtForward$$
    211211$rref SinCosForward$$
    212 $rref AtanForward$$
     212$rref atan_forward$$
    213213$rref asin_forward$$
    214214$rref acos_forward$$
  • trunk/omh/whats_new/whats_new_15.omh

    r3680 r3682  
    1414$dollar @$$
    1515$spell
     16        atanh
    1617        acosh
    1718        asinh
     
    5152assist you in learning about changes between various versions of CppAD.
    5253
     54$head 05-08$$
     55$list number$$
     56Add the inverse hyperbolic sine function $cref atanh$$.
     57If you are defining your own base type,
     58note that $cref/atanh/base_std_math/erf, asinh, acosh, atanh/$$
     59was added to the base type requirements.
     60$lnext
     61Fix a bug in the implementation of the $code acosh$$
     62multiple direction forward mode $cref forward_dir$$
     63(when compiler has $cref/acosh/acosh/CPPAD_COMPILER_HAS_ACOSH/$$).
     64$lend
     65
    5366$head 05-07$$
    5467Add the inverse hyperbolic sine function $cref acosh$$.
    5568If you are defining your own base type,
    56 note that $cref/acosh/base_std_math/erf, asinh, acosh/$$
     69note that $cref/acosh/base_std_math/erf, asinh, acosh, atanh/$$
    5770was added to the base type requirements.
    5871
     
    6073Add the inverse hyperbolic sine function $cref asinh$$.
    6174If you are defining your own base type,
    62 note that $cref/asinh/base_std_math/erf, asinh, acosh/$$
     75note that $cref/asinh/base_std_math/erf, asinh, acosh, atanh/$$
    6376was added to the base type requirements.
    6477
  • trunk/print_for/makefile.in

    r3679 r3682  
    263263cppad_SOURCE_DIR = @cppad_SOURCE_DIR@
    264264cppad_boostvector = @cppad_boostvector@
     265cppad_compiler_has_acosh = @cppad_compiler_has_acosh@
    265266cppad_compiler_has_asinh = @cppad_compiler_has_asinh@
     267cppad_compiler_has_atanh = @cppad_compiler_has_atanh@
    266268cppad_compiler_has_erf = @cppad_compiler_has_erf@
    267269cppad_cppadvector = @cppad_cppadvector@
  • trunk/speed/adolc/makefile.in

    r3679 r3682  
    267267cppad_SOURCE_DIR = @cppad_SOURCE_DIR@
    268268cppad_boostvector = @cppad_boostvector@
     269cppad_compiler_has_acosh = @cppad_compiler_has_acosh@
    269270cppad_compiler_has_asinh = @cppad_compiler_has_asinh@
     271cppad_compiler_has_atanh = @cppad_compiler_has_atanh@
    270272cppad_compiler_has_erf = @cppad_compiler_has_erf@
    271273cppad_cppadvector = @cppad_cppadvector@
  • trunk/speed/cppad/makefile.in

    r3679 r3682  
    254254cppad_SOURCE_DIR = @cppad_SOURCE_DIR@
    255255cppad_boostvector = @cppad_boostvector@
     256cppad_compiler_has_acosh = @cppad_compiler_has_acosh@
    256257cppad_compiler_has_asinh = @cppad_compiler_has_asinh@
     258cppad_compiler_has_atanh = @cppad_compiler_has_atanh@
    257259cppad_compiler_has_erf = @cppad_compiler_has_erf@
    258260cppad_cppadvector = @cppad_cppadvector@
  • trunk/speed/double/makefile.in

    r3679 r3682  
    254254cppad_SOURCE_DIR = @cppad_SOURCE_DIR@
    255255cppad_boostvector = @cppad_boostvector@
     256cppad_compiler_has_acosh = @cppad_compiler_has_acosh@
    256257cppad_compiler_has_asinh = @cppad_compiler_has_asinh@
     258cppad_compiler_has_atanh = @cppad_compiler_has_atanh@
    257259cppad_compiler_has_erf = @cppad_compiler_has_erf@
    258260cppad_cppadvector = @cppad_cppadvector@
  • trunk/speed/example/makefile.in

    r3679 r3682  
    270270cppad_SOURCE_DIR = @cppad_SOURCE_DIR@
    271271cppad_boostvector = @cppad_boostvector@
     272cppad_compiler_has_acosh = @cppad_compiler_has_acosh@
    272273cppad_compiler_has_asinh = @cppad_compiler_has_asinh@
     274cppad_compiler_has_atanh = @cppad_compiler_has_atanh@
    273275cppad_compiler_has_erf = @cppad_compiler_has_erf@
    274276cppad_cppadvector = @cppad_cppadvector@
  • trunk/speed/fadbad/makefile.in

    r3679 r3682  
    255255cppad_SOURCE_DIR = @cppad_SOURCE_DIR@
    256256cppad_boostvector = @cppad_boostvector@
     257cppad_compiler_has_acosh = @cppad_compiler_has_acosh@
    257258cppad_compiler_has_asinh = @cppad_compiler_has_asinh@
     259cppad_compiler_has_atanh = @cppad_compiler_has_atanh@
    258260cppad_compiler_has_erf = @cppad_compiler_has_erf@
    259261cppad_cppadvector = @cppad_cppadvector@
  • trunk/speed/profile/makefile.in

    r3679 r3682  
    257257cppad_SOURCE_DIR = @cppad_SOURCE_DIR@
    258258cppad_boostvector = @cppad_boostvector@
     259cppad_compiler_has_acosh = @cppad_compiler_has_acosh@
    259260cppad_compiler_has_asinh = @cppad_compiler_has_asinh@
     261cppad_compiler_has_atanh = @cppad_compiler_has_atanh@
    260262cppad_compiler_has_erf = @cppad_compiler_has_erf@
    261263cppad_cppadvector = @cppad_cppadvector@
  • trunk/speed/sacado/makefile.in

    r3679 r3682  
    255255cppad_SOURCE_DIR = @cppad_SOURCE_DIR@
    256256cppad_boostvector = @cppad_boostvector@
     257cppad_compiler_has_acosh = @cppad_compiler_has_acosh@
    257258cppad_compiler_has_asinh = @cppad_compiler_has_asinh@
     259cppad_compiler_has_atanh = @cppad_compiler_has_atanh@
    258260cppad_compiler_has_erf = @cppad_compiler_has_erf@
    259261cppad_cppadvector = @cppad_cppadvector@
  • trunk/speed/src/makefile.in

    r3679 r3682  
    273273cppad_SOURCE_DIR = @cppad_SOURCE_DIR@
    274274cppad_boostvector = @cppad_boostvector@
     275cppad_compiler_has_acosh = @cppad_compiler_has_acosh@
    275276cppad_compiler_has_asinh = @cppad_compiler_has_asinh@
     277cppad_compiler_has_atanh = @cppad_compiler_has_atanh@
    276278cppad_compiler_has_erf = @cppad_compiler_has_erf@
    277279cppad_cppadvector = @cppad_cppadvector@
  • trunk/test_more/CMakeLists.txt

    r3680 r3682  
    7676        add_zero.cpp
    7777        atan.cpp
     78        atanh.cpp
    7879        atan2.cpp
    7980        base_alloc.cpp
  • trunk/test_more/atan.cpp

    r2506 r3682  
    11/* $Id$ */
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
    6 the terms of the 
     6the terms of the
    77                    Eclipse Public License Version 1.0.
    88
     
    3434        // some temporary values
    3535        AD<double> x = cos(U[s]);
    36         AD<double> y = sin(U[s]); 
     36        AD<double> y = sin(U[s]);
    3737        AD<double> z = y / x;       // tan(s)
    3838
     
    4545
    4646        // create f: U -> Z and vectors used for dierivative calculations
    47         ADFun<double> f(U, Z); 
     47        ADFun<double> f(U, Z);
    4848        CPPAD_TESTVECTOR(double) v( f.Domain() );
    4949        CPPAD_TESTVECTOR(double) w( f.Range() );
    5050
    51         // check value 
     51        // check value
    5252        ok &= NearEqual(U[s] , Z[a],  1e-10 , 1e-10);
    5353
     
    6767        v[s] = 0.;
    6868        w    = f.Forward(2, v);
    69         ok &= NearEqual(2. * w[a], 0e0, 1e-10 , 1e-10);     // d^2 a / (ds ds) 
     69        ok &= NearEqual(2. * w[a], 0e0, 1e-10 , 1e-10);     // d^2 a / (ds ds)
    7070
    7171        // reverse computation of second partials of a
     
    9292
    9393        // a temporary values
    94         AD<double> x = sin(U[0]) / cos(U[0]); 
     94        AD<double> x = sin(U[0]) / cos(U[0]);
    9595
    96         // dependent variable vector 
     96        // dependent variable vector
    9797        CPPAD_TESTVECTOR(AD<double>) Z(1);
    9898        Z[0] = atan(x); // atan( tan(u) )
    9999
    100100        // create f: U -> Z and vectors used for derivative calculations
    101         ADFun<double> f(U, Z); 
     101        ADFun<double> f(U, Z);
    102102        CPPAD_TESTVECTOR(double) v(1);
    103103        CPPAD_TESTVECTOR(double) w(1);
    104104
    105         // check value 
     105        // check value
    106106        ok &= NearEqual(U[0] , Z[0],  1e-10 , 1e-10);
    107107
     
    114114        for(j = 1; j < p; j++)
    115115        {       jfac *= j;
    116                 w     = f.Forward(j, v);       
     116                w     = f.Forward(j, v);
    117117                ok &= NearEqual(jfac*w[0], value, 1e-10 , 1e-10); // d^jz/du^j
    118118                v[0]  = 0.;
     
    121121
    122122        // reverse computation of partials of Taylor coefficients
    123         CPPAD_TESTVECTOR(double) r(p); 
     123        CPPAD_TESTVECTOR(double) r(p);
    124124        w[0]  = 1.;
    125125        r     = f.Reverse(p, w);
     
    137137} // END empty namespace
    138138
    139 bool Atan(void)
     139bool atan(void)
    140140{       bool ok = true;
    141141        ok &= AtanTestOne();
    142         ok &= AtanTestTwo(); 
     142        ok &= AtanTestTwo();
    143143        return ok;
    144144}
  • trunk/test_more/forward_dir.cpp

    r3583 r3682  
    44
    55CppAD is distributed under multiple licenses. This distribution is under
    6 the terms of the 
     6the terms of the
    77                    Eclipse Public License Version 1.0.
    88
     
    2121        using CppAD::NearEqual;
    2222        // ---------------------------------------------------------------------
    23         // Used the check that fun is an idenity funciton 
    24         typedef AD<double> (*adfun)(const AD<double>&); 
     23        // Used the check that fun is an idenity funciton
     24        typedef AD<double> (*adfun)(const AD<double>&);
    2525        bool check_identity(adfun identity, double argument)
    2626        {
     
    2929                size_t j;
    3030
    31        
     31
    3232                // domain space vector
    3333                size_t n = 1;
    3434                CPPAD_TESTVECTOR(AD<double>) ax(n);
    3535                ax[0] = argument;
    36        
    37                 // declare independent variables and starting recording
    38                 CppAD::Independent(ax);
    39        
     36
     37                // declare independent variables and starting recording
     38                CppAD::Independent(ax);
     39
    4040                // range space vector
    4141                size_t m = 1;
    4242                CPPAD_TESTVECTOR(AD<double>) ay(m);
    4343                ay[0] = identity(ax[0]);
    44        
    45                 // create f: x -> y and stop tape recording
    46                 CppAD::ADFun<double> f(ax, ay);
    47        
    48                 // first order Taylor coefficients
    49                 size_t r = 2, ell;
    50                 CPPAD_TESTVECTOR(double) x1(r*n), y1;
    51                 for(ell = 0; ell < r; ell++)
    52                 {       for(j = 0; j < n; j++)
    53                                 x1[ r * j + ell ] = double(j + ell + 1);
    54                 }
    55                 y1  = f.Forward(1, r, x1);
    56                 ok &= y1.size() == r*m;
    57                
    58                 // secondorder Taylor coefficients
    59                 CPPAD_TESTVECTOR(double) x2(r*n), y2;
    60                 for(ell = 0; ell < r; ell++)
    61                 {       for(j = 0; j < n; j++)
    62                                 x2[ r * j + ell ] = double(j + ell + 2);
    63                 }
    64                 y2  = f.Forward(2, r, x2);
    65                 ok &= y2.size() == r*m;
    66                 // 
     44
     45                // create f: x -> y and stop tape recording
     46                CppAD::ADFun<double> f(ax, ay);
     47
     48                // first order Taylor coefficients
     49                size_t r = 2, ell;
     50                CPPAD_TESTVECTOR(double) x1(r*n), y1;
     51                for(ell = 0; ell < r; ell++)
     52                {       for(j = 0; j < n; j++)
     53                                x1[ r * j + ell ] = double(j + ell + 1);
     54                }
     55                y1  = f.Forward(1, r, x1);
     56                ok &= y1.size() == r*m;
     57
     58                // secondorder Taylor coefficients
     59                CPPAD_TESTVECTOR(double) x2(r*n), y2;
     60                for(ell = 0; ell < r; ell++)
     61                {       for(j = 0; j < n; j++)
     62                                x2[ r * j + ell ] = double(j + ell + 2);
     63                }
     64                y2  = f.Forward(2, r, x2);
     65                ok &= y2.size() == r*m;
     66                //
    6767                // Y_0  (t)    = F[X_0(t)] = X_0(t)
    6868                //             =  0.5 + 1t + 2t^2
    6969                double y_1_0   = 1.0;
    7070                double y_2_0   = 2.0;
    71                 // 
    72                 // Y_1  (t)    = F[X_1(t)] = X_1(t) 
     71                //
     72                // Y_1  (t)    = F[X_1(t)] = X_1(t)
    7373                //             =  0.5 + 2t + 3t^2
    7474                double y_1_1   = 2.0;
     
    8383        }
    8484        // ---------------------------------------------------------------------
    85         // AbsOp 
     85        // AbsOp
    8686        bool abs_op(void)
    8787        {       bool ok = true;
    8888                double eps = 10. * std::numeric_limits<double>::epsilon();
    8989                size_t j;
    90        
     90
    9191                // domain space vector
    9292                size_t n = 2;
    9393                CPPAD_TESTVECTOR(AD<double>) ax(n);
    94                 ax[0] = 0.5; 
     94                ax[0] = 0.5;
    9595                ax[1] = -1.0;
    96        
    97                 // declare independent variables and starting recording
    98                 CppAD::Independent(ax);
    99        
     96
     97                // declare independent variables and starting recording
     98                CppAD::Independent(ax);
     99
    100100                // range space vector
    101101                size_t m = 1;
    102102                CPPAD_TESTVECTOR(AD<double>) ay(m);
    103103                ay[0] = abs( ax[0] ) + abs( 2.0 * ax[1] );
    104        
    105                 // create f: x -> y and stop tape recording
    106                 CppAD::ADFun<double> f(ax, ay);
    107        
    108                 // first order Taylor coefficients
    109                 size_t r = 2, ell;
    110                 CPPAD_TESTVECTOR(double) x1(r*n), y1;
    111                 for(ell = 0; ell < r; ell++)
    112                 {       for(j = 0; j < n; j++)
    113                                 x1[ r * j + ell ] = double(j + ell + 1);
    114                 }
    115                 y1  = f.Forward(1, r, x1);
    116                 ok &= y1.size() == r*m;
    117                
    118                 // secondorder Taylor coefficients
    119                 CPPAD_TESTVECTOR(double) x2(r*n), y2;
    120                 for(ell = 0; ell < r; ell++)
    121                 {       for(j = 0; j < n; j++)
    122                                 x2[ r * j + ell ] = double(j + ell + 2);
    123                 }
    124                 y2  = f.Forward(2, r, x2);
    125                 ok &= y2.size() == r*m;
    126                 // 
    127                 // Y_0  (t)    = F[X_0(t)] 
     104
     105                // create f: x -> y and stop tape recording
     106                CppAD::ADFun<double> f(ax, ay);
     107
     108                // first order Taylor coefficients
     109                size_t r = 2, ell;
     110                CPPAD_TESTVECTOR(double) x1(r*n), y1;
     111                for(ell = 0; ell < r; ell++)
     112                {       for(j = 0; j < n; j++)
     113                                x1[ r * j + ell ] = double(j + ell + 1);
     114                }
     115                y1  = f.Forward(1, r, x1);
     116                ok &= y1.size() == r*m;
     117
     118                // secondorder Taylor coefficients
     119                CPPAD_TESTVECTOR(double) x2(r*n), y2;
     120                for(ell = 0; ell < r; ell++)
     121                {       for(j = 0; j < n; j++)
     122                                x2[ r * j + ell ] = double(j + ell + 2);
     123                }
     124                y2  = f.Forward(2, r, x2);
     125                ok &= y2.size() == r*m;
     126                //
     127                // Y_0  (t)    = F[X_0(t)]
    128128                //             = abs(0.5 + 1t + 2t^2) + abs( 2*(-1.0 + 2t + 3t^2 ) )
    129129                double y_1_0   = -3.0;
    130130                double y_2_0   = -4.0;
    131                 // 
    132                 // Y_1  (t)    = F[X_1(t)] 
     131                //
     132                // Y_1  (t)    = F[X_1(t)]
    133133                //             = abs(0.5 + 2t + 3t^2) + abs( 2*(-1.0 + 3t + 4t^2 ) )
    134134                double y_1_1   = -4.0;
     
    143143        }
    144144        // ---------------------------------------------------------------------
    145         // AddpvOp 
     145        // AddpvOp
    146146        bool addpv_op(void)
    147147        {       bool ok = true;
    148148                double eps = 10. * std::numeric_limits<double>::epsilon();
    149149                size_t j;
    150        
     150
    151151                // domain space vector
    152152                size_t n = 1;
    153153                CPPAD_TESTVECTOR(AD<double>) ax(n);
    154                 ax[0] = 0.5; 
    155        
    156                 // declare independent variables and starting recording
    157                 CppAD::Independent(ax);
    158        
     154                ax[0] = 0.5;
     155
     156                // declare independent variables and starting recording
     157                CppAD::Independent(ax);
     158
    159159                // range space vector
    160160                size_t m = 1;
    161161                CPPAD_TESTVECTOR(AD<double>) ay(m);
    162162                ay[0] = 2.0 + ax[0];
    163        
    164                 // create f: x -> y and stop tape recording
    165                 CppAD::ADFun<double> f(ax, ay);
    166        
    167                 // first order Taylor coefficients
    168                 size_t r = 2, ell;
    169                 CPPAD_TESTVECTOR(double) x1(r*n), y1;
    170                 for(ell = 0; ell < r; ell++)
    171                 {       for(j = 0; j < n; j++)
    172                                 x1[ r * j + ell ] = double(j + ell + 1);
    173                 }
    174                 y1  = f.Forward(1, r, x1);
    175                 ok &= y1.size() == r*m;
    176                
     163
     164                // create f: x -> y and stop tape recording
     165                CppAD::ADFun<double> f(ax, ay);
     166
     167                // first order Taylor coefficients
     168                size_t r = 2, ell;
     169                CPPAD_TESTVECTOR(double) x1(r*n), y1;
     170                for(ell = 0; ell < r; ell++)
     171                {       for(j = 0; j < n; j++)
     172                                x1[ r * j + ell ] = double(j + ell + 1);
     173                }
     174                y1  = f.Forward(1, r, x1);
     175                ok &= y1.size() == r*m;
     176
    177177                // secondorder Taylor coefficients
    178178                CPPAD_TESTVECTOR(double) x2(r*n), y2;
     
    183183                y2  = f.Forward(2, r, x2);
    184184                ok &= y2.size() == r*m;
    185                 // 
    186                 // Y_0 (t)     = F[X_0(t)] 
     185                //
     186                // Y_0 (t)     = F[X_0(t)]
    187187                //             =  2.0 + (0.5 + 1t + 3t^2)
    188188                double y_1_0   = 1.0;
    189189                double y_2_0   = 3.0;
    190                 // 
    191                 // Y_1 (t)     = F[X_1(t)] 
     190                //
     191                // Y_1 (t)     = F[X_1(t)]
    192192                //             =  2.0 + (0.5 + 2t + 4t^2)
    193193                double y_1_1   = 2.0;
     
    202202        }
    203203        // ---------------------------------------------------------------------
    204         // AddvvOp 
     204        // AddvvOp
    205205        bool addvv_op(void)
    206206        {       bool ok = true;
    207207                double eps = 10. * std::numeric_limits<double>::epsilon();
    208208                size_t j;
    209        
     209
    210210                // domain space vector
    211211                size_t n = 2;
    212212                CPPAD_TESTVECTOR(AD<double>) ax(n);
    213                 ax[0] = 0.5; 
     213                ax[0] = 0.5;
    214214                ax[1] = 2.0;
    215        
    216                 // declare independent variables and starting recording
    217                 CppAD::Independent(ax);
    218        
     215
     216                // declare independent variables and starting recording
     217                CppAD::Independent(ax);
     218
    219219                // range space vector
    220220                size_t m = 1;
    221221                CPPAD_TESTVECTOR(AD<double>) ay(m);
    222222                ay[0] = ax[0] + ax[1];
    223        
    224                 // create f: x -> y and stop tape recording
    225                 CppAD::ADFun<double> f(ax, ay);
    226        
    227                 // first order Taylor coefficients
    228                 size_t r = 2, ell;
    229                 CPPAD_TESTVECTOR(double) x1(r*n), y1;
    230                 for(ell = 0; ell < r; ell++)
    231                 {       for(j = 0; j < n; j++)
    232                                 x1[ r * j + ell ] = double(j + ell + 1);
    233                 }
    234                 y1  = f.Forward(1, r, x1);
    235                 ok &= y1.size() == r*m;
    236                
    237                 // secondorder Taylor coefficients
    238                 CPPAD_TESTVECTOR(double) x2(r*n), y2;
    239                 for(ell = 0; ell < r; ell++)
    240                 {       for(j = 0; j < n; j++)
    241                                 x2[ r * j + ell ] = double(j + ell + 2);
    242                 }
    243                 y2  = f.Forward(2, r, x2);
    244                 ok &= y2.size() == r*m;
    245                 // 
    246                 // Y_0 (t)     = F[X_0(t)] 
     223
     224                // create f: x -> y and stop tape recording
     225                CppAD::ADFun<double> f(ax, ay);
     226
     227                // first order Taylor coefficients
     228                size_t r = 2, ell;
     229                CPPAD_TESTVECTOR(double) x1(r*n), y1;
     230                for(ell = 0; ell < r; ell++)
     231                {       for(j = 0; j < n; j++)
     232                                x1[ r * j + ell ] = double(j + ell + 1);
     233                }
     234                y1  = f.Forward(1, r, x1);
     235                ok &= y1.size() == r*m;
     236
     237                // secondorder Taylor coefficients
     238                CPPAD_TESTVECTOR(double) x2(r*n), y2;
     239                for(ell = 0; ell < r; ell++)
     240                {       for(j = 0; j < n; j++)
     241                                x2[ r * j + ell ] = double(j + ell + 2);
     242                }
     243                y2  = f.Forward(2, r, x2);
     244                ok &= y2.size() == r*m;
     245                //
     246                // Y_0 (t)     = F[X_0(t)]
    247247                //             =  (0.5 + 1t + 2t^2) + (2.0 + 2t + 3t^2)
    248248                double y_1_0   = 1.0 + 2.0;
    249249                double y_2_0   = 2.0 + 3.0;
    250                 // 
    251                 // Y_1 (t)     = F[X_1(t)] 
     250                //
     251                // Y_1 (t)     = F[X_1(t)]
    252252                //             =  (2.0 + 2t + 3t^2) + (2.0 + 3t + 4t^2)
    253253                double y_1_1   = 2.0 + 3.0;
     
    262262        }
    263263        // ---------------------------------------------------------------------
    264         // CosOp 
     264        // CosOp
    265265        bool cos_op(void)
    266266        {       bool ok = true;
     
    268268                size_t j;
    269269
    270        
     270
    271271                // domain space vector
    272272                size_t n = 1;
    273273                CPPAD_TESTVECTOR(AD<double>) ax(n);
    274                 ax[0] = 0.5; 
    275        
    276                 // declare independent variables and starting recording
    277                 CppAD::Independent(ax);
    278        
     274                ax[0] = 0.5;
     275
     276                // declare independent variables and starting recording
     277                CppAD::Independent(ax);
     278
    279279                // range space vector
    280280                size_t m = 1;
    281281                CPPAD_TESTVECTOR(AD<double>) ay(m);
    282282                ay[0] = cos( ax[0] );
    283        
    284                 // create f: x -> y and stop tape recording
    285                 CppAD::ADFun<double> f(ax, ay);
    286        
    287                 // first order Taylor coefficients
    288                 size_t r = 2, ell;
    289                 CPPAD_TESTVECTOR(double) x1(r*n), y1;
    290                 for(ell = 0; ell < r; ell++)
    291                 {       for(j = 0; j < n; j++)
    292                                 x1[ r * j + ell ] = double(j + ell + 1);
    293                 }
    294                 y1  = f.Forward(1, r, x1);
    295                 ok &= y1.size() == r*m;
    296                
    297                 // secondorder Taylor coefficients
    298                 CPPAD_TESTVECTOR(double) x2(r*n), y2;
    299                 for(ell = 0; ell < r; ell++)
    300                 {       for(j = 0; j < n; j++)
    301                                 x2[ r * j + ell ] = double(j + ell + 2);
    302                 }
    303                 y2  = f.Forward(2, r, x2);
    304                 ok &= y2.size() == r*m;
    305                 // 
    306                 // Y_0  (t)    = F[X_0(t)] 
     283
     284                // create f: x -> y and stop tape recording
     285                CppAD::ADFun<double> f(ax, ay);
     286
     287                // first order Taylor coefficients
     288                size_t r = 2, ell;
     289                CPPAD_TESTVECTOR(double) x1(r*n), y1;
     290                for(ell = 0; ell < r; ell++)
     291                {       for(j = 0; j < n; j++)
     292                                x1[ r * j + ell ] = double(j + ell + 1);
     293                }
     294                y1  = f.Forward(1, r, x1);
     295                ok &= y1.size() == r*m;
     296
     297                // secondorder Taylor coefficients
     298                CPPAD_TESTVECTOR(double) x2(r*n), y2;
     299                for(ell = 0; ell < r; ell++)
     300                {       for(j = 0; j < n; j++)
     301                                x2[ r * j + ell ] = double(j + ell + 2);
     302                }
     303                y2  = f.Forward(2, r, x2);
     304                ok &= y2.size() == r*m;
     305                //
     306                // Y_0  (t)    = F[X_0(t)]
    307307                //             =  cos( 0.5 + 1t + 2t^2 )
    308308                // Y_0' (t)    = -sin( 0.5 + 1t + 2t^2) * (1 + 4t)
    309309                double y_1_0   = - sin(0.5);
    310310                double y_2_0   = - ( cos(0.5) + 4.0 * sin(0.5) ) / 2.0;
    311                 // 
    312                 // Y_1  (t)    = F[X_1(t)] 
     311                //
     312                // Y_1  (t)    = F[X_1(t)]
    313313                //             =  cos( 0.5 + 2t + 3t^2 )
    314314                // Y_1' (t)    = -sin( 0.5 + 2t + 3t^2) * (2 + 6t)
     
    324324        }
    325325        // ---------------------------------------------------------------------
    326         // CoshOp 
     326        // CoshOp
    327327        bool cosh_op(void)
    328328        {       bool ok = true;
     
    330330                size_t j;
    331331
    332        
     332
    333333                // domain space vector
    334334                size_t n = 1;
    335335                CPPAD_TESTVECTOR(AD<double>) ax(n);
    336                 ax[0] = 0.5; 
    337        
    338                 // declare independent variables and starting recording
    339                 CppAD::Independent(ax);
    340        
     336                ax[0] = 0.5;
     337
     338                // declare independent variables and starting recording
     339                CppAD::Independent(ax);
     340
    341341                // range space vector
    342342                size_t m = 1;
    343343                CPPAD_TESTVECTOR(AD<double>) ay(m);
    344344                ay[0] = cosh( ax[0] );
    345        
    346                 // create f: x -> y and stop tape recording
    347                 CppAD::ADFun<double> f(ax, ay);
    348        
    349                 // first order Taylor coefficients
    350                 size_t r = 2, ell;
    351                 CPPAD_TESTVECTOR(double) x1(r*n), y1;
    352                 for(ell = 0; ell < r; ell++)
    353                 {       for(j = 0; j < n; j++)
    354                                 x1[ r * j + ell ] = double(j + ell + 1);
    355                 }
    356                 y1  = f.Forward(1, r, x1);
    357                 ok &= y1.size() == r*m;
    358                
    359                 // secondorder Taylor coefficients
    360                 CPPAD_TESTVECTOR(double) x2(r*n), y2;
    361                 for(ell = 0; ell < r; ell++)
    362                 {       for(j = 0; j < n; j++)
    363                                 x2[ r * j + ell ] = double(j + ell + 2);
    364                 }
    365                 y2  = f.Forward(2, r, x2);
    366                 ok &= y2.size() == r*m;
    367                 // 
    368                 // Y_0  (t)    = F[X_0(t)] 
     345
     346                // create f: x -> y and stop tape recording
     347                CppAD::ADFun<double> f(ax, ay);
     348
     349                // first order Taylor coefficients
     350                size_t r = 2, ell;
     351                CPPAD_TESTVECTOR(double) x1(r*n), y1;
     352                for(ell = 0; ell < r; ell++)
     353                {       for(j = 0; j < n; j++)
     354                                x1[ r * j + ell ] = double(j + ell + 1);
     355                }
     356                y1  = f.Forward(1, r, x1);
     357                ok &= y1.size() == r*m;
     358
     359                // secondorder Taylor coefficients
     360                CPPAD_TESTVECTOR(double) x2(r*n), y2;
     361                for(ell = 0; ell < r; ell++)
     362                {       for(j = 0; j < n; j++)
     363                                x2[ r * j + ell ] = double(j + ell + 2);
     364                }
     365                y2  = f.Forward(2, r, x2);
     366                ok &= y2.size() == r*m;
     367                //
     368                // Y_0  (t)    = F[X_0(t)]
    369369                //             = cosh( 0.5 + 1t + 2t^2 )
    370370                // Y_0' (t)    = sinh( 0.5 + 1t + 2t^2) * (1 + 4t)
    371371                double y_1_0   = sinh(0.5);
    372372                double y_2_0   = ( sinh(0.5) * 4.0 + cosh(0.5) ) / 2.0;
    373                 // 
    374                 // Y_1  (t)    = F[X_1(t)] 
     373                //
     374                // Y_1  (t)    = F[X_1(t)]
    375375                //             = cosh( 0.5 + 2t + 3t^2 )
    376376                // Y_1' (t)    = sinh( 0.5 + 2t + 3t^2) * (2 + 6t)
     
    391391                double eps = 10. * std::numeric_limits<double>::epsilon();
    392392                size_t j;
    393        
     393
    394394                // domain space vector
    395395                size_t n = 4;
     
    397397                for(j = 0; j < n; j++)
    398398                        ax[j] = double(j);
    399        
    400                 // declare independent variables and starting recording
    401                 CppAD::Independent(ax);
    402        
     399
     400                // declare independent variables and starting recording
     401                CppAD::Independent(ax);
     402
    403403                // range space vector
    404404                size_t m = 2;
     
    409409                // create f: x -> y and stop tape recording
    410410                CppAD::ADFun<double> f(ax, ay);
    411        
    412                 // first order Taylor coefficients
    413                 size_t r = 2, ell;
    414                 CPPAD_TESTVECTOR(double) x1(r*n), y1;
    415                 for(ell = 0; ell < r; ell++)
    416                 {       for(j = 0; j < n; j++)
    417                                 x1[ r * j + ell ] = double(j + ell + 1);
    418                 }
    419                 y1  = f.Forward(1, r, x1);
    420                 ok &= y1.size() == r*m;
    421                
    422                 // secondorder Taylor coefficients
    423                 CPPAD_TESTVECTOR(double) x2(r*n), y2;
    424                 for(ell = 0; ell < r; ell++)
    425                 {       for(j = 0; j < n; j++)
    426                                 x2[ r * j + ell ] = double(j + ell + 2);
    427                 }
    428                 y2  = f.Forward(2, r, x2);
    429                 ok &= y2.size() == r*m;
    430                 // 
     411
     412                // first order Taylor coefficients
     413                size_t r = 2, ell;
     414                CPPAD_TESTVECTOR(double) x1(r*n), y1;
     415                for(ell = 0; ell < r; ell++)
     416                {       for(j = 0; j < n; j++)
     417                                x1[ r * j + ell ] = double(j + ell + 1);
     418                }
     419                y1  = f.Forward(1, r, x1);
     420                ok &= y1.size() == r*m;
     421
     422                // secondorder Taylor coefficients
     423                CPPAD_TESTVECTOR(double) x2(r*n), y2;
     424                for(ell = 0; ell < r; ell++)
     425                {       for(j = 0; j < n; j++)
     426                                x2[ r * j + ell ] = double(j + ell + 2);
     427                }
     428                y2  = f.Forward(2, r, x2);
     429                ok &= y2.size() == r*m;
     430                //
    431431                // Y0_0 (t)     = X2_0(t)
    432432                //             =  2.0 + 3t + 4t^2
    433433                double y0_1_0  = 3.0;
    434434                double y0_2_0  = 4.0;
    435                 // 
     435                //
    436436                // Y1_0 (t)     = X3_0(t)
    437437                //             =  3.0 + 4t + 5t^2
    438438                double y1_1_0  = 4.0;
    439439                double y1_2_0  = 5.0;
    440                 // 
     440                //
    441441                // Y0_1 (t)     = X2_1(t)
    442442                //             =  2.0 + 4t + 5t^2
    443443                double y0_1_1  = 4.0;
    444444                double y0_2_1  = 5.0;
    445                 // 
     445                //
    446446                // Y1_1 (t)     = X3_0(t)
    447447                //             =  3.0 + 5t + 6t^2
     
    463463
    464464        // ---------------------------------------------------------------------
    465         // CSumOp 
     465        // CSumOp
    466466        bool csum_op(void)
    467467        {       bool ok = true;
    468468                double eps = 10. * std::numeric_limits<double>::epsilon();
    469469                size_t j;
    470        
     470
    471471                // domain space vector
    472472                size_t n = 3;
     
    474474                for(j = 0; j < n; j++)
    475475                        ax[j] = double(j);
    476        
    477                 // declare independent variables and starting recording
    478                 CppAD::Independent(ax);
    479        
     476
     477                // declare independent variables and starting recording
     478                CppAD::Independent(ax);
     479
    480480                // range space vector
    481481                size_t m = 1;
     
    484484                for(j = 0; j < n; j++)
    485485                        ay[0] += ax[j];
    486        
     486
    487487                // create f: x -> y and stop tape recording
    488488                CppAD::ADFun<double> f(ax, ay);
     
    491491                f.optimize();
    492492
    493                 // zero order 
     493                // zero order
    494494                CPPAD_TESTVECTOR(double) x0(n);
    495495                for(j = 0; j < n; j++)
    496496                        x0[j] = double(j);
    497497                f.Forward(0, x0);
    498        
    499                 // first order Taylor coefficients
    500                 size_t r = 2, ell;
    501                 CPPAD_TESTVECTOR(double) x1(r*n), y1;
    502                 for(ell = 0; ell < r; ell++)
    503                 {       for(j = 0; j < n; j++)
    504                                 x1[ r * j + ell ] = double(j + ell + 1);
    505                 }
    506                 y1  = f.Forward(1, r, x1);
    507                 ok &= y1.size() == r*m;
    508                
     498
     499                // first order Taylor coefficients
     500                size_t r = 2, ell;
     501                CPPAD_TESTVECTOR(double) x1(r*n), y1;
     502                for(ell = 0; ell < r; ell++)
     503                {       for(j = 0; j < n; j++)
     504                                x1[ r * j + ell ] = double(j + ell + 1);
     505                }
     506                y1  = f.Forward(1, r, x1);
     507                ok &= y1.size() == r*m;
     508
    509509                // secondorder Taylor coefficients
    510510                CPPAD_TESTVECTOR(double) x2(r*n), y2;
     
    515515                y2  = f.Forward(2, r, x2);
    516516                ok &= y2.size() == r*m;
    517                 // 
     517                //
    518518                double check = 0.0;
    519519                for(j = 0; j < n; j++)
     
    549549                double eps = 10. * std::numeric_limits<double>::epsilon();
    550550                size_t j;
    551        
     551
    552552                // domain space vector
    553553                size_t n = 1;
    554554                CPPAD_TESTVECTOR(AD<double>) ax(n);
    555                 ax[0] = 0.5; 
    556        
    557                 // declare independent variables and starting recording
    558                 CppAD::Independent(ax);
    559        
     555                ax[0] = 0.5;
     556
     557                // declare independent variables and starting recording
     558                CppAD::Independent(ax);
     559
    560560                // range space vector
    561561                size_t m = 1;
    562562                CPPAD_TESTVECTOR(AD<double>) ay(m);
    563563                ay[0] = round_off( ax[0] ) + ax[0];
    564        
     564
    565565                // create f: x -> y and stop tape recording
    566566                CppAD::ADFun<double> f(ax, ay);
     
    571571                y0  = f.Forward(0, x0);
    572572                ok &= y0.size() == m;
    573                 ok &= NearEqual(y0[0], round_off(x0[0]) + x0[0], eps, eps); 
    574        
    575                 // first order Taylor coefficients
    576                 size_t r = 2, ell;
    577                 CPPAD_TESTVECTOR(double) x1(r*n), y1;
    578                 for(ell = 0; ell < r; ell++)
    579                 {       for(j = 0; j < n; j++)
    580                                 x1[ r * j + ell ] = double(j + ell + 1);
    581                 }
    582                 y1  = f.Forward(1, r, x1);
    583                 ok &= y1.size() == r*m;
    584                
    585                 // secondorder Taylor coefficients
    586                 CPPAD_TESTVECTOR(double) x2(r*n), y2;
    587                 for(ell = 0; ell < r; ell++)
    588                 {       for(j = 0; j < n; j++)
    589                                 x2[ r * j + ell ] = double(j + ell + 2);
    590                 }
    591                 y2  = f.Forward(2, r, x2);
    592                 ok &= y2.size() == r*m;
    593                 // 
    594                 // 
    595                 // Y_0 (t)     = F[X_0(t)] 
    596                 //             =  2.0 + (2.2 + 1t + 2t^2) 
     573                ok &= NearEqual(y0[0], round_off(x0[0]) + x0[0], eps, eps);
     574
     575                // first order Taylor coefficients
     576                size_t r = 2, ell;
     577                CPPAD_TESTVECTOR(double) x1(r*n), y1;
     578                for(ell = 0; ell < r; ell++)
     579                {       for(j = 0; j < n; j++)
     580                                x1[ r * j + ell ] = double(j + ell + 1);
     581                }
     582                y1  = f.Forward(1, r, x1);
     583                ok &= y1.size() == r*m;
     584
     585                // secondorder Taylor coefficients
     586                CPPAD_TESTVECTOR(double) x2(r*n), y2;
     587                for(ell = 0; ell < r; ell++)
     588                {       for(j = 0; j < n; j++)
     589                                x2[ r * j + ell ] = double(j + ell + 2);
     590                }
     591                y2  = f.Forward(2, r, x2);
     592                ok &= y2.size() == r*m;
     593                //
     594                //
     595                // Y_0 (t)     = F[X_0(t)]
     596                //             =  2.0 + (2.2 + 1t + 2t^2)
    597597                double y_1_0   = 1.0;
    598598                double y_2_0   = 2.0;
    599                 // 
    600                 // Y_1 (t)     = F[X_1(t)] 
    601                 //             =  2.0 + (2.2 + 2t + 3t^2) 
     599                //
     600                // Y_1 (t)     = F[X_1(t)]
     601                //             =  2.0 + (2.2 + 2t + 3t^2)
    602602                double y_1_1   = 2.0;
    603603                double y_2_1   = 3.0;
     
    616616                double eps = 10. * std::numeric_limits<double>::epsilon();
    617617                size_t j;
    618        
     618
    619619                // domain space vector
    620620                size_t n = 1;
    621621                CPPAD_TESTVECTOR(AD<double>) ax(n);
    622                 ax[0] = 0.5; 
    623        
    624                 // declare independent variables and starting recording
    625                 CppAD::Independent(ax);
    626        
     622                ax[0] = 0.5;
     623
     624                // declare independent variables and starting recording
     625                CppAD::Independent(ax);
     626
    627627                // range space vector
    628628                size_t m = 1;
     
    632632                // create f: x -> y and stop tape recording
    633633                CppAD::ADFun<double> f(ax, ay);
    634        
    635                 // first order Taylor coefficients
    636                 size_t r = 2, ell;
    637                 CPPAD_TESTVECTOR(double) x1(r*n), y1;
    638                 for(ell = 0; ell < r; ell++)
    639                 {       for(j = 0; j < n; j++)
    640                                 x1[ r * j + ell ] = double(j + ell + 1);
    641                 }
    642                 y1  = f.Forward(1, r, x1);
    643                 ok &= y1.size() == r*m;
    644                
    645                 // secondorder Taylor coefficients
    646                 CPPAD_TESTVECTOR(double) x2(r*n), y2;
    647                 for(ell = 0; ell < r; ell++)
    648                 {       for(j = 0; j < n; j++)
    649                                 x2[ r * j + ell ] = double(j + ell + 2);
    650                 }
    651                 y2  = f.Forward(2, r, x2);
    652                 ok &= y2.size() == r*m;
    653                 // 
    654                 // Y_0 (t)     = F[X_0(t)] 
     634
     635                // first order Taylor coefficients
     636                size_t r = 2, ell;
     637                CPPAD_TESTVECTOR(double) x1(r*n), y1;
     638                for(ell = 0; ell < r; ell++)
     639                {       for(j = 0; j < n; j++)
     640                                x1[ r * j + ell ] = double(j + ell + 1);
     641                }
     642                y1  = f.Forward(1, r, x1);
     643                ok &= y1.size() == r*m;
     644
     645                // secondorder Taylor coefficients
     646                CPPAD_TESTVECTOR(double) x2(r*n), y2;
     647                for(ell = 0; ell < r; ell++)
     648                {       for(j = 0; j < n; j++)
     649                                x2[ r * j + ell ] = double(j + ell + 2);
     650                }
     651                y2  = f.Forward(2, r, x2);
     652                ok &= y2.size() == r*m;
     653                //
     654                // Y_0 (t)     = F[X_0(t)]
    655655                //             = 2.0 * (0.5 + 1t + 2t^2)
    656656                double y_1_0   = 2.0;
    657657                double y_2_0   = 4.0;
    658                 // 
    659                 // Y_1 (t)     = F[X_1(t)] 
     658                //
     659                // Y_1 (t)     = F[X_1(t)]
    660660                //             = 2.0 * (0.5 + 2t + 3t^2)/2.0
    661661                double y_1_1   = 4.0;
     
    670670        }
    671671        // ---------------------------------------------------------------------
    672         // DivvpOp 
     672        // DivvpOp
    673673        bool divvp_op(void)
    674674        {       bool ok = true;
    675675                double eps = 10. * std::numeric_limits<double>::epsilon();
    676676                size_t j;
    677        
     677
    678678                // domain space vector
    679679                size_t n = 1;
    680680                CPPAD_TESTVECTOR(AD<double>) ax(n);
    681                 ax[0] = 0.5; 
    682        
    683                 // declare independent variables and starting recording
    684                 CppAD::Independent(ax);
    685        
     681                ax[0] = 0.5;
     682
     683                // declare independent variables and starting recording
     684                CppAD::Independent(ax);
     685
    686686                // range space vector
    687687                size_t m = 1;
     
    691691                // create f: x -> y and stop tape recording
    692692                CppAD::ADFun<double> f(ax, ay);
    693        
    694                 // first order Taylor coefficients
    695                 size_t r = 2, ell;
    696                 CPPAD_TESTVECTOR(double) x1(r*n), y1;
    697                 for(ell = 0; ell < r; ell++)
    698                 {       for(j = 0; j < n; j++)
    699                                 x1[ r * j + ell ] = double(j + ell + 1);
    700                 }
    701                 y1  = f.Forward(1, r, x1);
    702                 ok &= y1.size() == r*m;
    703                
     693
     694                // first order Taylor coefficients
     695                size_t r = 2, ell;
     696                CPPAD_TESTVECTOR(double) x1(r*n), y1;
     697                for(ell = 0; ell < r; ell++)
     698                {       for(j = 0; j < n; j++)
     699                                x1[ r * j + ell ] = double(j + ell + 1);
     700                }
     701                y1  = f.Forward(1, r, x1);
     702                ok &= y1.size() == r*m;
     703
    704704                // secondorder Taylor coefficients
    705705                CPPAD_TESTVECTOR(double) x2(r*n), y2;
     
    710710                y2  = f.Forward(2, r, x2);
    711711                ok &= y2.size() == r*m;
    712                 // 
    713                 // Y_0 (t)     = F[X_0(t)] 
     712                //
     713                // Y_0 (t)     = F[X_0(t)]
    714714                //             =  (0.5 + 1t + 3t^2)/2.0
    715715                double y_1_0   = 1.0 / 2.0;
    716716                double y_2_0   = 3.0 / 2.0;
    717                 // 
    718                 // Y_1 (t)     = F[X_1(t)] 
     717                //
     718                // Y_1 (t)     = F[X_1(t)]
    719719                //             =  (0.5 + 2t + 4t^2)/2.0
    720720                double y_1_1   = 2.0 / 2.0;
     
    729729        }
    730730        // ---------------------------------------------------------------------
    731         // ExpOp 
     731        // ExpOp
    732732        bool exp_op(void)
    733733        {       bool ok = true;
    734734                double eps = 10. * std::numeric_limits<double>::epsilon();
    735735                size_t j;
    736        
     736
    737737                // domain space vector
    738738                size_t n = 1;
    739739                CPPAD_TESTVECTOR(AD<double>) ax(n);
    740                 ax[0] = 0.5; 
    741        
    742                 // declare independent variables and starting recording
    743                 CppAD::Independent(ax);
    744        
     740                ax[0] = 0.5;
     741
     742                // declare independent variables and starting recording
     743                CppAD::Independent(ax);
     744
    745745                // range space vector
    746746                size_t m = 1;
    747747                CPPAD_TESTVECTOR(AD<double>) ay(m);
    748748                ay[0] = exp( ax[0] );
    749        
    750                 // create f: x -> y and stop tape recording
    751                 CppAD::ADFun<double> f(ax, ay);
    752        
    753                 // first order Taylor coefficients
    754                 size_t r = 2, ell;
    755                 CPPAD_TESTVECTOR(double) x1(r*n), y1;
    756                 for(ell = 0; ell < r; ell++)
    757                 {       for(j = 0; j < n; j++)
    758                                 x1[ r * j + ell ] = double(j + ell + 1);
    759                 }
    760                 y1  = f.Forward(1, r, x1);
    761                 ok &= y1.size() == r*m;
    762                
    763                 // secondorder Taylor coefficients
    764                 CPPAD_TESTVECTOR(double) x2(r*n), y2;
    765                 for(ell = 0; ell < r; ell++)
    766                 {       for(j = 0; j < n; j++)
    767                                 x2[ r * j + ell ] = double(j + ell + 2);
    768                 }
    769                 y2  = f.Forward(2, r, x2);
    770                 ok &= y2.size() == r*m;
    771                 // 
    772                 // Y_0  (t)    = F[X_0(t)] 
     749
     750                // create f: x -> y and stop tape recording
     751                CppAD::ADFun<double> f(ax, ay);
     752
     753                // first order Taylor coefficients
     754                size_t r = 2, ell;
     755                CPPAD_TESTVECTOR(double) x1(r*n), y1;
     756                for(ell = 0; ell < r; ell++)
     757                {       for(j = 0; j < n; j++)
     758                                x1[ r * j + ell ] = double(j + ell + 1);
     759                }
     760                y1  = f.Forward(1, r, x1);
     761                ok &= y1.size() == r*m;
     762
     763                // secondorder Taylor coefficients
     764                CPPAD_TESTVECTOR(double) x2(r*n), y2;
     765                for(ell = 0; ell < r; ell++)
     766                {       for(j = 0; j < n; j++)
     767                                x2[ r * j + ell ] = double(j + ell + 2);
     768                }
     769                y2  = f.Forward(2, r, x2);
     770                ok &= y2.size() == r*m;
     771                //
     772                // Y_0  (t)    = F[X_0(t)]
    773773                //             =  exp(0.5 + 1t + 2t^2)
    774774                // Y_0' (t)    =  exp(0.5 + 1t + 2t^2)*(1 + 4t)
    775775                double y_1_0   = exp(0.5);
    776776                double y_2_0   = ( exp(0.5)*4.0 + exp(0.5) ) / 2.0;
    777                 // 
    778                 // Y_1  (t)    = F[X_1(t)] 
     777                //
     778                // Y_1  (t)    = F[X_1(t)]
    779779                //             =  exp(0.5 + 2t + 3t^2)
    780780                // Y_1' (t)    =  exp(0.5 + 2t + 3t^2)*(2 + 6t)
     
    795795                double eps = 10. * std::numeric_limits<double>::epsilon();
    796796                size_t j;
    797        
     797
    798798                // domain space vector
    799799                size_t n = 2;
    800800                CPPAD_TESTVECTOR(AD<double>) ax(n);
    801                 ax[0] = 0.0; 
     801                ax[0] = 0.0;
    802802                ax[1] = 1.0;
    803        
     803
    804804                // declare independent variables and starting recording
    805805                CppAD::Independent(ax);
     
    810810                avec[ AD<double>(1) ]    = ax[1];  // store a variable
    811811                avec[ AD<double>(2) ]    = 5.0;    // store a parameter
    812        
    813                 // range space vector 
     812
     813                // range space vector
    814814                size_t m = 2;
    815815                CPPAD_TESTVECTOR(AD<double>) ay(m);
    816816                ay[0] = avec[ AD<double>(0) ];     // load using parameter index
    817817                ay[1] = avec[ ax[0] ];             // load using variable index
    818        
     818
    819819                // create f: x -> y and stop tape recording
    820820                CppAD::ADFun<double> f(ax, ay);
     
    829829                ok &= y0[0] == x0[0];
    830830                // y[1] = avec[ x[0] ] = avec[2] = 5.0
    831                 ok &= y0[1] == 5.0; 
    832 
    833                 // first order Taylor coefficients
    834                 size_t r = 2, ell;
    835                 CPPAD_TESTVECTOR(double) x1(r*n), y1;
    836                 for(ell = 0; ell < r; ell++)
    837                 {       for(j = 0; j < n; j++)
    838                                 x1[ r * j + ell ] = double(j + ell + 1);
    839                 }
    840                 y1  = f.Forward(1, r, x1);
    841                 ok &= y1.size() == r*m;
    842                
    843                 // secondorder Taylor coefficients
    844                 CPPAD_TESTVECTOR(double) x2(r*n), y2;
    845                 for(ell = 0; ell < r; ell++)
    846                 {       for(j = 0; j < n; j++)
    847                                 x2[ r * j + ell ] = double(j + ell + 2);
    848                 }
    849                 y2  = f.Forward(2, r, x2);
    850                 ok &= y2.size() == r*m;
    851                 // 
     831                ok &= y0[1] == 5.0;
     832
     833                // first order Taylor coefficients
     834                size_t r = 2, ell;
     835                CPPAD_TESTVECTOR(double) x1(r*n), y1;
     836                for(ell = 0; ell < r; ell++)
     837                {       for(j = 0; j < n; j++)
     838                                x1[ r * j + ell ] = double(j + ell + 1);
     839                }
     840                y1  = f.Forward(1, r, x1);
     841                ok &= y1.size() == r*m;
     842
     843                // secondorder Taylor coefficients
     844                CPPAD_TESTVECTOR(double) x2(r*n), y2;
     845                for(ell = 0; ell < r; ell++)
     846                {       for(j = 0; j < n; j++)
     847                                x2[ r * j + ell ] = double(j + ell + 2);
     848                }
     849                y2  = f.Forward(2, r, x2);
     850                ok &= y2.size() == r*m;
     851                //
    852852                // Y0_0 (t)    = 2.0 + 1t + 2t^2
    853853                double y0_1_0  = 1.0;
    854854                double y0_2_0  = 2.0;
    855                 // 
     855                //
    856856                // Y1_0 (t)    = 5.0
    857857                double y1_1_0  = 0.0;
    858858                double y1_2_0  = 0.0;
    859                 // 
     859                //
    860860                // Y0_1 (t)    = 2.0 + 2t + 3t^2
    861861                double y0_1_1  = 2.0;
    862862                double y0_2_1  = 3.0;
    863                 // 
     863                //
    864864                // Y1_1 (t)    = 5.0
    865865                double y1_1_1  = 0.0;
     
    878878                return ok;
    879879        }
    880        
    881         // ---------------------------------------------------------------------
    882         // MulpvOp 
     880
     881        // ---------------------------------------------------------------------
     882        // MulpvOp
    883883        bool mulpv_op(void)
    884884        {       bool ok = true;
    885885                double eps = 10. * std::numeric_limits<double>::epsilon();
    886886                size_t j;
    887        
     887
    888888                // domain space vector
    889889                size_t n = 1;
    890890                CPPAD_TESTVECTOR(AD<double>) ax(n);
    891                 ax[0] = 0.5; 
    892        
    893                 // declare independent variables and starting recording
    894                 CppAD::Independent(ax);
    895        
     891                ax[0] = 0.5;
     892
     893                // declare independent variables and starting recording
     894                CppAD::Independent(ax);
     895
    896896                // range space vector
    897897                size_t m = 1;
    898898                CPPAD_TESTVECTOR(AD<double>) ay(m);
    899899                ay[0] = 2.0 * ax[0];
    900        
    901                 // create f: x -> y and stop tape recording
    902                 CppAD::ADFun<double> f(ax, ay);
    903        
    904                 // first order Taylor coefficients
    905                 size_t r = 2, ell;
    906                 CPPAD_TESTVECTOR(double) x1(r*n), y1;
    907                 for(ell = 0; ell < r; ell++)
    908                 {       for(j = 0; j < n; j++)
    909                                 x1[ r * j + ell ] = double(j + ell + 1);
    910                 }
    911                 y1  = f.Forward(1, r, x1);
    912                 ok &= y1.size() == r*m;
    913                
     900
     901                // create f: x -> y and stop tape recording
     902                CppAD::ADFun<double> f(ax, ay);
     903
     904                // first order Taylor coefficients
     905                size_t r = 2, ell;
     906                CPPAD_TESTVECTOR(double) x1(r*n), y1;
     907                for(ell = 0; ell < r; ell++)
     908                {       for(j = 0; j < n; j++)
     909                                x1[ r * j + ell ] = double(j + ell + 1);
     910                }
     911                y1  = f.Forward(1, r, x1);
     912                ok &= y1.size() == r*m;
     913
    914914                // secondorder Taylor coefficients
    915915                CPPAD_TESTVECTOR(double) x2(r*n), y2;
     
    920920                y2  = f.Forward(2, r, x2);
    921921                ok &= y2.size() == r*m;
    922                 // 
    923                 // Y_0 (t)     = F[X_0(t)] 
     922                //
     923                // Y_0 (t)     = F[X_0(t)]
    924924                //             =  2.0 * (0.5 + 1t + 3t^2)
    925925                double y_1_0   = 2.0 * 1.0;
    926926                double y_2_0   = 2.0 * 3.0;
    927                 // 
    928                 // Y_1 (t)     = F[X_1(t)] 
     927                //
     928                // Y_1 (t)     = F[X_1(t)]
    929929                //             =  2.0 * (0.5 + 2t + 4t^2)
    930930                double y_1_1   = 2.0 * 2.0;
     
    992992                double eps = 10. * std::numeric_limits<double>::epsilon();
    993993                size_t j;
    994        
     994
    995995                // domain space vector
    996996                size_t n = 2;
    997997                CPPAD_TESTVECTOR(AD<double>) ax(n);
    998                 ax[0] = 0.5; 
     998                ax[0] = 0.5;
    999999                ax[1] = 2.0;
    1000        
    1001                 // declare independent variables and starting recording
    1002                 CppAD::Independent(ax);
    1003        
     1000
     1001                // declare independent variables and starting recording
     1002                CppAD::Independent(ax);
     1003
    10041004                // range space vector
    10051005                size_t m = 2;
     
    10071007                ay[0] = log( pow( exp(ax[0]) , ax[1] ) ) / ax[1] ;
    10081008                ay[1] = log( pow( exp(ax[0]) , ax[1] ) ) / ax[0] ;
    1009        
    1010                 // create f: x -> y and stop tape recording
    1011                 CppAD::ADFun<double> f(ax, ay);
    1012        
    1013                 // first order Taylor coefficients
    1014                 size_t r = 2, ell;
    1015                 CPPAD_TESTVECTOR(double) x1(r*n), y1;
    1016                 for(ell = 0; ell < r; ell++)
    1017                 {       for(j = 0; j < n; j++)
    1018                                 x1[ r * j + ell ] = double(j + ell + 1);
    1019                 }
    1020                 y1  = f.Forward(1, r, x1);
    1021                 ok &= y1.size() == r*m;
    1022                
    1023                 // secondorder Taylor coefficients
    1024                 CPPAD_TESTVECTOR(double) x2(r*n), y2;
    1025                 for(ell = 0; ell < r; ell++)
    1026                 {       for(j = 0; j < n; j++)
    1027                                 x2[ r * j + ell ] = double(j + ell + 2);
    1028                 }
    1029                 y2  = f.Forward(2, r, x2);
    1030                 ok &= y2.size() == r*m;
    1031                 // 
     1009
     1010                // create f: x -> y and stop tape recording
     1011                CppAD::ADFun<double> f(ax, ay);
     1012
     1013                // first order Taylor coefficients
     1014                size_t r = 2, ell;
     1015                CPPAD_TESTVECTOR(double) x1(r*n), y1;
     1016                for(ell = 0; ell < r; ell++)
     1017                {       for(j = 0; j < n; j++)
     1018                                x1[ r * j + ell ] = double(j + ell + 1);
     1019                }
     1020                y1  = f.Forward(1, r, x1);
     1021                ok &= y1.size() == r*m;
     1022
     1023                // secondorder Taylor coefficients
     1024                CPPAD_TESTVECTOR(double) x2(r*n), y2;
     1025                for(ell = 0; ell < r; ell++)
     1026                {       for(j = 0; j < n; j++)
     1027                                x2[ r * j + ell ] = double(j + ell + 2);
     1028                }
     1029                y2  = f.Forward(2, r, x2);
     1030                ok &= y2.size() == r*m;
     1031                //
    10321032                // Y0_0 (t)    = 0.5 + 1t + 2t^2
    10331033                double y0_1_0  = 1.0;
    10341034                double y0_2_0  = 2.0;
    1035                 // 
     1035                //
    10361036                // Y0_1 (t)    = 0.5 + 2t + 3t^2
    10371037                double y0_1_1  = 2.0;
    10381038                double y0_2_1  = 3.0;
    1039                 // 
     1039                //
    10401040                // Y1_0 (t)    = 2.0 + 2t + 3t^2
    10411041                double y1_1_0  = 2.0;
    10421042                double y1_2_0  = 3.0;
    1043                 // 
     1043                //
    10441044                // Y1_1 (t)    = 2.0 + 3t + 4t^2
    10451045                double y1_1_1  = 3.0;
     
    10641064                double eps = 10. * std::numeric_limits<double>::epsilon();
    10651065                size_t j;
    1066        
     1066
    10671067                // domain space vector
    10681068                size_t n = 1;
    10691069                CPPAD_TESTVECTOR(AD<double>) ax(n);
    1070                 ax[0] = 0.5; 
    1071        
    1072                 // declare independent variables and starting recording
    1073                 CppAD::Independent(ax);
    1074        
     1070                ax[0] = 0.5;
     1071
     1072                // declare independent variables and starting recording
     1073                CppAD::Independent(ax);
     1074
    10751075                // range space vector
    10761076                size_t m = 1;
    10771077                CPPAD_TESTVECTOR(AD<double>) ay(m);
    10781078                ay[0] = sign( ax[0] ) * ax[0];
    1079        
     1079
    10801080                // create f: x -> y and stop tape recording
    10811081                CppAD::ADFun<double> f(ax, ay);
     
    10861086                y0  = f.Forward(0, x0);
    10871087                ok &= y0.size() == m;
    1088                 ok &= NearEqual(y0[0], CppAD::abs(x0[0]), eps, eps); 
    1089        
    1090                 // first order Taylor coefficients
    1091                 size_t r = 2, ell;
    1092                 CPPAD_TESTVECTOR(double) x1(r*n), y1;
    1093                 for(ell = 0; ell < r; ell++)
    1094                 {       for(j = 0; j < n; j++)
    1095                                 x1[ r * j + ell ] = double(j + ell + 1);
    1096                 }
    1097                 y1  = f.Forward(1, r, x1);
    1098                 ok &= y1.size() == r*m;
    1099                
    1100                 // secondorder Taylor coefficients
    1101                 CPPAD_TESTVECTOR(double) x2(r*n), y2;
    1102                 for(ell = 0; ell < r; ell++)
    1103                 {       for(j = 0; j < n; j++)
    1104                                 x2[ r * j + ell ] = double(j + ell + 2);
    1105                 }
    1106                 y2  = f.Forward(2, r, x2);
    1107                 ok &= y2.size() == r*m;
    1108                 // 
    1109                 // 
    1110                 // Y_0 (t)     = F[X_0(t)] 
    1111                 //             =  -(-3.0 + 1t + 2t^2) 
     1088                ok &= NearEqual(y0[0], CppAD::abs(x0[0]), eps, eps);
     1089
     1090                // first order Taylor coefficients
     1091                size_t r = 2, ell;
     1092                CPPAD_TESTVECTOR(double) x1(r*n), y1;
     1093                for(ell = 0; ell < r; ell++)
     1094                {       for(j = 0; j < n; j++)
     1095                                x1[ r * j + ell ] = double(j + ell + 1);
     1096                }
     1097                y1  = f.Forward(1, r, x1);
     1098                ok &= y1.size() == r*m;
     1099
     1100                // secondorder Taylor coefficients
     1101                CPPAD_TESTVECTOR(double) x2(r*n), y2;
     1102                for(ell = 0; ell < r; ell++)
     1103                {       for(j = 0; j < n; j++)
     1104                                x2[ r * j + ell ] = double(j + ell + 2);
     1105                }
     1106                y2  = f.Forward(2, r, x2);
     1107                ok &= y2.size() == r*m;
     1108                //
     1109                //
     1110                // Y_0 (t)     = F[X_0(t)]
     1111                //             =  -(-3.0 + 1t + 2t^2)
    11121112                double y_1_0   = -1.0;
    11131113                double y_2_0   = -2.0;
    1114                 // 
    1115                 // Y_1 (t)     = F[X_1(t)] 
    1116                 //             =  -(-3.0 + 2t + 3t^2) 
     1114                //
     1115                // Y_1 (t)     = F[X_1(t)]
     1116                //             =  -(-3.0 + 2t + 3t^2)
    11171117                double y_1_1   = -2.0;
    11181118                double y_2_1   = -3.0;
     
    11271127
    11281128        // ---------------------------------------------------------------------
    1129         // SinOp 
     1129        // SinOp
    11301130        bool sin_op(void)
    11311131        {       bool ok = true;
     
    11331133                size_t j;
    11341134
    1135        
     1135
    11361136                // domain space vector
    11371137                size_t n = 1;
    11381138                CPPAD_TESTVECTOR(AD<double>) ax(n);
    1139                 ax[0] = 0.5; 
    1140        
    1141                 // declare independent variables and starting recording
    1142                 CppAD::Independent(ax);
    1143        
     1139                ax[0] = 0.5;
     1140
     1141                // declare independent variables and starting recording
     1142                CppAD::Independent(ax);
     1143
    11441144                // range space vector
    11451145                size_t m = 1;
    11461146                CPPAD_TESTVECTOR(AD<double>) ay(m);
    11471147                ay[0] = sin( ax[0] );
    1148        
    1149                 // create f: x -> y and stop tape recording
    1150                 CppAD::ADFun<double> f(ax, ay);
    1151        
    1152                 // first order Taylor coefficients
    1153                 size_t r = 2, ell;
    1154                 CPPAD_TESTVECTOR(double) x1(r*n), y1;
    1155                 for(ell = 0; ell < r; ell++)
    1156                 {       for(j = 0; j < n; j++)
    1157                                 x1[ r * j + ell ] = double(j + ell + 1);
    1158                 }
    1159                 y1  = f.Forward(1, r, x1);
    1160                 ok &= y1.size() == r*m;
    1161                
    1162                 // secondorder Taylor coefficients
    1163                 CPPAD_TESTVECTOR(double) x2(r*n), y2;
    1164                 for(ell = 0; ell < r; ell++)
    1165                 {       for(j = 0; j < n; j++)
    1166                                 x2[ r * j + ell ] = double(j + ell + 2);
    1167                 }
    1168                 y2  = f.Forward(2, r, x2);
    1169                 ok &= y2.size() == r*m;
    1170                 // 
    1171                 // Y_0  (t)    = F[X_0(t)] 
     1148
     1149                // create f: x -> y and stop tape recording
     1150                CppAD::ADFun<double> f(ax, ay);
     1151
     1152                // first order Taylor coefficients
     1153                size_t r = 2, ell;
     1154                CPPAD_TESTVECTOR(double) x1(r*n), y1;
     1155                for(ell = 0; ell < r; ell++)
     1156                {       for(j = 0; j < n; j++)
     1157                                x1[ r * j + ell ] = double(j + ell + 1);
     1158                }
     1159                y1  = f.Forward(1, r, x1);
     1160                ok &= y1.size() == r*m;
     1161
     1162                // secondorder Taylor coefficients
     1163                CPPAD_TESTVECTOR(double) x2(r*n), y2;
     1164                for(ell = 0; ell < r; ell++)
     1165                {       for(j = 0; j < n; j++)
     1166                                x2[ r * j + ell ] = double(j + ell + 2);
     1167                }
     1168                y2  = f.Forward(2, r, x2);
     1169                ok &= y2.size() == r*m;
     1170                //
     1171                // Y_0  (t)    = F[X_0(t)]
    11721172                //             = sin( 0.5 + 1t + 2t^2 )
    11731173                // Y_0' (t)    = cos( 0.5 + 1t + 2t^2) * (1 + 4t)
    11741174                double y_1_0   = cos(0.5);
    11751175                double y_2_0   = ( cos(0.5) * 4.0 - sin(0.5) ) / 2.0;
    1176                 // 
    1177                 // Y_1  (t)    = F[X_1(t)] 
     1176                //
     1177                // Y_1  (t)    = F[X_1(t)]
    11781178                //             = sin( 0.5 + 2t + 3t^2 )
    11791179                // Y_1' (t)    = cos( 0.5 + 2t + 3t^2) * (2 + 6t)
     
    11891189        }
    11901190        // ---------------------------------------------------------------------
    1191         // SinhOp 
     1191        // SinhOp
    11921192        bool sinh_op(void)
    11931193        {       bool ok = true;
     
    11951195                size_t j;
    11961196
    1197        
     1197
    11981198                // domain space vector
    11991199                size_t n = 1;
    12001200                CPPAD_TESTVECTOR(AD<double>) ax(n);
    1201                 ax[0] = 0.5; 
    1202        
    1203                 // declare independent variables and starting recording
    1204                 CppAD::Independent(ax);
    1205        
     1201                ax[0] = 0.5;
     1202
     1203                // declare independent variables and starting recording
     1204                CppAD::Independent(ax);
     1205
    12061206                // range space vector
    12071207                size_t m = 1;
    12081208                CPPAD_TESTVECTOR(AD<double>) ay(m);
    12091209                ay[0] = sinh( ax[0] );
    1210        
    1211                 // create f: x -> y and stop tape recording
    1212                 CppAD::ADFun<double> f(ax, ay);
    1213        
    1214                 // first order Taylor coefficients
    1215                 size_t r = 2, ell;
    1216                 CPPAD_TESTVECTOR(double) x1(r*n), y1;
    1217                 for(ell = 0; ell < r; ell++)
    1218                 {       for(j = 0; j < n; j++)
    1219                                 x1[ r * j + ell ] = double(j + ell + 1);
    1220                 }
    1221                 y1  = f.Forward(1, r, x1);
    1222                 ok &= y1.size() == r*m;
    1223                
    1224                 // secondorder Taylor coefficients
    1225                 CPPAD_TESTVECTOR(double) x2(r*n), y2;
    1226                 for(ell = 0; ell < r; ell++)
    1227                 {       for(j = 0; j < n; j++)
    1228                                 x2[ r * j + ell ] = double(j + ell + 2);
    1229                 }
    1230                 y2  = f.Forward(2, r, x2);
    1231                 ok &= y2.size() == r*m;
    1232                 // 
    1233                 // Y_0  (t)    = F[X_0(t)] 
     1210
     1211                // create f: x -> y and stop tape recording
     1212                CppAD::ADFun<double> f(ax, ay);
     1213
     1214                // first order Taylor coefficients
     1215                size_t r = 2, ell;
     1216                CPPAD_TESTVECTOR(double) x1(r*n), y1;
     1217                for(ell = 0; ell < r; ell++)
     1218                {       for(j = 0; j < n; j++)
     1219                                x1[ r * j + ell ] = double(j + ell + 1);
     1220                }
     1221                y1  = f.Forward(1, r, x1);
     1222                ok &= y1.size() == r*m;
     1223
     1224                // secondorder Taylor coefficients
     1225                CPPAD_TESTVECTOR(double) x2(r*n), y2;
     1226                for(ell = 0; ell < r; ell++)
     1227                {       for(j = 0; j < n; j++)
     1228                                x2[ r * j + ell ] = double(j + ell + 2);
     1229                }
     1230                y2  = f.Forward(2, r, x2);
     1231                ok &= y2.size() == r*m;
     1232                //
     1233                // Y_0  (t)    = F[X_0(t)]
    12341234                //             = sinh( 0.5 + 1t + 2t^2 )
    12351235                // Y_0' (t)    = cosh( 0.5 + 1t + 2t^2) * (1 + 4t)
    12361236                double y_1_0   = cosh(0.5);
    12371237                double y_2_0   = ( cosh(0.5) * 4.0 + sinh(0.5) ) / 2.0;
    1238                 // 
    1239                 // Y_1  (t)    = F[X_1(t)] 
     1238                //
     1239                // Y_1  (t)    = F[X_1(t)]
    12401240                //             = sinh( 0.5 + 2t + 3t^2 )
    12411241                // Y_1' (t)    = cosh( 0.5 + 2t + 3t^2) * (2 + 6t)
     
    12511251        }
    12521252        // ---------------------------------------------------------------------
    1253         // SubpvOp 
     1253        // SubpvOp
    12541254        bool subpv_op(void)
    12551255        {       bool ok = true;
    12561256                double eps = 10. * std::numeric_limits<double>::epsilon();
    12571257                size_t j;
    1258        
     1258
    12591259                // domain space vector
    12601260                size_t n = 1;
    12611261                CPPAD_TESTVECTOR(AD<double>) ax(n);
    1262                 ax[0] = 0.5; 
    1263        
    1264                 // declare independent variables and starting recording
    1265                 CppAD::Independent(ax);
    1266        
     1262                ax[0] = 0.5;
     1263
     1264                // declare independent variables and starting recording
     1265                CppAD::Independent(ax);
     1266
    12671267                // range space vector
    12681268                size_t m = 1;
    12691269                CPPAD_TESTVECTOR(AD<double>) ay(m);
    12701270                ay[0] = 2.0 - ax[0];
    1271        
    1272                 // create f: x -> y and stop tape recording
    1273                 CppAD::ADFun<double> f(ax, ay);
    1274        
    1275                 // first order Taylor coefficients
    1276                 size_t r = 2, ell;
    1277                 CPPAD_TESTVECTOR(double) x1(r*n), y1;
    1278                 for(ell = 0; ell < r; ell++)
    1279                 {       for(j = 0; j < n; j++)
    1280                                 x1[ r * j + ell ] = double(j + ell + 1);
    1281                 }
    1282                 y1  = f.Forward(1, r, x1);
    1283                 ok &= y1.size() == r*m;
    1284                
     1271
     1272                // create f: x -> y and stop tape recording
     1273                CppAD::ADFun<double> f(ax, ay);
     1274
     1275                // first order Taylor coefficients
     1276                size_t r = 2, ell;
     1277                CPPAD_TESTVECTOR(double) x1(r*n), y1;
     1278                for(ell = 0; ell < r; ell++)
     1279                {       for(j = 0; j < n; j++)
     1280                                x1[ r * j + ell ] = double(j + ell + 1);
     1281                }
     1282                y1  = f.Forward(1, r, x1);
     1283                ok &= y1.size() == r*m;
     1284
    12851285                // secondorder Taylor coefficients
    12861286                CPPAD_TESTVECTOR(double) x2(r*n), y2;
     
    12911291                y2  = f.Forward(2, r, x2);
    12921292                ok &= y2.size() == r*m;
    1293                 // 
    1294                 // Y_0 (t)     = F[X_0(t)] 
     1293                //
     1294                // Y_0 (t)     = F[X_0(t)]
    12951295                //             =  2.0 - (0.5 + 1t + 3t^2)/2.0
    12961296                double y_1_0   = - 1.0;
    12971297                double y_2_0   = - 3.0;
    1298                 // 
    1299                 // Y_1 (t)     = F[X_1(t)] 
     1298                //
     1299                // Y_1 (t)     = F[X_1(t)]
    13001300                //             =  3.0 - (0.5 + 2t + 4t^2)/2.0
    13011301                double y_1_1   = - 2.0;
     
    13101310        }
    13111311        // ---------------------------------------------------------------------
    1312         // SubvvOp 
     1312        // SubvvOp
    13131313        bool subvv_op(void)
    13141314        {       bool ok = true;
    13151315                double eps = 10. * std::numeric_limits<double>::epsilon();
    13161316                size_t j;
    1317        
     1317
    13181318                // domain space vector
    13191319                size_t n = 2;
    13201320                CPPAD_TESTVECTOR(AD<double>) ax(n);
    1321                 ax[0] = 0.5; 
     1321                ax[0] = 0.5;
    13221322                ax[1] = 2.0;
    1323        
    1324                 // declare independent variables and starting recording
    1325                 CppAD::Independent(ax);
    1326        
     1323
     1324                // declare independent variables and starting recording
     1325                CppAD::Independent(ax);
     1326
    13271327                // range space vector
    13281328                size_t m = 1;
    13291329                CPPAD_TESTVECTOR(AD<double>) ay(m);
    13301330                ay[0] = ax[0] - 2.0 * ax[1];
    1331        
    1332                 // create f: x -> y and stop tape recording
    1333                 CppAD::ADFun<double> f(ax, ay);
    1334        
    1335                 // first order Taylor coefficients
    1336                 size_t r = 2, ell;
    1337                 CPPAD_TESTVECTOR(double) x1(r*n), y1;
    1338                 for(ell = 0; ell < r; ell++)
    1339                 {       for(j = 0; j < n; j++)
    1340                                 x1[ r * j + ell ] = double(j + ell + 1);
    1341                 }
    1342                 y1  = f.Forward(1, r, x1);
    1343                 ok &= y1.size() == r*m;
    1344                
    1345                 // secondorder Taylor coefficients
    1346                 CPPAD_TESTVECTOR(double) x2(r*n), y2;
    1347                 for(ell = 0; ell < r; ell++)
    1348                 {       for(j = 0; j < n; j++)
    1349                                 x2[ r * j + ell ] = double(j + ell + 2);
    1350                 }
    1351                 y2  = f.Forward(2, r, x2);
    1352                 ok &= y2.size() == r*m;
    1353                 // 
    1354                 // Y_0 (t)     = F[X_0(t)] 
     1331
     1332                // create f: x -> y and stop tape recording
     1333                CppAD::ADFun<double> f(ax, ay);
     1334
     1335                // first order Taylor coefficients
     1336                size_t r = 2, ell;
     1337                CPPAD_TESTVECTOR(double) x1(r*n), y1;
     1338                for(ell = 0; ell < r; ell++)
     1339                {       for(j = 0; j < n; j++)
     1340                                x1[ r * j + ell ] = double(j + ell + 1);
     1341                }
     1342                y1  = f.Forward(1, r, x1);
     1343                ok &= y1.size() == r*m;
     1344
     1345                // secondorder Taylor coefficients
     1346                CPPAD_TESTVECTOR(double) x2(r*n), y2;
     1347                for(ell = 0; ell < r; ell++)
     1348                {       for(j = 0; j < n; j++)
     1349                                x2[ r * j + ell ] = double(j + ell + 2);
     1350                }
     1351                y2  = f.Forward(2, r, x2);
     1352                ok &= y2.size() == r*m;
     1353                //
     1354                // Y_0 (t)     = F[X_0(t)]
    13551355                //             =  (0.5 + 1t + 2t^2) - 2.0 * (2.0 + 2t + 3t^2)
    13561356                double y_1_0   = 1.0 - 4.0;
    13571357                double y_2_0   = 2.0 - 6.0;
    1358                 // 
    1359                 // Y_1 (t)     = F[X_1(t)] 
     1358                //
     1359                // Y_1 (t)     = F[X_1(t)]
    13601360                //             =  (2.0 + 2t + 3t^2) - 2.0 * (2.0 + 3t + 4t^2)
    13611361                double y_1_1   = 2.0 - 6.0;
     
    13701370        }
    13711371        // ---------------------------------------------------------------------
    1372         // TanOp 
     1372        // TanOp
    13731373        bool tan_op(void)
    13741374        {       bool ok = true;
    13751375                double eps = 10. * std::numeric_limits<double>::epsilon();
    13761376                size_t j;
    1377        
     1377
    13781378                // domain space vector
    13791379                size_t n = 1;
    13801380                CPPAD_TESTVECTOR(AD<double>) ax(n);
    1381                 ax[0] = 0.5; 
    1382        
    1383                 // declare independent variables and starting recording
    1384                 CppAD::Independent(ax);
    1385        
     1381                ax[0] = 0.5;
     1382
     1383                // declare independent variables and starting recording
     1384                CppAD::Independent(ax);
     1385
    13861386                // range space vector
    13871387                size_t m = 1;
    13881388                CPPAD_TESTVECTOR(AD<double>) ay(m);
    13891389                ay[0] = tan( ax[0] );
    1390        
    1391                 // create f: x -> y and stop tape recording
    1392                 CppAD::ADFun<double> f(ax, ay);
    1393        
    1394                 // first order Taylor coefficients
    1395                 size_t r = 2, ell;
    1396                 CPPAD_TESTVECTOR(double) x1(r*n), y1;
    1397                 for(ell = 0; ell < r; ell++)
    1398                 {       for(j = 0; j < n; j++)
    1399                                 x1[ r * j + ell ] = double(j + ell + 1);
    1400                 }
    1401                 y1  = f.Forward(1, r, x1);
    1402                 ok &= y1.size() == r*m;
    1403                
    1404                 // secondorder Taylor coefficients
    1405                 CPPAD_TESTVECTOR(double) x2(r*n), y2;
    1406                 for(ell = 0; ell < r; ell++)
    1407                 {       for(j = 0; j < n; j++)
    1408                                 x2[ r * j + ell ] = double(j + ell + 2);
    1409                 }
    1410                 y2  = f.Forward(2, r, x2);
    1411                 ok &= y2.size() == r*m;
    1412                 // 
    1413                 // Y_0  (t)    = F[X_0(t)] 
     1390
     1391                // create f: x -> y and stop tape recording
     1392                CppAD::ADFun<double> f(ax, ay);
     1393
     1394                // first order Taylor coefficients
     1395                size_t r = 2, ell;
     1396                CPPAD_TESTVECTOR(double) x1(r*n), y1;
     1397                for(ell = 0; ell < r; ell++)
     1398                {       for(j = 0; j < n; j++)
     1399                                x1[ r * j + ell ] = double(j + ell + 1);
     1400                }
     1401                y1  = f.Forward(1, r, x1);
     1402                ok &= y1.size() == r*m;
     1403
     1404                // secondorder Taylor coefficients
     1405                CPPAD_TESTVECTOR(double) x2(r*n), y2;
     1406                for(ell = 0; ell < r; ell++)
     1407                {       for(j = 0; j < n; j++)
     1408                                x2[ r * j + ell ] = double(j + ell + 2);
     1409                }
     1410                y2  = f.Forward(2, r, x2);
     1411                ok &= y2.size() == r*m;
     1412                //
     1413                // Y_0  (t)    = F[X_0(t)]
    14141414                //             =  tan(0.5 + 1t + 2t^2)
    14151415                // Y_0' (t)    =  cos(0.5 + 1t + 2t^2)^(-2)*(1 + 4t)
     
    14181418                double y_1_0   = sec_sq;
    14191419                double y_2_0   = (2.0 * tan(0.5) + 4.0) * sec_sq / 2.0;
    1420                 // 
    1421                 // Y_1  (t)    = F[X_1(t)] 
     1420                //
     1421                // Y_1  (t)    = F[X_1(t)]
    14221422                //             = tan(0.5 + 2t + 3t^2)
    14231423                // Y_1' (t)    = cos(0.5 + 2t + 3t^2)^(-2)*(2 + 6t)
     
    14341434        }
    14351435        // ---------------------------------------------------------------------
    1436         // Usr*Op 
     1436        // Usr*Op
    14371437        typedef CPPAD_TESTVECTOR(AD<double>) avector;
    14381438        void usr_algo(const avector& x, avector& z)
     
    14501450                size_t n = 2;
    14511451                avector ax(n), az(3);
    1452                 ax[0] = 0.5; 
     1452                ax[0] = 0.5;
    14531453                ax[1] = 2.0;
    14541454                CppAD::checkpoint<double> usr_check("usr_check", usr_algo, ax, az);
     
    14591459                // record checkpoint function
    14601460                usr_check(ax, az);
    1461        
     1461
    14621462                // range space vector
    14631463                size_t m = 2;
     
    14681468                // create f: x -> y and stop tape recording
    14691469                CppAD::ADFun<double> f(ax, ay);
    1470        
    1471                 // first order Taylor coefficients
    1472                 size_t r = 2, ell;
    1473                 CPPAD_TESTVECTOR(double) x1(r*n), y1;
    1474                 for(ell = 0; ell < r; ell++)
    1475                 {       for(j = 0; j < n; j++)
    1476                                 x1[ r * j + ell ] = double(j + ell + 1);
    1477                 }
    1478                 y1  = f.Forward(1, r, x1);
    1479                 ok &= y1.size() == r*m;
    1480                
    1481                 // secondorder Taylor coefficients
    1482                 CPPAD_TESTVECTOR(double) x2(r*n), y2;
    1483                 for(ell = 0; ell < r; ell++)
    1484                 {       for(j = 0; j < n; j++)
    1485                                 x2[ r * j + ell ] = double(j + ell + 2);
    1486                 }
    1487                 y2  = f.Forward(2, r, x2);
    1488                 ok &= y2.size() == r*m;
    1489                 // 
     1470
     1471                // first order Taylor coefficients
     1472                size_t r = 2, ell;
     1473                CPPAD_TESTVECTOR(double) x1(r*n), y1;
     1474                for(ell = 0; ell < r; ell++)
     1475                {       for(j = 0; j < n; j++)
     1476                                x1[ r * j + ell ] = double(j + ell + 1);
     1477                }
     1478                y1  = f.Forward(1, r, x1);
     1479                ok &= y1.size() == r*m;
     1480
     1481                // secondorder Taylor coefficients
     1482                CPPAD_TESTVECTOR(double) x2(r*n), y2;
     1483                for(ell = 0; ell < r; ell++)
     1484                {       for(j = 0; j < n; j++)
     1485                                x2[ r * j + ell ] = double(j + ell + 2);
     1486                }
     1487                y2  = f.Forward(2, r, x2);
     1488                ok &= y2.size() == r*m;
     1489                //
    14901490                // Y0_0 (t)    = 0.5 + 1t + 2t^2
    14911491                double y0_1_0  = 1.0;
    14921492                double y0_2_0  = 2.0;
    1493                 // 
     1493                //
    14941494                // Y0_1 (t)    = 0.5 + 2t + 3t^2
    14951495                double y0_1_1  = 2.0;
    14961496                double y0_2_1  = 3.0;
    1497                 // 
     1497                //
    14981498                // Y1_0 (t)    = 2.0 + 2t + 3t^2
    14991499                double y1_1_0  = 2.0;
    15001500                double y1_2_0  = 3.0;
    1501                 // 
     1501                //
    15021502                // Y1_1 (t)    = 2.0 + 3t + 4t^2
    15031503                double y1_1_1  = 3.0;
     
    15201520        // CosOp, SinOp, TanOp, ExpOp, MulvvOp, DivvpOp, AddpvOp
    15211521        //
    1522         // AcosOp 
     1522        // AcosOp
    15231523        AD<double> acos_fun(const AD<double>& x)
    15241524        {       return acos( cos(x) ); }
     
    15261526        {       return check_identity(acos_fun, 0.5); }
    15271527        //
    1528         // AsinOp
     1528        // AcoshOp
     1529        AD<double> acosh_fun(const AD<double>& x)
     1530        {       return acosh( cosh(x) ); }
     1531        bool acosh_op(void)
     1532        {       return check_identity(acosh_fun, 0.5); }
     1533        //
     1534        // AsinOp
    15291535        AD<double> asin_fun(const AD<double>& x)
    15301536        {       return asin( sin(x) ); }
     
    15321538        {       return check_identity(asin_fun, 0.5); }
    15331539        //
    1534         // AtanOp
     1540        // AsinhOp
     1541        AD<double> asinh_fun(const AD<double>& x)
     1542        {       return asinh( sinh(x) ); }
     1543        bool asinh_op(void)
     1544        {       return check_identity(asinh_fun, 0.5); }
     1545        //
     1546        // AtanOp
    15351547        AD<double> atan_fun(const AD<double>& x)
    15361548        {       return atan( tan(x) ); }
     
    15381550        {       return check_identity(atan_fun, 0.5); }
    15391551        //
    1540         // LogOp
     1552        // AtanhOp
     1553        AD<double> atanh_fun(const AD<double>& x)
     1554        {       return atanh( tanh(x) ); }
     1555        bool atanh_op(void)
     1556        {       return check_identity(atanh_fun, 0.5); }
     1557        //
     1558        // LogOp
    15411559        AD<double> log_fun(const AD<double>& x)
    15421560        {       return log( exp(x) ); }
     
    15881606        ok     &= abs_op();
    15891607        ok     &= acos_op();
     1608        ok     &= acosh_op();
    15901609        ok     &= asin_op();
     1610        ok     &= asinh_op();
    15911611        ok     &= atan_op();
     1612        ok     &= atanh_op();
    15921613        ok     &= addpv_op();
    15931614        ok     &= addvv_op();
  • trunk/test_more/makefile.am

    r3680 r3682  
    101101        add_zero.cpp \
    102102        atan.cpp \
     103        atanh.cpp \
    103104        atan2.cpp \
    104105        base_alloc.cpp \
  • trunk/test_more/makefile.in

    r3681 r3682  
    105105        alloc_openmp.cpp test_more.cpp abs.cpp acos.cpp acosh.cpp \
    106106        adfun_copy.cpp asin.cpp asinh.cpp assign.cpp add.cpp \
    107         add_eq.cpp add_zero.cpp atan.cpp atan2.cpp base_alloc.cpp \
    108         check_simple_vector.cpp checkpoint.cpp compare.cpp \
    109         compare_change.cpp cond_exp.cpp cond_exp_ad.cpp \
     107        add_eq.cpp add_zero.cpp atan.cpp atanh.cpp atan2.cpp \
     108        base_alloc.cpp check_simple_vector.cpp checkpoint.cpp \
     109        compare.cpp compare_change.cpp cond_exp.cpp cond_exp_ad.cpp \
    110110        cond_exp_rev.cpp copy.cpp cos.cpp cosh.cpp dbl_epsilon.cpp \
    111111        div.cpp div_eq.cpp div_zero_one.cpp erf.cpp exp.cpp \
     
    131131        asin.$(OBJEXT) asinh.$(OBJEXT) assign.$(OBJEXT) add.$(OBJEXT) \
    132132        add_eq.$(OBJEXT) add_zero.$(OBJEXT) atan.$(OBJEXT) \
    133         atan2.$(OBJEXT) base_alloc.$(OBJEXT) \
     133        atanh.$(OBJEXT) atan2.$(OBJEXT) base_alloc.$(OBJEXT) \
    134134        check_simple_vector.$(OBJEXT) checkpoint.$(OBJEXT) \
    135135        compare.$(OBJEXT) compare_change.$(OBJEXT) cond_exp.$(OBJEXT) \
     
    352352cppad_SOURCE_DIR = @cppad_SOURCE_DIR@
    353353cppad_boostvector = @cppad_boostvector@
     354cppad_compiler_has_acosh = @cppad_compiler_has_acosh@
    354355cppad_compiler_has_asinh = @cppad_compiler_has_asinh@
     356cppad_compiler_has_atanh = @cppad_compiler_has_atanh@
    355357cppad_compiler_has_erf = @cppad_compiler_has_erf@
    356358cppad_cppadvector = @cppad_cppadvector@
     
    487489        add_zero.cpp \
    488490        atan.cpp \
     491        atanh.cpp \
    489492        atan2.cpp \
    490493        base_alloc.cpp \
     
    629632@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/atan.Po@am__quote@
    630633@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/atan2.Po@am__quote@
     634@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/atanh.Po@am__quote@
    631635@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/base_adolc.Po@am__quote@
    632636@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/base_alloc.Po@am__quote@
  • trunk/test_more/test_more.cpp

    r3680 r3682  
    2929extern bool asinh(void);
    3030extern bool assign(void);
    31 extern bool Atan(void);
     31extern bool atan(void);
     32extern bool atanh(void);
    3233extern bool atan2(void);
    3334extern bool base_adolc(void);
     
    145146        ok &= Run( asinh,           "asinh"          );
    146147        ok &= Run( assign,          "assign"         );
    147         ok &= Run( Atan,            "Atan"           );
     148        ok &= Run( atan,            "atan"           );
     149        ok &= Run( atanh,           "atanh"          );
    148150        ok &= Run( atan2,           "atan2"          );
    149151        ok &= Run( check_simple_vector, "check_simple_vector" );
Note: See TracChangeset for help on using the changeset viewer.