Changeset 3675


Ignore:
Timestamp:
May 5, 2015 10:26:18 AM (5 years ago)
Author:
bradbell
Message:

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

commit bf9459823c22b7b496d632ebde31ca166a1cc81b
Author: Brad Bell <bradbell@…>
Date: Tue May 5 06:53:28 2015 -0700

New doxygen requires GENERATE_HTML (default has changed from YES to NO).


doxyfile.sh: set GENERATE_HTML to YES.
cskip_op.hpp: fix error in doxygen command, remove trailing white space.

commit 158a03f245d13ec00b5474a428645f6712c9ea9f
Author: Brad Bell <bradbell@…>
Date: Tue May 5 06:09:24 2015 -0700

Remove trailing white space.

commit d501584454b6d99e639fafcaeead55f0158965f6
Author: Brad Bell <bradbell@…>
Date: Tue May 5 06:04:14 2015 -0700

  1. Add the inverse hyperbolic sine function asinh.
  2. Change the asin test name from Asin to asin.


base_require.hpp: remove spelling commands that are no longer used.
remove include: remove include commands that are no longer needed.
asin.cpp: use machine epsilon to gauge accuracy of this test result.

Location:
trunk
Files:
4 added
38 edited

Legend:

Unmodified
Added
Removed
  • trunk/bin/doxyfile.sh

    r3238 r3675  
    22# $Id$
    33# -----------------------------------------------------------------------------
    4 # CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
     4# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
    55#
    66# CppAD is distributed under multiple licenses. This distribution is under
     
    3838FILE_PATTERNS           =  *.hpp  *.cpp
    3939FULL_PATH_NAMES         = NO
     40GENERATE_HTML           = YES
    4041GENERATE_LATEX          = NO
    4142GENERATE_TREEVIEW       = YES
  • trunk/cppad/CMakeLists.txt

    r3656 r3675  
    147147# -----------------------------------------------------------------------------
    148148# cppad_compiler_has_erf
    149 #
    150 SET(source "
     149# cppad_compiler_has_asinh
     150#
     151SET(source_template "
    151152# include <cmath>
    152153int main(void)
    153 {       if( std::erf(0.0) == 0.0 )
     154{       if( std::c11_function(0.0) == 0.0 )
    154155                return 0;
    155156        return 1;
     
    157158"
    158159)
    159 check_source_runs("${source}" cppad_compiler_has_erf)
     160FOREACH(c11_function erf asinh)
     161        STRING(REPLACE "c11_function" ${c11_function} source "${source_template}" )
     162        check_source_runs("${source}" cppad_compiler_has_${c11_function} )
     163ENDFOREACH(c11_function erf asinh)
    160164# -----------------------------------------------------------------------------
    161165# cppad_has_high_resolution_clock
  • trunk/cppad/base_require.hpp

    r3665 r3675  
    2828        cppad.hpp
    2929        namespace
    30         acos
    31         asin
    32         atan
    33         cos
    34         sqrt
    3530        optimizations
    3631        bool
  • trunk/cppad/configure.hpp.in

    r3656 r3675  
    6969*/
    7070# define CPPAD_COMPILER_HAS_ERF @cppad_compiler_has_erf@
     71# endif
     72
     73# if __cplusplus >= 201100
     74/*!
     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@
    7179# endif
    7280
  • trunk/cppad/example/base_adolc.hpp

    r3495 r3675  
    33# define CPPAD_BASE_ADOLC_INCLUDED
    44/* --------------------------------------------------------------------------
    5 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
     5CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
    66
    77CppAD is distributed under multiple licenses. This distribution is under
    8 the terms of the 
     8the terms of the
    99                    Eclipse Public License Version 1.0.
    1010
     
    1515$begin base_adolc.hpp$$
    1616$spell
     17        asinh
    1718        erf
    1819        ifndef
     
    5657$index Adolc, adouble as Base$$
    5758$index Base, Adolc's adouble$$
    58 $index adouble, as Base$$ 
     59$index adouble, as Base$$
    5960
    6061$section Enable use of AD<Base> where Base is Adolc's adouble Type$$
     
    9697This enables one to include conditionals in the recording of
    9798$code adouble$$ operations and later evaluation for different
    98 values of the independent variables 
     99values of the independent variables
    99100(in the same spirit as the CppAD $cref CondExp$$ function).
    100101$codep */
     
    143144
    144145$head EqualOpSeq$$
    145 The Adolc user interface does not specify a way to determine if 
    146 two $code adouble$$ variables correspond to the same operations sequence. 
     146The Adolc user interface does not specify a way to determine if
     147two $code adouble$$ variables correspond to the same operations sequence.
    147148Make $code EqualOpSeq$$ an error if it gets used:
    148149$codep */
     
    160161
    161162$head Identical$$
    162 The Adolc user interface does not specify a way to determine if an 
    163 $code adouble$$ depends on the independent variables. 
     163The Adolc user interface does not specify a way to determine if an
     164$code adouble$$ depends on the independent variables.
    164165To be safe (but slow) return $code false$$ in all the cases below.
    165166$codep */
     
    199200
    200201$head Unary Standard Math$$
    201 The following $cref/required/base_require/$$ functions 
     202The following $cref/required/base_require/$$ functions
    202203are defined by the Adolc package for the $code adouble$$ base case:
    203204$pre
     
    216217$code tan$$.
    217218
     219$head asinh$$
     220If the inverse hyperbolic sine function is supported by the compiler,
     221it must also be supported by a $icode Base$$ type;
     222see $cref/asinh/base_std_math/asinh/$$.
     223The adolc package does not support this function:
     224$codep */
     225namespace CppAD {
     226# if CPPAD_COMPILER_HAS_ASINH
     227        inline adouble asinh(const adouble& x)
     228        {       CPPAD_ASSERT_KNOWN(
     229                        false,
     230                        "erf: adolc does not support the inverse hyperbolic sine function"
     231                );
     232                return 0;
     233        }
     234# endif
     235}
     236/* $$
     237
    218238$head erf$$
    219239If the error function is supported by the compiler,
     
    225245# if CPPAD_COMPILER_HAS_ERF
    226246        inline adouble erf(const adouble& x)
    227         {       CPPAD_ASSERT_KNOWN( 
     247        {       CPPAD_ASSERT_KNOWN(
    228248                        false,
    229249                        "erf: adolc does not support the error function"
     
    233253# endif
    234254}
    235 /* $$ 
     255/* $$
    236256
    237257
    238258
    239259$head sign$$
    240 This $cref/required/base_require/$$ function is defined using the 
     260This $cref/required/base_require/$$ function is defined using the
    241261$code codassign$$ function so that its $code adouble$$ operation sequence
    242262does not depend on the value of $icode x$$.
     
    256276
    257277$head abs$$
    258 This $cref/required/base_require/$$ function uses the adolc $code fabs$$ 
     278This $cref/required/base_require/$$ function uses the adolc $code fabs$$
    259279function:
    260280$codep */
     
    266286
    267287$head pow$$
    268 This $cref/required/base_require/$$ function 
     288This $cref/required/base_require/$$ function
    269289is defined by the Adolc package for the $code adouble$$ base case.
    270290
  • trunk/cppad/local/ad.hpp

    r3607 r3675  
    77
    88CppAD is distributed under multiple licenses. This distribution is under
    9 the terms of the 
     9the terms of the
    1010                    Eclipse Public License Version 1.0.
    1111
     
    2727
    2828typedef enum {
    29         tape_manage_new, 
    30         tape_manage_delete, 
     29        tape_manage_new,
     30        tape_manage_delete,
    3131        tape_manage_clear
    3232} tape_manage_job;
     
    4343
    4444        // one argument functions
    45         friend bool Parameter          <Base> 
     45        friend bool Parameter          <Base>
    4646                (const AD<Base>    &u);
    4747        friend bool Parameter          <Base>
    4848                (const VecAD<Base> &u);
    49         friend bool Variable           <Base> 
    50                 (const AD<Base>    &u);
    51         friend bool Variable           <Base> 
     49        friend bool Variable           <Base>
     50                (const AD<Base>    &u);
     51        friend bool Variable           <Base>
    5252                (const VecAD<Base> &u);
    53         friend int  Integer            <Base> 
     53        friend int  Integer            <Base>
    5454                (const AD<Base>    &u);
    5555        friend AD   Var2Par            <Base>
     
    7272        friend bool IdenticalZero     <Base> (const AD<Base> &x);
    7373        friend bool IdenticalOne      <Base> (const AD<Base> &x);
    74         friend bool IdenticalEqualPar <Base> 
     74        friend bool IdenticalEqualPar <Base>
    7575                (const AD<Base> &x, const AD<Base> &y);
    7676
    7777        // EqualOpSeq function
    78         friend bool EqualOpSeq <Base> 
     78        friend bool EqualOpSeq <Base>
    7979                (const AD<Base> &u, const AD<Base> &v);
    8080
     
    9292        friend AD<Base> CondExpOp  <Base> (
    9393                enum CompareOp  cop       ,
    94                 const AD<Base> &left      , 
    95                 const AD<Base> &right     , 
    96                 const AD<Base> &trueCase  , 
    97                 const AD<Base> &falseCase 
     94                const AD<Base> &left      ,
     95                const AD<Base> &right     ,
     96                const AD<Base> &trueCase  ,
     97                const AD<Base> &falseCase
    9898        );
    9999
     
    140140                const AD<Base>&    flag   ,
    141141                const char*        before ,
    142                 const AD<Base>&    var    , 
     142                const AD<Base>&    var    ,
    143143                const char*        after
    144144        );
     
    156156        // implicit construction and assingment from base type
    157157        inline AD(const Base &b);
    158         inline AD& operator=(const Base &b); 
     158        inline AD& operator=(const Base &b);
    159159
    160160        // implicit contructor and assignment from VecAD<Base>::reference
     
    206206        inline AD tan(void) const;
    207207        inline AD tanh(void) const;
     208# if CPPAD_COMPILER_HAS_ASINH
     209        inline AD asinh(void) const;
     210# endif
    208211# if CPPAD_COMPILER_HAS_ERF
    209212        inline AD erf(void) const;
     
    212215        // ----------------------------------------------------------
    213216        // static public member functions
    214        
     217
    215218        // abort current AD<Base> recording
    216         static void        abort_recording(void);   
     219        static void        abort_recording(void);
    217220
    218221        // set the maximum number of OpenMP threads (deprecated)
     
    239242        tape_id_t tape_id_;
    240243
    241         // taddr_ in tape for this variable 
     244        // taddr_ in tape for this variable
    242245        addr_t taddr_;
    243246        //
     
    249252        }
    250253        //
    251         // Make this parameter a new variable 
     254        // Make this parameter a new variable
    252255        //
    253256        void make_variable(size_t id,  size_t taddr)
     
    260263        // ---------------------------------------------------------------
    261264        // tape linking functions
    262         // 
     265        //
    263266        // not static
    264267        inline ADTape<Base>* tape_this(void) const;
    265268        //
    266         // static 
     269        // static
    267270        inline static tape_id_t**    tape_id_handle(size_t thread);
    268271        inline static tape_id_t*     tape_id_ptr(size_t thread);
     
    271274        inline static ADTape<Base>*  tape_ptr(void);
    272275        inline static ADTape<Base>*  tape_ptr(tape_id_t tape_id);
    273 }; 
     276};
    274277// ---------------------------------------------------------------------------
    275278
  • trunk/cppad/local/base_complex.hpp

    r3523 r3675  
    33# define CPPAD_BASE_COMPLEX_INCLUDED
    44/* --------------------------------------------------------------------------
    5 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
     5CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
    66
    77CppAD is distributed under multiple licenses. This distribution is under
     
    2222$begin base_complex.hpp$$
    2323$spell
     24        asinh
    2425        endif
    2526        eps
     
    112113
    113114$head EqualOpSeq$$
    114 Complex numbers do not carry operation sequence information. 
    115 Thus they are equal in this sense if and only if there values are equal. 
     115Complex numbers do not carry operation sequence information.
     116Thus they are equal in this sense if and only if there values are equal.
    116117$codep */
    117118namespace CppAD {
    118119        inline bool EqualOpSeq(
    119                 const std::complex<double> &x , 
     120                const std::complex<double> &x ,
    120121                const std::complex<double> &y )
    121         {       return x == y; 
     122        {       return x == y;
    122123        }
    123124}
     
    125126
    126127$head Identical$$
    127 Complex numbers do not carry operation sequence information. 
     128Complex numbers do not carry operation sequence information.
    128129Thus they are all parameters so the identical functions just check values.
    129130$codep */
     
    142143
    143144$head Ordered$$
    144 Complex types do not support comparison operators, 
     145Complex types do not support comparison operators,
    145146$codep */
    146147# undef  CPPAD_USER_MACRO
     
    160161        CPPAD_USER_MACRO(GreaterThanZero)
    161162        inline bool abs_geq(
    162                 const std::complex<double>& x , 
     163                const std::complex<double>& x ,
    163164                const std::complex<double>& y )
    164165        {       return std::abs(x) >= std::abs(y); }
     
    208209
    209210$head Valid Unary Math$$
    210 The following macro invocations define the standard unary 
     211The following macro invocations define the standard unary
    211212math functions that are valid with complex arguments and are
    212213required to use $code AD< std::complex<double> >$$.
     
    224225
    225226$head Invalid Unary Math$$
    226 The following macro definition and invocations define the standard unary 
     227The following macro definition and invocations define the standard unary
    227228math functions that are invalid with complex arguments and are
    228229required to use $code AD< std::complex<double> >$$.
     
    244245        CPPAD_USER_MACRO(atan)
    245246        CPPAD_USER_MACRO(sign)
     247# if CPPAD_COMPILER_HAS_ASINH
     248        CPPAD_USER_MACRO(asinh)
     249# endif
    246250}
    247251/* $$
     
    253257namespace CppAD {
    254258        inline std::complex<double> pow(
    255                 const std::complex<double> &x , 
     259                const std::complex<double> &x ,
    256260                const std::complex<double> &y )
    257261        {       return std::pow(x, y); }
     
    286290        };
    287291        // deprecated machine epsilon
    288         template <> 
     292        template <>
    289293        inline std::complex<double> epsilon< std::complex<double> > (void)
    290294        {       return numeric_limits< std::complex<double> >::epsilon(); }
     
    332336        // EqualOpSeq -----------------------------------------------------
    333337        inline bool EqualOpSeq(
    334                 const std::complex<float> &x , 
     338                const std::complex<float> &x ,
    335339                const std::complex<float> &y )
    336         {       return x == y; 
     340        {       return x == y;
    337341        }
    338342        // Identical ------------------------------------------------------
     
    352356        CPPAD_USER_MACRO_ONE(GreaterThanZero)
    353357        inline bool abs_geq(
    354                 const std::complex<float>& x , 
     358                const std::complex<float>& x ,
    355359                const std::complex<float>& y )
    356360        {       return std::abs(x) >= std::abs(y); }
     
    378382        // The pow function
    379383        inline std::complex<float> pow(
    380                 const std::complex<float> &x , 
     384                const std::complex<float> &x ,
    381385                const std::complex<float> &y )
    382386        {       return std::pow(x, y); }
     
    401405                }
    402406        };
    403         template <> 
     407        template <>
    404408        inline std::complex<float> epsilon< std::complex<float> >(void)
    405409        {       return numeric_limits< std::complex<float> >::epsilon(); }
  • trunk/cppad/local/base_double.hpp

    r3495 r3675  
    33# define CPPAD_BASE_DOUBLE_INCLUDED
    44/* --------------------------------------------------------------------------
    5 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
     5CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
    66
    77CppAD is distributed under multiple licenses. This distribution is under
     
    1818$begin base_double.hpp$$
    1919$spell
     20        asinh
    2021        erf
    2122        endif
     
    5556$codep */
    5657namespace CppAD {
    57         inline double CondExpOp( 
     58        inline double CondExpOp(
    5859                enum CompareOp     cop          ,
    5960                const double&       left         ,
    60                 const double&       right        , 
    61                 const double&       exp_if_true  , 
     61                const double&       right        ,
     62                const double&       exp_if_true  ,
    6263                const double&       exp_if_false )
    6364        {       return CondExpTemplate(cop, left, right, exp_if_true, exp_if_false);
     
    146147        CPPAD_STANDARD_MATH_UNARY(double, tan)
    147148        CPPAD_STANDARD_MATH_UNARY(double, tanh)
     149# if CPPAD_COMPILER_HAS_ASINH
     150        CPPAD_STANDARD_MATH_UNARY(double, asinh)
     151# endif
    148152# if CPPAD_COMPILER_HAS_ERF
    149153        CPPAD_STANDARD_MATH_UNARY(double, erf)
     
    151155}
    152156/* $$
    153 The absolute value function is special because its $code std$$ name is 
     157The absolute value function is special because its $code std$$ name is
    154158$code fabs$$
    155159$codep */
     
    206210        };
    207211        // deprecated machine epsilon
    208         template <> 
     212        template <>
    209213        inline double epsilon<double>(void)
    210214        {       return numeric_limits<double>::epsilon(); }
  • trunk/cppad/local/base_float.hpp

    r3495 r3675  
    33# define CPPAD_BASE_FLOAT_INCLUDED
    44/* --------------------------------------------------------------------------
    5 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
     5CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
    66
    77CppAD is distributed under multiple licenses. This distribution is under
     
    1818$begin base_float.hpp$$
    1919$spell
     20        asinh
    2021        erf
    2122        endif
     
    5556$codep */
    5657namespace CppAD {
    57         inline float CondExpOp( 
     58        inline float CondExpOp(
    5859                enum CompareOp     cop          ,
    5960                const float&       left         ,
    60                 const float&       right        , 
    61                 const float&       exp_if_true  , 
     61                const float&       right        ,
     62                const float&       exp_if_true  ,
    6263                const float&       exp_if_false )
    6364        {       return CondExpTemplate(cop, left, right, exp_if_true, exp_if_false);
     
    147148        CPPAD_STANDARD_MATH_UNARY(float, tan)
    148149        CPPAD_STANDARD_MATH_UNARY(float, tanh)
     150# if CPPAD_COMPILER_HAS_ASINH
     151        CPPAD_STANDARD_MATH_UNARY(float, asinh)
     152# endif
    149153# if CPPAD_COMPILER_HAS_ERF
    150154        CPPAD_STANDARD_MATH_UNARY(float, erf)
     
    152156}
    153157/* $$
    154 The absolute value function is special because its $code std$$ name is 
     158The absolute value function is special because its $code std$$ name is
    155159$code fabs$$
    156160$codep */
     
    175179}
    176180/* $$
    177  
     181
    178182$head pow $$
    179183The following defines a $code CppAD::pow$$ function that
     
    206210        };
    207211        // deprecated machine epsilon
    208         template <> 
     212        template <>
    209213        inline float epsilon<float>(void)
    210214        {       return numeric_limits<float>::epsilon(); }
  • trunk/cppad/local/base_std_math.hpp

    r3495 r3675  
    44
    55/* --------------------------------------------------------------------------
    6 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
     6CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
    77
    88CppAD is distributed under multiple licenses. This distribution is under
    9 the terms of the 
     9the terms of the
    1010                    Eclipse Public License Version 1.0.
    1111
     
    1414-------------------------------------------------------------------------- */
    1515
    16 /* 
     16/*
    1717$begin base_std_math$$
    1818$spell
     19        asinh
    1920        inline
    2021        fabs
     
    4344$codei%AD<%Base%>%$$:
    4445
    45 $head Unary Standard Math$$ 
     46$head Unary Standard Math$$
    4647$index math, base unary$$
    4748$index base, unary math$$
     
    5051unary standard math functions (in the CppAD namespace):
    5152$table
    52 $bold Syntax$$ $cnext $bold Result$$ 
     53$bold Syntax$$ $cnext $bold Result$$
    5354$rnext
    5455$icode%y% = abs(%x%)%$$  $cnext absolute value     $rnext
     
    6465$icode%y% = sinh(%x%)%$$ $cnext hyperbolic sine    $rnext
    6566$icode%y% = sqrt(%x%)%$$ $cnext square root        $rnext
    66 $icode%y% = tan(%x%)%$$  $cnext tangent           
     67$icode%y% = tan(%x%)%$$  $cnext tangent
    6768$tend
    6869where the arguments and return value have the prototypes
     
    8788This macro uses the functions $codei%std::%Fun%$$ which
    8889must be defined and have the same prototype as $codei%CppAD::%Fun%$$.
    89 For example, 
     90For example,
    9091$cref/float/base_float.hpp/Unary Standard Math/$$.
     92
     93$head asinh$$
     94If the inverse hyperbolic sine function is supported by the compiler,
     95$cref/CPPAD_COMPILER_HAS_ASINH/asinh/CPPAD_COMPILER_HAS_ASINH/$$
     96is one,
     97the type $icode Base$$ must support the syntax
     98$codei%
     99        %y% = CppAD::asinh(%x%)
     100%$$
     101where $icode x$$ and $icode y$$ have the same prototype as above.
     102For example, see
     103$cref/base_alloc/base_alloc.hpp/asinh/$$.
    91104
    92105$head erf$$
     
    152165$head isnan$$
    153166$index isnan, base type$$
    154 $index base, isnan$$ 
     167$index base, isnan$$
    155168If $icode Base$$ defines the $code isnan$$ function,
    156169you may also have to provide a definition in the CppAD namespace
  • trunk/cppad/local/cskip_op.hpp

    r3370 r3675  
    44
    55/* --------------------------------------------------------------------------
    6 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
     6CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
    77
    88CppAD is distributed under multiple licenses. This distribution is under
    9 the terms of the 
     9the terms of the
    1010                    Eclipse Public License Version 1.0.
    1111
     
    4040\verbatim
    4141        enum CompareOp {
    42                 CompareLt, 
    43                 CompareLe, 
    44                 CompareEq, 
    45                 CompareGe, 
    46                 CompareGt, 
     42                CompareLt,
     43                CompareLe,
     44                CompareEq,
     45                CompareGe,
     46                CompareGt,
    4747                CompareNe
    4848        }
     
    6161If this is zero, right is a parameter. Otherwise it is a variable.
    6262\n
    63 \a arg[2] 
     63\a arg[2]
    6464is the index corresponding to left in comparision.
    6565\n
    66 \a arg[3] 
     66\a arg[3]
    6767is the index corresponding to right in comparision.
    6868\n
    69 \a arg[4] 
     69\a arg[4]
    7070is the number of operations to skip if the comparision result is true.
    7171\n
    72 \a arg[5] 
     72\a arg[5]
    7373is the number of operations to skip if the comparision result is false.
    7474\n
     
    101101is the zeroth order Taylor coefficient corresponding to right.
    102102
    103 \param \cskip_op [in,out]
     103\param cskip_op [in,out]
    104104is vector specifying which operations are at this point are know to be
    105 unecessary and can be skipped. 
     105unecessary and can be skipped.
    106106This is both an input and an output.
    107107*/
     
    178178        if( true_case )
    179179        {       for(size_t i = 0; i < size_t(arg[4]); i++)
    180                         cskip_op[ arg[6+i] ] = true; 
     180                        cskip_op[ arg[6+i] ] = true;
    181181        }
    182182        else
    183183        {       for(size_t i = 0; i < size_t(arg[5]); i++)
    184                         cskip_op[ arg[6+arg[4]+i] ] = true; 
     184                        cskip_op[ arg[6+arg[4]+i] ] = true;
    185185        }
    186186        return;
  • trunk/cppad/local/erf.hpp

    r3495 r3675  
    1 // $Id:$
     1// $Id$
    22# ifndef CPPAD_ERF_INCLUDED
    33# define CPPAD_ERF_INCLUDED
    44
    55/* --------------------------------------------------------------------------
    6 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
     6CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
    77
    88CppAD is distributed under multiple licenses. This distribution is under
    9 the terms of the 
     9the terms of the
    1010                    Eclipse Public License Version 1.0.
    1111
     
    7474
    7575$subhead Other$$
    76 If the function $codei%std::erf(double %x%)%$$ is not defined, 
    77 CppAD uses a fast approximation (few numerical operations) 
     76If the function $codei%std::erf(double %x%)%$$ is not defined,
     77CppAD uses a fast approximation (few numerical operations)
    7878with relative error bound $latex 4 \times 10^{-4}$$; see
    7979Vedder, J.D.,
    8080$icode Simple approximations for the error function and its inverse$$,
    81 American Journal of Physics, 
    82 v 55, 
    83 n 8, 
    84 1987, 
     81American Journal of Physics,
     82v 55,
     83n 8,
     841987,
    8585p 762-3.
    8686
     
    9191The file
    9292$cref erf.cpp$$
    93 contains an example and test of this function.   
     93contains an example and test of this function.
    9494It returns true if it succeeds and false otherwise.
    9595
     
    9898*/
    9999# include <cppad/configure.hpp>
    100 # include <cppad/local/cppad_assert.hpp>
    101 
    102 // needed before one can use CPPAD_ASSERT_FIRST_CALL_NOT_PARALLEL
    103 # include <cppad/thread_alloc.hpp>
    104 
    105100# if ! CPPAD_COMPILER_HAS_ERF
    106101
    107102// BEGIN CppAD namespace
    108 namespace CppAD {   
     103namespace CppAD {
    109104
    110105template <class Type>
     
    112107{       using CppAD::exp;
    113108        const Type a = static_cast<Type>(993./880.);
    114         const Type b = static_cast<Type>(89./880.); 
     109        const Type b = static_cast<Type>(89./880.);
    115110
    116111        return tanh( (a + b * x * x) * x );
  • trunk/cppad/local/forward0sweep.hpp

    r3607 r3675  
    77
    88CppAD is distributed under multiple licenses. This distribution is under
    9 the terms of the 
     9the terms of the
    1010                    Eclipse Public License Version 1.0.
    1111
     
    3131        user_ok = user_atom->forward
    3232\endcode
    33 This maco is undefined at the end of this file to facillitate is 
     33This maco is undefined at the end of this file to facillitate is
    3434use with a different definition in other files.
    3535*/
     
    4242/*!
    4343\def CPPAD_FORWARD0SWEEP_TRACE
    44 This value is either zero or one. 
     44This value is either zero or one.
    4545Zero is the normal operational value.
    4646If it is one, a trace of every forward0sweep computation is printed.
     
    8686The exception to this is that while palying back the tape
    8787the object play holds information about the current location
    88 with in the tape and this changes during palyback. 
     88with in the tape and this changes during palyback.
    8989
    9090\param J
     
    9999For i = 1 , ... , n,
    100100<code>taylor [i * J + 0]</code>
    101 variable with index j on the tape 
     101variable with index j on the tape
    102102(these are the independent variables).
    103103\n
    104104\n
    105 \b Output: 
     105\b Output:
    106106For i = n + 1, ... , numvar - 1,
    107107<code>taylor [i * J + 0]</code>
    108 is the zero order Taylor coefficient for the variable with 
     108is the zero order Taylor coefficient for the variable with
    109109index i on the tape.
    110110
     
    112112Is a vector with size play->num_op_rec().
    113113The input value of the elements does not matter.
    114 Upon return, if cskip_op[i] is true, the operator index i 
    115 does not affect any of the dependent variable 
     114Upon return, if cskip_op[i] is true, the operator index i
     115does not affect any of the dependent variable
    116116(given the value of the independent variables).
    117117
     
    119119Is a vector with size play->num_load_op_rec().
    120120The input value of the elements does not matter.
    121 Upon return, 
     121Upon return,
    122122it is the variable index corresponding the result for each load operator.
    123123In the case where the index is zero,
     
    132132If compare_change_count is zero, this value is set to zero.
    133133Otherwise, the return value is the number of comparision operations
    134 that have a different result from when the information in 
     134that have a different result from when the information in
    135135play was recorded.
    136136
     
    138138If compare_change_count is zero, this value is set to zero.
    139139Otherwise it is the operator index (see forward_next) for the count-th
    140 comparision operation that has a different result from when the information in 
     140comparision operation that has a different result from when the information in
    141141play was recorded.
    142142*/
     
    173173        size_t i_op;
    174174
    175         // next variables 
     175        // next variables
    176176        size_t i_var;
    177177
     
    210210        vector<bool> user_vx;        // empty vecotor
    211211        vector<bool> user_vy;        // empty vecotor
    212         vector<Base> user_tx;        // argument vector Taylor coefficients 
    213         vector<Base> user_ty;        // result vector Taylor coefficients 
     212        vector<Base> user_tx;        // argument vector Taylor coefficients
     213        vector<Base> user_ty;        // result vector Taylor coefficients
    214214        size_t user_index = 0;       // indentifier for this atomic operation
    215215        size_t user_id    = 0;       // user identifier for this call to operator
     
    248248
    249249# if CPPAD_FORWARD0SWEEP_TRACE
    250         // variable indices for results vector 
     250        // variable indices for results vector
    251251        // (done differently for order zero).
    252         vector<size_t> user_iy;     
     252        vector<size_t> user_iy;
    253253# endif
    254254
     
    264264                // this op
    265265                play->forward_next(op, arg, i_op, i_var);
    266                 CPPAD_ASSERT_UNKNOWN( (i_op > n)  | (op == InvOp) ); 
    267                 CPPAD_ASSERT_UNKNOWN( (i_op <= n) | (op != InvOp) ); 
     266                CPPAD_ASSERT_UNKNOWN( (i_op > n)  | (op == InvOp) );
     267                CPPAD_ASSERT_UNKNOWN( (i_op <= n) | (op != InvOp) );
    268268                CPPAD_ASSERT_UNKNOWN( i_op < play->num_op_rec() );
    269269                CPPAD_ASSERT_ARG_BEFORE_RESULT(op, arg, i_var);
     
    317317                        // -------------------------------------------------
    318318
     319                        case AsinhOp:
     320                        // sqrt(1 - x * x), asin(x)
     321                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
     322                        forward_asinh_op_0(i_var, arg[0], J, taylor);
     323                        break;
     324                        // -------------------------------------------------
     325
    319326                        case AtanOp:
    320327                        // 1 + x * x, atan(x)
     
    325332
    326333                        case CExpOp:
    327                         // Use the general case with d == 0 
     334                        // Use the general case with d == 0
    328335                        // (could create an optimzied verison for this case)
    329336                        forward_cond_op_0(
     
    443450                        forward_load_p_op_0(
    444451                                play,
    445                                 i_var, 
    446                                 arg, 
    447                                 parameter, 
    448                                 J, 
     452                                i_var,
     453                                arg,
     454                                parameter,
     455                                J,
    449456                                taylor,
    450457                                isvar_by_ind.data(),
     
    458465                        forward_load_v_op_0(
    459466                                play,
    460                                 i_var, 
    461                                 arg, 
    462                                 parameter, 
    463                                 J, 
     467                                i_var,
     468                                arg,
     469                                parameter,
     470                                J,
    464471                                taylor,
    465472                                isvar_by_ind.data(),
     
    641648                        case StppOp:
    642649                        forward_store_pp_op_0(
    643                                 i_var, 
    644                                 arg, 
    645                                 num_par, 
    646                                 J, 
     650                                i_var,
     651                                arg,
     652                                num_par,
     653                                J,
    647654                                taylor,
    648655                                isvar_by_ind.data(),
     
    654661                        case StpvOp:
    655662                        forward_store_pv_op_0(
    656                                 i_var, 
    657                                 arg, 
    658                                 num_par, 
    659                                 J, 
     663                                i_var,
     664                                arg,
     665                                num_par,
     666                                J,
    660667                                taylor,
    661668                                isvar_by_ind.data(),
     
    667674                        case StvpOp:
    668675                        forward_store_vp_op_0(
    669                                 i_var, 
    670                                 arg, 
    671                                 num_par, 
    672                                 J, 
     676                                i_var,
     677                                arg,
     678                                num_par,
     679                                J,
    673680                                taylor,
    674681                                isvar_by_ind.data(),
     
    680687                        case StvvOp:
    681688                        forward_store_vv_op_0(
    682                                 i_var, 
    683                                 arg, 
    684                                 num_par, 
    685                                 J, 
     689                                i_var,
     690                                arg,
     691                                num_par,
     692                                J,
    686693                                taylor,
    687694                                isvar_by_ind.data(),
     
    734741# ifndef NDEBUG
    735742                                if( user_atom == CPPAD_NULL )
    736                                 {       std::string msg = 
     743                                {       std::string msg =
    737744                                                atomic_base<Base>::class_name(user_index)
    738745                                                + ": atomic_base function has been deleted";
     
    760767# ifndef NDEBUG
    761768                                if( ! user_ok )
    762                                 {       std::string msg = 
     769                                {       std::string msg =
    763770                                                atomic_base<Base>::class_name(user_index)
    764771                                                + ": atomic_base.forward: returned false";
     
    783790                        {       // call users function for this operation
    784791                                user_atom->set_id(user_id);
    785                                 CPPAD_ATOMIC_CALL(p, q, 
     792                                CPPAD_ATOMIC_CALL(p, q,
    786793                                        user_vx, user_vy, user_tx, user_ty
    787794                                );
     
    799806                        {       // call users function for this operation
    800807                                user_atom->set_id(user_id);
    801                                 CPPAD_ATOMIC_CALL(p, q, 
     808                                CPPAD_ATOMIC_CALL(p, q,
    802809                                        user_vx, user_vy, user_tx, user_ty
    803810                                );
     
    844851                        {       size_t i_tmp   = (i_op + i) - user_m;
    845852                                printOp(
    846                                         std::cout, 
     853                                        std::cout,
    847854                                        play,
    848855                                        i_tmp,
    849856                                        user_iy[i],
    850                                         UsrrvOp, 
     857                                        UsrrvOp,
    851858                                        CPPAD_NULL
    852859                                );
    853860                                Base* Z_tmp = taylor + user_iy[i] * J;
    854861                                printOpResult(
    855                                         std::cout, 
    856                                         d + 1, 
     862                                        std::cout,
     863                                        d + 1,
    857864                                        Z_tmp,
    858                                         0, 
     865                                        0,
    859866                                        (Base *) CPPAD_NULL
    860867                                );
     
    871878                {
    872879                        printOp(
    873                                 std::cout, 
     880                                std::cout,
    874881                                play,
    875882                                i_op,
    876883                                i_var,
    877                                 op, 
     884                                op,
    878885                                arg_tmp
    879886                        );
    880887                        if( NumRes(op) > 0 ) printOpResult(
    881                                 std::cout, 
    882                                 d + 1, 
    883                                 Z_tmp, 
    884                                 0, 
     888                                std::cout,
     889                                d + 1,
     890                                Z_tmp,
     891                                0,
    885892                                (Base *) CPPAD_NULL
    886893                        );
  • trunk/cppad/local/forward1sweep.hpp

    r3607 r3675  
    77
    88CppAD is distributed under multiple licenses. This distribution is under
    9 the terms of the 
     9the terms of the
    1010                    Eclipse Public License Version 1.0.
    1111
     
    3131        user_ok = user_atom->forward
    3232\endcode
    33 This macro is undefined at the end of this file to facillitate its 
     33This macro is undefined at the end of this file to facillitate its
    3434use with a different definition in other files.
    3535*/
     
    4242/*!
    4343\def CPPAD_FORWARD1SWEEP_TRACE
    44 This value is either zero or one. 
     44This value is either zero or one.
    4545Zero is the normal operational value.
    4646If it is one, a trace of every forward1sweep computation is printed.
     
    8585The exception to this is that while palying back the tape
    8686the object play holds information about the current location
    87 with in the tape and this changes during palyback. 
     87with in the tape and this changes during palyback.
    8888
    8989\param J
     
    102102the input value of the elements does not matter.
    103103Upon return, if cskip_op[i] is true, the operator with index i
    104 does not affect any of the dependent variable 
     104does not affect any of the dependent variable
    105105(given the value of the independent variables).
    106106\n
     
    108108<tt>p > 0</tt>
    109109\n
    110 In this case cskip_op is not modified and has the same meaning 
     110In this case cskip_op is not modified and has the same meaning
    111111as its return value above.
    112112
     
    119119In this case,
    120120The input value of the elements does not matter.
    121 Upon return, 
     121Upon return,
    122122it is the variable index corresponding the result for each load operator.
    123123In the case where the index is zero,
     
    128128<tt>p > 0</tt>
    129129\n
    130 In this case var_by_load_op is not modified and has the meaning 
     130In this case var_by_load_op is not modified and has the meaning
    131131as its return value above.
    132132
    133133\param p
    134134is the lowest order of the Taylor coefficients
    135 that are computed during this call. 
     135that are computed during this call.
    136136
    137137\param q
    138138is the highest order of the Taylor coefficients
    139 that are computed during this call. 
     139that are computed during this call.
    140140
    141141\param taylor
     
    145145<code>k = 0 , ... , p-1</code>,
    146146<code>taylor[ J*i + k]</code>
    147 is the k-th order Taylor coefficient corresponding to 
     147is the k-th order Taylor coefficient corresponding to
    148148the i-th variable.
    149149\n
     
    153153<code>k = p , ... , q</code>,
    154154<code>taylor[ J*j + k]</code>
    155 is the k-th order Taylor coefficient corresponding to 
    156 the i-th variable 
     155is the k-th order Taylor coefficient corresponding to
     156the i-th variable
    157157(these are the independent varaibles).
    158158\n
    159159\n
    160 \b Output: 
    161 For <code>i = n+1 , ... , numvar-1</code>, and 
     160\b Output:
     161For <code>i = n+1 , ... , numvar-1</code>, and
    162162<code>k = 0 , ... , p-1</code>,
    163163<code>taylor[ J*i + k]</code>
    164164is the k-th order Taylor coefficient corresponding to
    165 the i-th variable. 
     165the i-th variable.
    166166
    167167
     
    174174If compare_change_count is zero, this value is set to zero, otherwise:
    175175this value is set to the number of comparision operations
    176 that have a different result from when the information in 
     176that have a different result from when the information in
    177177play was recorded.
    178178
     
    181181If compare_change_count is zero, this value is set to zero.
    182182Otherwise it is the operator index (see forward_next) for the count-th
    183 comparision operation that has a different result from when the information in 
     183comparision operation that has a different result from when the information in
    184184play was recorded.
    185185*/
     
    219219        size_t i_op;
    220220
    221         // next variables 
     221        // next variables
    222222        size_t i_var;
    223223
     
    256256        vector<bool> user_vx;        // empty vecotor
    257257        vector<bool> user_vy;        // empty vecotor
    258         vector<Base> user_tx;        // argument vector Taylor coefficients 
    259         vector<Base> user_ty;        // result vector Taylor coefficients 
     258        vector<Base> user_tx;        // argument vector Taylor coefficients
     259        vector<Base> user_ty;        // result vector Taylor coefficients
    260260        size_t user_index = 0;       // indentifier for this atomic operation
    261261        size_t user_id    = 0;       // user identifier for this call to operator
     
    299299        const size_t user_q1 = q+1;
    300300
    301         // variable indices for results vector 
     301        // variable indices for results vector
    302302        // (done differently for order zero).
    303         vector<size_t> user_iy;     
     303        vector<size_t> user_iy;
    304304
    305305        // skip the BeginOp at the beginning of the recording
     
    314314                // this op
    315315                play->forward_next(op, arg, i_op, i_var);
    316                 CPPAD_ASSERT_UNKNOWN( (i_op > n)  | (op == InvOp) ); 
    317                 CPPAD_ASSERT_UNKNOWN( (i_op <= n) | (op != InvOp) ); 
     316                CPPAD_ASSERT_UNKNOWN( (i_op > n)  | (op == InvOp) );
     317                CPPAD_ASSERT_UNKNOWN( (i_op <= n) | (op != InvOp) );
    318318                CPPAD_ASSERT_UNKNOWN( i_op < play->num_op_rec() );
    319319                CPPAD_ASSERT_ARG_BEFORE_RESULT(op, arg, i_var);
     
    322322                while( cskip_op[i_op] )
    323323                {       if( op == CSumOp )
    324                         {       // CSumOp has a variable number of arguments 
     324                        {       // CSumOp has a variable number of arguments
    325325                                play->forward_csum(op, arg, i_op, i_var);
    326326                        }
     
    367367                        // -------------------------------------------------
    368368
     369                        case AsinhOp:
     370                        // sqrt(1 + x * x), asin(x)
     371                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
     372                        forward_asinh_op(p, q, i_var, arg[0], J, taylor);
     373                        break;
     374                        // -------------------------------------------------
     375
    369376                        case AtanOp:
    370377                        // 1 + x * x, atan(x)
     
    492499                        {       forward_load_p_op_0(
    493500                                        play,
    494                                         i_var, 
    495                                         arg, 
    496                                         parameter, 
    497                                         J, 
     501                                        i_var,
     502                                        arg,
     503                                        parameter,
     504                                        J,
    498505                                        taylor,
    499506                                        isvar_by_ind.data(),
     
    501508                                        var_by_load_op.data()
    502509                                );
    503                                 if( p < q ) forward_load_op( 
     510                                if( p < q ) forward_load_op(
    504511                                        play,
    505512                                        op,
     
    514521                                );
    515522                        }
    516                         else    forward_load_op( 
     523                        else    forward_load_op(
    517524                                play,
    518525                                op,
     
    533540                        {       forward_load_v_op_0(
    534541                                        play,
    535                                         i_var, 
    536                                         arg, 
    537                                         parameter, 
    538                                         J, 
     542                                        i_var,
     543                                        arg,
     544                                        parameter,
     545                                        J,
    539546                                        taylor,
    540547                                        isvar_by_ind.data(),
     
    542549                                        var_by_load_op.data()
    543550                                );
    544                                 if( p < q ) forward_load_op( 
     551                                if( p < q ) forward_load_op(
    545552                                        play,
    546553                                        op,
     
    555562                                );
    556563                        }
    557                         else    forward_load_op( 
     564                        else    forward_load_op(
    558565                                play,
    559566                                op,
     
    681688                        }
    682689                        while(i <= q)
    683                         {       taylor[ i_var * J + i] = Base(0); 
     690                        {       taylor[ i_var * J + i] = Base(0);
    684691                                i++;
    685692                        }
     
    740747                        if( p == 0 )
    741748                        {       forward_store_pp_op_0(
    742                                         i_var, 
    743                                         arg, 
    744                                         num_par, 
    745                                         J, 
     749                                        i_var,
     750                                        arg,
     751                                        num_par,
     752                                        J,
    746753                                        taylor,
    747754                                        isvar_by_ind.data(),
     
    755762                        if( p == 0 )
    756763                        {       forward_store_pv_op_0(
    757                                         i_var, 
    758                                         arg, 
    759                                         num_par, 
    760                                         J, 
     764                                        i_var,
     765                                        arg,
     766                                        num_par,
     767                                        J,
    761768                                        taylor,
    762769                                        isvar_by_ind.data(),
     
    770777                        if( p == 0 )
    771778                        {       forward_store_vp_op_0(
    772                                         i_var, 
    773                                         arg, 
    774                                         num_par, 
    775                                         J, 
     779                                        i_var,
     780                                        arg,
     781                                        num_par,
     782                                        J,
    776783                                        taylor,
    777784                                        isvar_by_ind.data(),
     
    785792                        if( p == 0 )
    786793                        {       forward_store_vv_op_0(
    787                                         i_var, 
    788                                         arg, 
    789                                         num_par, 
    790                                         J, 
     794                                        i_var,
     795                                        arg,
     796                                        num_par,
     797                                        J,
    791798                                        taylor,
    792799                                        isvar_by_ind.data(),
     
    840847# ifndef NDEBUG
    841848                                if( user_atom == CPPAD_NULL )
    842                                 {       std::string msg = 
     849                                {       std::string msg =
    843850                                                atomic_base<Base>::class_name(user_index)
    844851                                                + ": atomic_base function has been deleted";
     
    870877# ifndef NDEBUG
    871878                                if( ! user_ok )
    872                                 {       std::string msg = 
     879                                {       std::string msg =
    873880                                                atomic_base<Base>::class_name(user_index)
    874881                                                + ": atomic_base.forward: returned false";
     
    876883                                }
    877884# endif
    878                                 for(i = 0; i < user_m; i++) 
     885                                for(i = 0; i < user_m; i++)
    879886                                        if( user_iy[i] > 0 )
    880887                                                for(k = p; k <= q; k++)
    881                                                         taylor[ user_iy[i] * J + k ] = 
     888                                                        taylor[ user_iy[i] * J + k ] =
    882889                                                                user_ty[ i * user_q1 + k ];
    883890# if CPPAD_FORWARD1SWEEP_TRACE
     
    952959                        {       size_t i_tmp   = (i_op + i) - user_m;
    953960                                printOp(
    954                                         std::cout, 
     961                                        std::cout,
    955962                                        play,
    956963                                        i_tmp,
    957964                                        user_iy[i],
    958                                         UsrrvOp, 
     965                                        UsrrvOp,
    959966                                        CPPAD_NULL
    960967                                );
    961968                                Base* Z_tmp = taylor + user_iy[i] * J;
    962969                                printOpResult(
    963                                         std::cout, 
    964                                         q + 1, 
     970                                        std::cout,
     971                                        q + 1,
    965972                                        Z_tmp,
    966                                         0, 
     973                                        0,
    967974                                        (Base *) CPPAD_NULL
    968975                                );
     
    979986                {
    980987                        printOp(
    981                                 std::cout, 
     988                                std::cout,
    982989                                play,
    983990                                i_op,
    984991                                i_var,
    985                                 op, 
     992                                op,
    986993                                arg_tmp
    987994                        );
    988995                        if( NumRes(op) > 0 ) printOpResult(
    989                                 std::cout, 
    990                                 q + 1, 
    991                                 Z_tmp, 
    992                                 0, 
     996                                std::cout,
     997                                q + 1,
     998                                Z_tmp,
     999                                0,
    9931000                                (Base *) CPPAD_NULL
    9941001                        );
     
    10041011
    10051012        if( (p == 0) & (compare_change_count == 0) )
    1006                 compare_change_number = 0; 
     1013                compare_change_number = 0;
    10071014        return;
    10081015}
  • trunk/cppad/local/forward2sweep.hpp

    r3607 r3675  
    77
    88CppAD is distributed under multiple licenses. This distribution is under
    9 the terms of the 
     9the terms of the
    1010                    Eclipse Public License Version 1.0.
    1111
     
    3131        user_ok = user_atom->forward
    3232\endcode
    33 This macro is undefined at the end of this file to facillitate its 
     33This macro is undefined at the end of this file to facillitate its
    3434use with a different definition in other files.
    3535*/
     
    4242/*!
    4343\def CPPAD_FORWARD2SWEEP_TRACE
    44 This value is either zero or one. 
     44This value is either zero or one.
    4545Zero is the normal operational value.
    4646If it is one, a trace of every forward2sweep computation is printed.
     
    8585The exception to this is that while palying back the tape
    8686the object play holds information about the current location
    87 with in the tape and this changes during palyback. 
     87with in the tape and this changes during palyback.
    8888
    8989\param J
     
    9696For <code>i = 1 , ... , numvar-1</code>,
    9797<code>taylor[ (J-1)*r*i + i + 0 ]</code>
    98 is the zero order Taylor coefficient corresponding to 
     98is the zero order Taylor coefficient corresponding to
    9999the i-th variable and all directions.
    100100For <code>i = 1 , ... , numvar-1</code>,
     
    102102<code>ell = 0 , ... , r-1</code>,
    103103<code>taylor[ (J-1)*r*i + i + (k-1)*r + ell + 1 ]</code>
    104 is the k-th order Taylor coefficient corresponding to 
     104is the k-th order Taylor coefficient corresponding to
    105105the i-th variabel and ell-th direction.
    106106\n
    107107\n
    108108\b Input:
    109 For <code>i = 1 , ... , n</code>, 
     109For <code>i = 1 , ... , n</code>,
    110110<code>ell = 0 , ... , r-1</code>,
    111111<code>taylor[ (J-1)*r*i + i + (q-1)*r + ell + 1 ]</code>
    112 is the q-th order Taylor coefficient corresponding to 
     112is the q-th order Taylor coefficient corresponding to
    113113the i-th variable and ell-th direction
    114114(these are the independent varaibles).
    115115\n
    116116\n
    117 \b Output: 
    118 For <code>i = n+1 , ... , numvar-1</code>, 
     117\b Output:
     118For <code>i = n+1 , ... , numvar-1</code>,
    119119<code>ell = 0 , ... , r-1</code>,
    120120<code>taylor[ (J-1)*r*i + i + (q-1)*r + ell + 1 ]</code>
    121 is the q-th order Taylor coefficient corresponding to 
     121is the q-th order Taylor coefficient corresponding to
    122122the i-th variable and ell-th direction.
    123123
     
    163163        size_t i_op;
    164164
    165         // next variables 
     165        // next variables
    166166        size_t i_var;
    167167
     
    172172        vector<bool> user_vx;        // empty vecotor
    173173        vector<bool> user_vy;        // empty vecotor
    174         vector<Base> user_tx_one;    // argument vector Taylor coefficients 
     174        vector<Base> user_tx_one;    // argument vector Taylor coefficients
    175175        vector<Base> user_tx_all;
    176         vector<Base> user_ty_one;    // result vector Taylor coefficients 
     176        vector<Base> user_ty_one;    // result vector Taylor coefficients
    177177        vector<Base> user_ty_all;
    178178        size_t user_index = 0;       // indentifier for this atomic operation
     
    207207        const size_t user_q1 = q+1;
    208208
    209         // variable indices for results vector 
     209        // variable indices for results vector
    210210        // (done differently for order zero).
    211         vector<size_t> user_iy;     
     211        vector<size_t> user_iy;
    212212
    213213        // skip the BeginOp at the beginning of the recording
     
    223223                // this op
    224224                play->forward_next(op, arg, i_op, i_var);
    225                 CPPAD_ASSERT_UNKNOWN( (i_op > n)  | (op == InvOp) ); 
    226                 CPPAD_ASSERT_UNKNOWN( (i_op <= n) | (op != InvOp) ); 
     225                CPPAD_ASSERT_UNKNOWN( (i_op > n)  | (op == InvOp) );
     226                CPPAD_ASSERT_UNKNOWN( (i_op <= n) | (op != InvOp) );
    227227                CPPAD_ASSERT_UNKNOWN( i_op < play->num_op_rec() );
    228228                CPPAD_ASSERT_ARG_BEFORE_RESULT(op, arg, i_var);
     
    231231                while( cskip_op[i_op] )
    232232                {       if( op == CSumOp )
    233                         {       // CSumOp has a variable number of arguments 
     233                        {       // CSumOp has a variable number of arguments
    234234                                play->forward_csum(op, arg, i_op, i_var);
    235235                        }
     
    273273                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
    274274                        forward_asin_op_dir(q, r, i_var, arg[0], J, taylor);
     275                        break;
     276                        // -------------------------------------------------
     277
     278                        case AsinhOp:
     279                        // sqrt(1 + x * x), asin(x)
     280                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
     281                        forward_asinh_op_dir(q, r, i_var, arg[0], J, taylor);
    275282                        break;
    276283                        // -------------------------------------------------
     
    412419                        k = i_var*(J-1)*r + i_var + (q-1)*r + 1;
    413420                        for(ell = 0; ell < r; ell++)
    414                                 taylor[k + ell] = Base(0); 
     421                                taylor[k + ell] = Base(0);
    415422                        break;
    416423                        // -------------------------------------------------
     
    515522# ifndef NDEBUG
    516523                                if( user_atom == CPPAD_NULL )
    517                                 {       std::string msg = 
     524                                {       std::string msg =
    518525                                                atomic_base<Base>::class_name(user_index)
    519526                                                + ": atomic_base function has been deleted";
     
    574581# ifndef NDEBUG
    575582                                        if( ! user_ok )
    576                                         {       std::string msg = 
     583                                        {       std::string msg =
    577584                                                        atomic_base<Base>::class_name(user_index)
    578585                                                        + ": atomic_base.forward: returned false";
     
    580587                                        }
    581588# endif
    582                                         for(i = 0; i < user_m; i++) 
     589                                        for(i = 0; i < user_m; i++)
    583590                                        {       if( user_iy[i] > 0 )
    584                                                 {       size_t i_taylor = user_iy[i]*((J-1)*r+1); 
     591                                                {       size_t i_taylor = user_iy[i]*((J-1)*r+1);
    585592                                                        size_t q_taylor = i_taylor + (q-1)*r+1+ell;
    586593                                                        size_t q_one    = i * user_q1 + q;
     
    619626                        for(ell = 0; ell < r; ell++)
    620627                        {       for(k = 1; k < user_q1; k++)
    621                                 {       user_tx_all[user_j*(q*r+1) + (k-1)*r+1+ell] = 
     628                                {       user_tx_all[user_j*(q*r+1) + (k-1)*r+1+ell] =
    622629                                                taylor[arg[0]*((J-1)*r+1) + (k-1)*r+1+ell];
    623630                                }
     
    650657                        for(ell = 0; ell < r; ell++)
    651658                        {       for(k = 1; k < user_q1; k++)
    652                                 {       user_ty_all[user_i*(q*r+1) + (k-1)*r+1+ell] = 
     659                                {       user_ty_all[user_i*(q*r+1) + (k-1)*r+1+ell] =
    653660                                                taylor[i_var*((J-1)*r+1) + (k-1)*r+1+ell];
    654661                                }
     
    671678                        {       size_t i_tmp   = (i_op + i) - user_m;
    672679                                printOp(
    673                                         std::cout, 
     680                                        std::cout,
    674681                                        play,
    675682                                        i_tmp,
    676683                                        user_iy[i],
    677                                         UsrrvOp, 
     684                                        UsrrvOp,
    678685                                        CPPAD_NULL
    679686                                );
     
    685692                                                        Z_vec[p_tmp] = Z_tmp[(p_tmp-1)*r+ell+1];
    686693                                                printOpResult(
    687                                                         std::cout, 
    688                                                         q + 1, 
     694                                                        std::cout,
     695                                                        q + 1,
    689696                                                        Z_vec.data(),
    690                                                         0, 
     697                                                        0,
    691698                                                        (Base *) CPPAD_NULL
    692699                                                );
     
    703710                if( op != UsrrvOp )
    704711                {       printOp(
    705                                 std::cout, 
     712                                std::cout,
    706713                                play,
    707714                                i_op,
    708715                                i_var,
    709                                 op, 
     716                                op,
    710717                                arg_tmp
    711718                        );
     
    722729                                                Z_vec[p_tmp] = Z_tmp[ (p_tmp-1)*r + ell + 1];
    723730                                        printOpResult(
    724                                                 std::cout, 
    725                                                 q + 1, 
     731                                                std::cout,
     732                                                q + 1,
    726733                                                Z_vec.data(),
    727                                                 0, 
     734                                                0,
    728735                                                (Base *) CPPAD_NULL
    729736                                        );
  • trunk/cppad/local/hash_code.hpp

    r3638 r3675  
    77
    88CppAD is distributed under multiple licenses. This distribution is under
    9 the terms of the 
     9the terms of the
    1010                    Eclipse Public License Version 1.0.
    1111
     
    2222/*!
    2323\def CPPAD_HASH_TABLE_SIZE
    24 the codes retruned by hash_code are between zero and CPPAD_HASH_TABLE_SIZE 
    25 minus one. 
     24the codes retruned by hash_code are between zero and CPPAD_HASH_TABLE_SIZE
     25minus one.
    2626*/
    2727# define CPPAD_HASH_TABLE_SIZE 10000
     
    4444\par Checked Assertions
    4545\li \c std::numeric_limits<unsigned short>::max() >= CPPAD_HASH_TABLE_SIZE
    46 \li \c sizeof(value) is even 
     46\li \c sizeof(value) is even
    4747\li \c sizeof(unsigned short)  == 2
    4848*/
     
    5050template <class Value>
    5151unsigned short hash_code(const Value& value)
    52 {       CPPAD_ASSERT_UNKNOWN( 
     52{       CPPAD_ASSERT_UNKNOWN(
    5353                std::numeric_limits<unsigned short>::max()
    5454                >=
     
    8080
    8181\li unary operators:
    82 AbsOp, AcosOp, AsinOp, AtanOp, CosOp, CoshOp
     82AbsOp, AcosOp, AsinOp, AsinhOp, AtanOp, CosOp, CoshOp
    8383ExpOp, LogOp, SinOp, SinhOp, SqrtOp, TanOp, TanhOp
    8484
    8585\li binary operators where first argument is a parameter:
    86 AddpvOp, DivpvOp, MulpvOp, PowpvOp, SubpvOp, 
     86AddpvOp, DivpvOp, MulpvOp, PowpvOp, SubpvOp,
    8787
    8888\li binary operators where second argument is a parameter:
     
    114114\par Checked Assertions
    115115\c op must be one of the operators specified above. In addition,
    116 \li \c std::numeric_limits<unsigned short>::max() >= CPPAD_HASH_TABLE_SIZE 
    117 \li \c sizeof(size_t) is even 
    118 \li \c sizeof(Base) is even 
     116\li \c std::numeric_limits<unsigned short>::max() >= CPPAD_HASH_TABLE_SIZE
     117\li \c sizeof(size_t) is even
     118\li \c sizeof(Base) is even
    119119\li \c sizeof(unsigned short)  == 2
    120120\li \c size_t(op) < size_t(NumberOp) <= CPPAD_HASH_TABLE_SIZE
     
    124124template <class Base>
    125125unsigned short hash_code(
    126         OpCode        op      , 
    127         const addr_t* arg     , 
    128         size_t npar           , 
     126        OpCode        op      ,
     127        const addr_t* arg     ,
     128        size_t npar           ,
    129129        const Base* par       )
    130 {       CPPAD_ASSERT_UNKNOWN( 
     130{       CPPAD_ASSERT_UNKNOWN(
    131131                std::numeric_limits<unsigned short>::max()
    132132                >=
     
    215215                case AcosOp:
    216216                case AsinOp:
     217                case AsinhOp:
    217218                case AtanOp:
    218219                case CosOp:
  • trunk/cppad/local/math_other.hpp

    r2506 r3675  
    44
    55/* --------------------------------------------------------------------------
    6 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
     6CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
    77
    88CppAD is distributed under multiple licenses. This distribution is under
    9 the terms of the 
     9the terms of the
    1010                    Eclipse Public License Version 1.0.
    1111
     
    2727$childtable%
    2828        cppad/local/abs.hpp%
     29        cppad/local/asinh.hpp%
    2930        cppad/local/sign.hpp%
    3031        cppad/local/atan2.hpp%
     
    3839
    3940# include <cppad/local/abs.hpp>
     41# include <cppad/local/asinh.hpp>
    4042# include <cppad/local/sign.hpp>
    4143# include <cppad/local/atan2.hpp>
  • trunk/cppad/local/op.hpp

    r3495 r3675  
    44
    55/* --------------------------------------------------------------------------
    6 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
     6CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
    77
    88CppAD is distributed under multiple licenses. This distribution is under
    9 the terms of the 
     9the terms of the
    1010                    Eclipse Public License Version 1.0.
    1111
     
    2323# include <cppad/local/acos_op.hpp>
    2424# include <cppad/local/asin_op.hpp>
     25# include <cppad/local/asinh_op.hpp>
    2526# include <cppad/local/atan_op.hpp>
    2627# include <cppad/local/comp_op.hpp>
  • trunk/cppad/local/op_code.hpp

    r3638 r3675  
    77
    88CppAD is distributed under multiple licenses. This distribution is under
    9 the terms of the 
     9the terms of the
    1010                    Eclipse Public License Version 1.0.
    1111
     
    3939\verbatim
    4040    Ending  Left-Operand  Right-Operand
    41       pvOp     parameter       variable 
    42       vpOp      variable      parameter 
    43       vvOp      variable       variable 
     41      pvOp     parameter       variable
     42      vpOp      variable      parameter
     43      vvOp      variable       variable
    4444\endverbatim
    4545For example, AddpvOp represents the addition operator where the left
     
    5353        AddvvOp,  //      variable   + variable
    5454        AsinOp,   // asin(variable)
     55        AsinhOp,  // asinh(variable)
    5556        AtanOp,   // atan(variable)
    5657        BeginOp,  // used to mark the beginning of the tape
     
    6162        // arg[1] & 4 = is trueCase a variable
    6263        // arg[1] & 8 = is falseCase a variable
    63         // arg[2]     = index correspoding to left 
    64         // arg[3]     = index correspoding to right 
    65         // arg[4]     = index correspoding to trueCase 
    66         // arg[5]     = index correspoding to falseCase 
     64        // arg[2]     = index correspoding to left
     65        // arg[3]     = index correspoding to right
     66        // arg[4]     = index correspoding to trueCase
     67        // arg[5]     = index correspoding to falseCase
    6768        CosOp,    //  cos(variable)
    6869        CoshOp,   // cosh(variable)
     
    7172        // arg[1] & 1 = is left a variable
    7273        // arg[1] & 2 = is right a variable
    73         // arg[2]     = index correspoding to left 
    74         // arg[3]     = index correspoding to right 
     74        // arg[2]     = index correspoding to left
     75        // arg[3]     = index correspoding to right
    7576        // arg[4] = number of operations to skip if CExpOp comparision is true
    7677        // arg[5] = number of operations to skip if CExpOp comparision is false
     
    7879        // arg[6+arg[4]] -> arg[5+arg[4]+arg[5]] = skip operations if false
    7980        // arg[6+arg[4]+arg[5]] = arg[4] + arg[5]
    80         CSumOp,   // Cummulative summation 
     81        CSumOp,   // Cummulative summation
    8182        // arg[0] = number of addition variables in summation
    8283        // arg[1] = number of subtraction variables in summation
    8384        // arg[2] = index of parameter that initializes summation
    8485        // arg[3] -> arg[2+arg[0]] = index for positive variables
    85         // arg[3+arg[0]] -> arg[2+arg[0]+arg[1]] = index for minus variables 
     86        // arg[3+arg[0]] -> arg[2+arg[0]+arg[1]] = index for minus variables
    8687        // arg[3+arg[0]+arg[1]] = arg[0] + arg[1]
    8788        DisOp,    //  discrete::eval(index, variable)
     
    147148Number of arguments corresponding to the specified operator.
    148149
    149 \param op 
     150\param op
    150151Operator for which we are fetching the number of arugments.
    151152
     
    172173                2, // AddvvOp
    173174                1, // AsinOp
     175                1, // AsinhOp
    174176                1, // AtanOp
    175177                1, // BeginOp  offset first real argument to have index 1
     
    272274                1, // AddvvOp
    273275                2, // AsinOp
     276                2, // AsinhOp
    274277                2, // AtanOp
    275278                1, // BeginOp  offsets first variable to have index one (not zero)
     
    328331        };
    329332        // check ensuring conversion to size_t is as expected
    330         CPPAD_ASSERT_UNKNOWN( size_t(NumberOp) == 
     333        CPPAD_ASSERT_UNKNOWN( size_t(NumberOp) ==
    331334                sizeof(NumResTable) / sizeof(NumResTable[0]) - 1
    332335        );
     
    344347name of the specified operation.
    345348
    346 \param op 
     349\param op
    347350Operator for which we are fetching the name
    348351*/
     
    355358                "Addvv" ,
    356359                "Asin"  ,
     360                "Asinh"  ,
    357361                "Atan"  ,
    358362                "Begin" ,
     
    407411                "Usrav" ,
    408412                "Usrrp" ,
    409                 "Usrrv" 
     413                "Usrrv"
    410414        };
    411415        // check ensuring conversion to size_t is as expected
    412         CPPAD_ASSERT_UNKNOWN( 
    413                 size_t(NumberOp) == sizeof(OpNameTable)/sizeof(OpNameTable[0]) 
     416        CPPAD_ASSERT_UNKNOWN(
     417                size_t(NumberOp) == sizeof(OpNameTable)/sizeof(OpNameTable[0])
    414418        );
    415419        // this test ensures that all indices are within the table
     
    444448template <class Type>
    445449void printOpField(
    446         std::ostream      &os , 
     450        std::ostream      &os ,
    447451        const char *   leader ,
    448         const Type     &value , 
     452        const Type     &value ,
    449453        size_t          width )
    450454{
     
    470474
    471475        // count number of spaces at begining
    472         size_t nspace = 0; 
     476        size_t nspace = 0;
    473477        while(str[nspace] == ' ' && nspace < len)
    474478                nspace++;
     
    481485        i = width - len + nspace;
    482486        while(i--)
    483                 os << " "; 
     487                os << " ";
    484488}
    485489
     
    512516template <class Base>
    513517void printOp(
    514         std::ostream&          os     , 
     518        std::ostream&          os     ,
    515519        const player<Base>*    play   ,
    516         size_t                 i_op   , 
    517         size_t                 i_var  , 
     520        size_t                 i_op   ,
     521        size_t                 i_var  ,
    518522        OpCode                 op     ,
    519523        const addr_t*          ind    )
     
    523527                "cannot print trace of AD operations in parallel mode"
    524528        );
    525         static const char *CompareOpName[] = 
     529        static const char *CompareOpName[] =
    526530                { "Lt", "Le", "Eq", "Ge", "Gt", "Ne" };
    527531
     
    532536        else    printOpField(os,  "v=",      "",    5);
    533537        if( op == CExpOp || op == CSkipOp )
    534         {       printOpField(os, "", OpName(op), 5); 
     538        {       printOpField(os, "", OpName(op), 5);
    535539                printOpField(os, "", CompareOpName[ ind[0] ], 3);
    536540        }
    537         else    printOpField(os, "", OpName(op), 8); 
     541        else    printOpField(os, "", OpName(op), 8);
    538542
    539543        // print other fields
     
    546550                ind[1] & 1 = is left a variable
    547551                ind[1] & 2 = is right a variable
    548                 ind[2]     = index correspoding to left 
    549                 ind[3]     = index correspoding to right 
     552                ind[2]     = index correspoding to left
     553                ind[3]     = index correspoding to right
    550554                ind[4] = number of operations to skip if CExpOp comparision is true
    551555                ind[5] = number of operations to skip if CExpOp comparision is false
     
    589593                ind[2] = index of parameter that initializes summation
    590594                ind[3], ... , ind[2+ind[0]] = index for positive variables
    591                 ind[3+ind[0]], ..., ind[2+ind[0]+ind[1]] = negative variables 
     595                ind[3+ind[0]], ..., ind[2+ind[0]+ind[1]] = negative variables
    592596                ind[3+ind[0]+ind[1]] == ind[0] + ind[1]
    593597                */
     
    681685                case AcosOp:
    682686                case AsinOp:
     687                case AsinhOp:
    683688                case AtanOp:
    684689                case CosOp:
     
    751756                }
    752757                break;
    753        
     758
    754759
    755760                case CExpOp:
     
    809814template <class Value>
    810815void printOpResult(
    811         std::ostream          &os     , 
     816        std::ostream          &os     ,
    812817        size_t                 nfz    ,
    813818        const  Value          *fz     ,
     
    877882                case AcosOp:
    878883                case AsinOp:
     884                case AsinhOp:
    879885                case AtanOp:
    880886                case CosOp:
     
    899905                CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) <= result );
    900906                break;
    901                 // 
     907                //
    902908                case LevpOp:
    903909                case LtvpOp:
    904910                CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) <= result );
    905911                break;
    906                 // 
     912                //
    907913                case LevvOp:
    908914                case LtvvOp:
     
    963969                CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < result );
    964970                break;
    965                
     971
    966972                // 3 arguments, third variable, no result
    967973                case StpvOp:
  • trunk/cppad/local/optimize.hpp

    r3669 r3675  
    15471547                        case AcosOp:
    15481548                        case AsinOp:
     1549                        case AsinhOp:
    15491550                        case AtanOp:
    15501551                        case CosOp:
     
    23102311                        case AcosOp:
    23112312                        case AsinOp:
     2313                        case AsinhOp:
    23122314                        case AtanOp:
    23132315                        case CosOp:
  • trunk/cppad/local/rev_hes_sweep.hpp

    r3638 r3675  
    77
    88CppAD is distributed under multiple licenses. This distribution is under
    9 the terms of the 
     9the terms of the
    1010                    Eclipse Public License Version 1.0.
    1111
     
    2222/*!
    2323\def CPPAD_REV_HES_SWEEP_TRACE
    24 This value is either zero or one. 
     24This value is either zero or one.
    2525Zero is the normal operational value.
    2626If it is one, a trace of every rev_hes_sweep computation is printed.
     
    3131Given the forward Jacobian sparsity pattern for all the variables,
    3232and the reverse Jacobian sparsity pattern for the dependent variables,
    33 RevHesSweep computes the Hessian sparsity pattern for all the independent 
     33RevHesSweep computes the Hessian sparsity pattern for all the independent
    3434variables.
    3535
    3636\tparam Base
    3737base type for the operator; i.e., this operation sequence was recorded
    38 using AD< \a Base > and computations by this routine are done using type 
     38using AD< \a Base > and computations by this routine are done using type
    3939\a Base.
    4040
     
    4949is the total number of variables on the tape; i.e.,
    5050\a play->num_var_rec().
    51 This is also the number of rows in the entire sparsity pattern 
     51This is also the number of rows in the entire sparsity pattern
    5252\a rev_hes_sparse.
    5353
     
    6666
    6767\param for_jac_sparse
    68 For i = 0 , ... , \a numvar - 1, 
     68For i = 0 , ... , \a numvar - 1,
    6969(for all the variables on the tape),
    7070the forward Jacobian sparsity pattern for the variable with index i
     
    7373\param RevJac
    7474\b Input:
    75 For i = 0, ... , \a numvar - 1 
     75For i = 0, ... , \a numvar - 1
    7676the if the variable with index i on the tape is an dependent variable and
    7777included in the Hessian, \a RevJac[ i ] is equal to true,
    78 otherwise it is equal to false. 
     78otherwise it is equal to false.
    7979\n
    8080\n
     
    8787\n
    8888\n
    89 \b Input: For i = 0 , ... , \a numvar - 1 
     89\b Input: For i = 0 , ... , \a numvar - 1
    9090the reverse Hessian sparsity pattern for the variable with index i is empty.
    9191\n
    9292\n
    9393\b Output: For j = 1 , ... , \a n,
    94 the reverse Hessian sparsity pattern for the independent dependent variable 
     94the reverse Hessian sparsity pattern for the independent dependent variable
    9595with index (j-1) is given by the set with index j
    96 in \a rev_hes_sparse. 
     96in \a rev_hes_sparse.
    9797The values in the rest of \a rev_hes_sparse are not specified; i.e.,
    9898they are used for temporary work space.
     
    131131
    132132        // check number of sets match
    133         CPPAD_ASSERT_UNKNOWN( 
     133        CPPAD_ASSERT_UNKNOWN(
    134134                for_jac_sparse.n_set() == rev_hes_sparse.n_set()
    135135        );
    136136
    137137        // vecad_sparsity contains a sparsity pattern for each VecAD object.
    138         // vecad_ind maps a VecAD index (beginning of the VecAD object) 
     138        // vecad_ind maps a VecAD index (beginning of the VecAD object)
    139139        // to the index for the corresponding set in vecad_sparsity.
    140140        size_t num_vecad_ind   = play->num_vec_ind_rec();
     
    153153                        length   = play->GetVecInd(j);
    154154                        // set vecad_ind to proper index for this VecAD
    155                         vecad_ind[j] = i; 
     155                        vecad_ind[j] = i;
    156156                        // make all other values for this vector invalid
    157157                        for(k = 1; k <= length; k++)
     
    159159                        // start of next VecAD
    160160                        j       += length + 1;
    161                         // initialize this vector's reverse jacobian value 
     161                        // initialize this vector's reverse jacobian value
    162162                        vecad_jac[i] = false;
    163163                }
     
    263263                        // -------------------------------------------------
    264264
     265                        case AsinhOp:
     266                        // sqrt(1 + x * x), asinh(x)
     267                        CPPAD_ASSERT_NARG_NRES(op, 1, 2)
     268                        reverse_sparse_hessian_nonlinear_unary_op(
     269                        i_var, arg[0], RevJac, for_jac_sparse, rev_hes_sparse
     270                        );
     271                        break;
     272                        // -------------------------------------------------
     273
    265274                        case AtanOp:
    266275                        // 1 + x * x, atan(x)
     
    605614# ifndef NDEBUG
    606615                                if( user_atom == CPPAD_NULL )
    607                                 {       std::string msg = 
     616                                {       std::string msg =
    608617                                                atomic_base<Base>::class_name(user_index)
    609618                                                + ": atomic_base function has been deleted";
     
    685694                                );
    686695                                if( ! user_ok )
    687                                 {       std::string msg = 
     696                                {       std::string msg =
    688697                                                atomic_base<Base>::class_name(user_index)
    689698                                                + ": atomic_base.rev_sparse_hes: returned false";
     
    805814                }
    806815                printOp(
    807                         std::cout, 
     816                        std::cout,
    808817                        play,
    809818                        i_op,
    810819                        i_var,
    811                         op, 
     820                        op,
    812821                        arg
    813822                );
     
    815824                // yet allow for this
    816825                if( NumRes(op) > 0 && op != BeginOp ) printOpResult(
    817                         std::cout, 
    818                         1, 
    819                         &zf_value, 
    820                         1, 
     826                        std::cout,
     827                        1,
     828                        &zf_value,
     829                        1,
    821830                        &zh_value
    822831                );
  • trunk/cppad/local/rev_jac_sweep.hpp

    r3638 r3675  
    245245                        case AsinOp:
    246246                        // sqrt(1 - x * x), asin(x)
     247                        CPPAD_ASSERT_NARG_NRES(op, 1, 2);
     248                        reverse_sparse_jacobian_unary_op(
     249                                i_var, arg[0], var_sparsity
     250                        );
     251                        break;
     252                        // -------------------------------------------------
     253
     254                        case AsinhOp:
     255                        // sqrt(1 + x * x), asinh(x)
    247256                        CPPAD_ASSERT_NARG_NRES(op, 1, 2);
    248257                        reverse_sparse_jacobian_unary_op(
     
    653662                        if( user_bool )
    654663                        {       for(j = 0; j < user_q; j++)
    655                                         if( bool_s[ user_j * user_q + j ] )     
    656                                                 var_sparsity.add_element(arg[0], j);   
     664                                        if( bool_s[ user_j * user_q + j ] )
     665                                                var_sparsity.add_element(arg[0], j);
    657666                        }
    658667                        else
     
    660669                                set_end = set_s[user_j].end();
    661670                                while( set_itr != set_end )
    662                                         var_sparsity.add_element(arg[0], *set_itr++);   
     671                                        var_sparsity.add_element(arg[0], *set_itr++);
    663672                        }
    664673                        if( user_j == 0 )
  • trunk/cppad/local/reverse_sweep.hpp

    r3666 r3675  
    333333                        // --------------------------------------------------
    334334
     335                        case AsinhOp:
     336                        // sqrt(1 - x * x), asin(x)
     337                        CPPAD_ASSERT_UNKNOWN( i_var < numvar );
     338                        reverse_asinh_op(
     339                                d, i_var, arg[0], J, Taylor, K, Partial
     340                        );
     341                        break;
     342                        // --------------------------------------------------
     343
    335344                        case AtanOp:
    336345                        // 1 + x * x, atan(x)
  • trunk/cppad/local/std_math_ad.hpp

    r3495 r3675  
    44
    55/* --------------------------------------------------------------------------
    6 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
     6CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
    77
    88CppAD is distributed under multiple licenses. This distribution is under
    9 the terms of the 
     9the terms of the
    1010                    Eclipse Public License Version 1.0.
    1111
     
    5959
    6060$head Purpose$$
    61 Evaluates the one argument standard math function 
    62 $icode fun$$ where its argument is an 
     61Evaluates the one argument standard math function
     62$icode fun$$ where its argument is an
    6363$cref/AD of/glossary/AD of Base/$$ $icode Base$$ object.
    6464
     
    8282In all cases,
    8383The AD of $icode Base$$
    84 operation sequence used to calculate $icode y$$ is 
     84operation sequence used to calculate $icode y$$ is
    8585$cref/independent/glossary/Operation/Independent/$$
    8686of $icode x$$.
    8787
    88 $head fun$$ 
    89 A definition of $icode fun$$ is included 
     88$head fun$$
     89A definition of $icode fun$$ is included
    9090for each of the following functions:
    9191$code acos$$,
     
    107107$head Examples$$
    108108The following files
    109 contain examples and tests of these functions.   
     109contain examples and tests of these functions.
    110110Each test returns true if it succeeds and false otherwise.
    111111$children%
     
    144144$head Derivatives$$
    145145Each of these functions satisfy a standard math function differential equation.
    146 Calculating derivatives using this differential equation 
    147 is discussed for 
     146Calculating derivatives using this differential equation
     147is discussed for
    148148both $cref/forward/ForwardTheory/Standard Math Functions/$$
    149149and $cref/reverse/ReverseTheory/Standard Math Functions/$$ mode.
     
    215215\begin{array}{lcr}
    216216        \D{[ \sin (x) ]}{x} & = & \cos (x) \\
    217         \D{[ \cos (x) ]}{x} & = & - \sin (x) 
     217        \D{[ \cos (x) ]}{x} & = & - \sin (x)
    218218\end{array}
    219219\] $$
     
    263263The macro defines the function x.Name() where x has type AD<Base>.
    264264It then uses this funciton to define Name(x) where x has type
    265 AD<Base> or VecAD_reference<Base>. 
    266        
     265AD<Base> or VecAD_reference<Base>.
     266
    267267If x is a variable, the tape unary operator Op is used
    268268to record the operation and the result is identified as correspoding
    269 to this operation; i.e., Name(x).taddr_ idendifies the operation and 
     269to this operation; i.e., Name(x).taddr_ idendifies the operation and
    270270Name(x).tape_id_ identifies the tape.
    271271
    272 This macro is used to define AD<Base> versions of 
     272This macro is used to define AD<Base> versions of
    273273acos, asin, atan, cos, cosh, exp, fabs, log, sin, sinh, sqrt, tan, tanh.
    274274*/
     
    315315     CPPAD_STANDARD_MATH_UNARY_AD(tanh, TanhOp)
    316316
     317# if CPPAD_COMPILER_HAS_ASINH
     318     CPPAD_STANDARD_MATH_UNARY_AD(asinh, AsinhOp)
     319# endif
     320
    317321# if CPPAD_COMPILER_HAS_ERF
    318322        // Error function is a special case
     
    355359
    356360        \tparam Base
    357         is the base type (different from base for log) 
     361        is the base type (different from base for log)
    358362        for this AD type, see base_require.
    359363
     
    374378# undef CPPAD_STANDARD_MATH_UNARY_AD
    375379
    376 # endif 
     380# endif
  • trunk/cppad/local/undef.hpp

    r3656 r3675  
    2626# undef CPPAD_BOOL_BINARY         in user api
    2727# undef CPPAD_BOOL_UNARY          in user api
     28# undef CPPAD_COMPILER_HAS_ASINH  in user api
     29# undef CPPAD_COMPILER_HAS_ERF    in user api
    2830# undef CPPAD_DISCRETE_FUNCTION   in user api
    2931# undef CPPAD_EIGENVECTOR         in user api
    30 # undef CPPAD_COMPILER_HAS_ERF    in user api
    3132# undef CPPAD_INTERNAL_SPARSE_SET in user api
    3233# undef CPPAD_MAX_NUM_THREADS     in user api
  • trunk/example/CMakeLists.txt

    r3651 r3675  
    8686        ad_output.cpp
    8787        asin.cpp
     88        asinh.cpp
    8889        atan.cpp
    8990        atan2.cpp
  • trunk/example/asin.cpp

    r2506 r3675  
    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
     
    1212
    1313/*
    14 $begin Asin.cpp$$
     14$begin asin.cpp$$
    1515$spell
    1616        sin
     
    1919
    2020$section The AD asin Function: Example and Test$$
    21 
    22 $index asin, AD example$$
    23 $index example, AD asin$$
    24 $index test, AD asin$$
    2521
    2622$code
     
    3430# include <cppad/cppad.hpp>
    3531
    36 bool Asin(void)
     32bool asin(void)
    3733{       bool ok = true;
    3834
    3935        using CppAD::AD;
    4036        using CppAD::NearEqual;
     37
     38        // 10 times machine epsilon
     39        double eps = 10. * std::numeric_limits<double>::epsilon();
    4140
    4241        // domain space vector
     
    5251        AD<double> sin_of_x0 = CppAD::sin(x[0]);
    5352
    54         // range space vector 
     53        // range space vector
    5554        size_t m = 1;
    5655        CPPAD_TESTVECTOR(AD<double>) y(m);
     
    5857
    5958        // create f: x -> y and stop tape recording
    60         CppAD::ADFun<double> f(x, y); 
     59        CppAD::ADFun<double> f(x, y);
    6160
    62         // check value 
    63         ok &= NearEqual(y[0] , x0,  1e-10 , 1e-10);
     61        // check value
     62        ok &= NearEqual(y[0] , x0,  eps, eps);
    6463
    6564        // forward computation of first partial w.r.t. x[0]
     
    6867        dx[0] = 1.;
    6968        dy    = f.Forward(1, dx);
    70         ok   &= NearEqual(dy[0], 1., 1e-10, 1e-10);
     69        ok   &= NearEqual(dy[0], 1., eps, eps);
    7170
    7271        // reverse computation of derivative of y[0]
     
    7574        w[0]  = 1.;
    7675        dw    = f.Reverse(1, w);
    77         ok   &= NearEqual(dw[0], 1., 1e-10, 1e-10);
     76        ok   &= NearEqual(dw[0], 1., eps, eps);
    7877
    7978        // use a VecAD<Base>::reference object with asin
     
    8281        v[zero] = sin_of_x0;
    8382        AD<double> result = CppAD::asin(v[zero]);
    84         ok     &= NearEqual(result, x0, 1e-10, 1e-10);
     83        ok     &= NearEqual(result, x0, eps, eps);
    8584
    8685        return ok;
  • trunk/example/base_alloc.hpp

    r3495 r3675  
    33# define CPPAD_BASE_ALLOC_INCLUDED
    44/* --------------------------------------------------------------------------
    5 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
     5CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
    66
    77CppAD is distributed under multiple licenses. This distribution is under
     
    1515$begin base_alloc.hpp$$
    1616$spell
     17        asinh
    1718        Rel
    1819        Lt Le Eq Ge Gt
     
    4647
    4748$head Purpose$$
    48 Demonstrate use of $codei%AD<%Base%>%$$ 
     49Demonstrate use of $codei%AD<%Base%>%$$
    4950where memory is allocated for each element of the type $icode Base$$.
    50 In addition, this is a complete example where all the 
     51In addition, this is a complete example where all the
    5152$cref/required Base/base_require/$$ type
    5253operations are defined (as apposed to other examples where
     
    6263
    6364$head Computed Assignment Macro$$
    64 This macro is used for the 
    65 $code base_alloc$$ computed assignment operators; to be specific, 
     65This macro is used for the
     66$code base_alloc$$ computed assignment operators; to be specific,
    6667used with $icode op $$ equal to
    6768$code +=$$,
     
    7677
    7778$head Binary Operator Macro$$
    78 This macro is used for the 
    79 $code base_alloc$$ binary operators (as member functions); to be specific, 
     79This macro is used for the
     80$code base_alloc$$ binary operators (as member functions); to be specific,
    8081used with $icode op $$ equal to
    8182$code +$$,
     
    9596
    9697$head Boolean Operator Macro$$
    97 This macro can be used for the 
    98 $code base_alloc$$ binary operators that have a 
    99 $code bool$$ result; to be specific, 
     98This macro can be used for the
     99$code base_alloc$$ binary operators that have a
     100$code bool$$ result; to be specific,
    100101used with $icode op $$ equal to
    101102$code ==$$,
     
    115116
    116117$head Class Definition$$
    117 The following example class 
     118The following example class
    118119defines the necessary $cref base_member$$ functions.
    119120It is made more complicated by storing a pointer to a $code double$$
     
    127128        base_alloc(void)
    128129        {       size_t cap;
    129                 void* v  = CppAD::thread_alloc::get_memory(sizeof(double), cap); 
     130                void* v  = CppAD::thread_alloc::get_memory(sizeof(double), cap);
    130131                ptrdbl_  = static_cast<double*>(v);
    131132        }
    132133        base_alloc(double dbl)
    133134        {       size_t cap;
    134                 void *v  = CppAD::thread_alloc::get_memory(sizeof(double), cap); 
     135                void *v  = CppAD::thread_alloc::get_memory(sizeof(double), cap);
    135136                ptrdbl_  = static_cast<double*>(v);
    136137                *ptrdbl_ = dbl;
     
    138139        base_alloc(const base_alloc& x)
    139140        {       size_t cap;
    140                 void *v  = CppAD::thread_alloc::get_memory(sizeof(double), cap); 
     141                void *v  = CppAD::thread_alloc::get_memory(sizeof(double), cap);
    141142                ptrdbl_  = static_cast<double*>(v);
    142143                *ptrdbl_ = *x.ptrdbl_;
     
    165166        BASE_ALLOC_BOOL_OPERATOR(==)
    166167        BASE_ALLOC_BOOL_OPERATOR(!=)
    167         // The <= operator is not necessary for the base type requirements 
     168        // The <= operator is not necessary for the base type requirements
    168169        // (needed so we can use NearEqual with base_alloc arguments).
    169170        BASE_ALLOC_BOOL_OPERATOR(<=)
     
    176177$codep */
    177178namespace CppAD {
    178         inline base_alloc CondExpOp( 
     179        inline base_alloc CondExpOp(
    179180                enum CompareOp     cop          ,
    180181                const base_alloc&       left         ,
    181                 const base_alloc&       right        , 
    182                 const base_alloc&       exp_if_true  , 
     182                const base_alloc&       right        ,
     183                const base_alloc&       exp_if_true  ,
    183184                const base_alloc&       exp_if_false )
    184185        {       // not used
     
    272273        { return   std::fun(*x.ptrdbl_); }
    273274/* $$
    274 The following invocations of the macro above define the 
     275The following invocations of the macro above define the
    275276$cref/unary standard math/base_std_math/Unary Standard Math/$$ functions
    276277(except for $code abs$$):
    277 $codep */ 
     278$codep */
    278279namespace CppAD {
    279280        BASE_ALLOC_STD_MATH(acos)
     
    292293}
    293294/* $$
    294 The absolute value function is special because its $code std$$ name is 
     295The absolute value function is special because its $code std$$ name is
    295296$code fabs$$
    296297$codep */
     
    299300        {       return std::fabs(*x.ptrdbl_); }
    300301}
     302/* $$
     303
     304$head asinh$$
     305The following defines the $code CppAD::asinh$$ function that
     306is required th use $code AD<Base_alloc>$$:
     307$codep */
     308# if CPPAD_COMPILER_HAS_ASINH
     309        inline base_alloc asinh(const base_alloc& x)
     310        {       return std::asinh(*x.ptrdbl_); }
     311# endif
    301312/* $$
    302313
     
    325336}
    326337/* $$
    327  
     338
    328339$head pow $$
    329340The following defines a $code CppAD::pow$$ function that
     
    353364        };
    354365        // deprecated machine epsilon
    355         template <> 
     366        template <>
    356367        inline base_alloc epsilon<base_alloc>(void)
    357368        {       return numeric_limits<base_alloc>::epsilon(); }
  • trunk/example/example.cpp

    r3651 r3675  
    5656extern bool ad_input(void);
    5757extern bool ad_output(void);
    58 extern bool Asin(void);
     58extern bool asin(void);
     59extern bool asinh(void);
    5960extern bool Atan(void);
    6061extern bool Atan2(void);
     
    219220        ok &= Run( ad_input,          "ad_input"         );
    220221        ok &= Run( ad_output,         "ad_output"        );
    221         ok &= Run( Asin,              "Asin"             );
     222        ok &= Run( asin,              "asin"             );
     223        ok &= Run( asinh,             "asinh"            );
    222224        ok &= Run( Atan,              "Atan"             );
    223225        ok &= Run( Atan2,             "Atan2"            );
  • trunk/makefile.am

    r3552 r3675  
    11# $Id$
    22# -----------------------------------------------------------------------------
    3 # CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
     3# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
    44#
    55# CppAD is distributed under multiple licenses. This distribution is under
    6 # the terms of the 
     6# the terms of the
    77#                     Eclipse Public License Version 1.0.
    88#
     
    1313BUILT_SOURCES = $(top_srcdir)/cppad/configure.hpp
    1414$(top_srcdir)/cppad/configure.hpp: cppad/configure.hpp
    15         cp cppad/configure.hpp $(top_srcdir)/cppad/configure.hpp 
     15        cp cppad/configure.hpp $(top_srcdir)/cppad/configure.hpp
    1616#
    1717if CppAD_POSTFIX
     
    2525SPEED_ADOLC_TESTS   = speed/adolc
    2626else
    27 SPEED_ADOLC_TESTS   = 
     27SPEED_ADOLC_TESTS   =
    2828endif
    2929#
     
    3232SPEED_FADBAD_TESTS  = speed/fadbad
    3333else
    34 SPEED_FADBAD_TESTS  = 
     34SPEED_FADBAD_TESTS  =
    3535endif
    3636#
     
    3939SPEED_SACADO_TESTS  = speed/sacado
    4040else
    41 SPEED_SACADO_TESTS  = 
    42 endif
    43 #
    44 # Did user specify a value for IPOPT_DIR in configure command line 
     41SPEED_SACADO_TESTS  =
     42endif
     43#
     44# Did user specify a value for IPOPT_DIR in configure command line
    4545if CppAD_IPOPT
    4646IPOPT_TESTS = \
     
    5252IPOPT_DIRS = \
    5353        cppad_ipopt/src \
    54         $(IPOPT_TESTS) 
     54        $(IPOPT_TESTS)
    5555#
    5656IPOPT_HEADER = \
     
    139139        cppad/local/arithmetic.hpp \
    140140        cppad/local/asin_op.hpp \
     141        cppad/local/asinh.hpp \
     142        cppad/local/asinh_op.hpp \
    141143        cppad/local/atan2.hpp \
    142144        cppad/local/atan_op.hpp \
     
    296298        cppad/track_new_del.hpp \
    297299        cppad/vector.hpp
    298 # End nobase_myinclude_HEADERS (check_makefile.sh uses this comment) 
     300# End nobase_myinclude_HEADERS (check_makefile.sh uses this comment)
    299301# ---------------------------------------------------------------
    300302#
     
    312314        multi_thread \
    313315        multi_thread/test_multi \
    314         test_more 
     316        test_more
    315317#
    316318# note that bin/gpl_license.sh is deleted by dist-hook
     
    352354        multi_thread/openmp/CMakeLists.txt \
    353355        multi_thread/pthread/CMakeLists.txt \
    354         print_for/CMakeLists.txt 
     356        print_for/CMakeLists.txt
    355357
    356358test_directory_list = \
     
    365367        multi_thread/test_multi \
    366368        print_for \
    367         test_more 
     369        test_more
    368370
    369 test: all 
    370         rm -f test.log 
     371test: all
     372        rm -f test.log
    371373        touch test.log
    372374        echo "#! /bin/sh -e"                               >  test.sh
  • trunk/omh/theory/asin_forward.omh

    r3169 r3675  
    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 AsinForward$$
     15$begin asin_forward$$
    1616$spell
    1717        asin
     
    2424$index forward, asin theory$$
    2525
    26 $section Arcsine Function Forward Taylor Polynomial Theory$$
     26$section Arc Sine and Hyperbolic Sine Forward Taylor Polynomial Theory$$
    2727
    28 If $latex F(x)  = \arcsin(x) $$ it follows that
     28$head Derivatives$$
    2929$latex \[
    30         \sqrt{ 1 - x * x } * F^{(1)} (x) - 0 * F (u)  = 1
     30\begin{array}{rcl}
     31\R{arcsin}^{(1)} (x)  & = & 1 / \sqrt{ 1 - x * x }
     32\\
     33\R{arcsinh}^{(1)} (x) & = & 1 / \sqrt{ 1 + x * x }
     34\end{array}
     35\] $$
     36If $latex F(x)$$ is $latex \R{arcsin} (x) $$ or $latex \R{arcsinh} (x)$$
     37the corresponding derivative satisfies the equation
     38$latex \[
     39        \sqrt{ 1 \mp x * x } * F^{(1)} (x) - 0 * F (u)  = 1
    3140\] $$
    3241and in the
    3342$xref/
    34         ForwardTheory/ 
    35         Standard Math Functions/ 
     43        ForwardTheory/
     44        Standard Math Functions/
    3645        Differential Equation/
    3746        standard math function differential equation/
     
    3948/$$,
    4049$latex A(x) = 0$$,
    41 $latex B(x) = \sqrt{1 - x * x }$$,
     50$latex B(x) = \sqrt{1 \mp x * x }$$,
    4251and $latex D(x) = 1$$.
    43 We use $latex a$$, $latex b$$, $latex d$$ and $latex z$$ to denote the 
     52We use $latex a$$, $latex b$$, $latex d$$ and $latex z$$ to denote the
    4453Taylor coefficients for
    45 $latex A [ X (t) ] $$, 
    46 $latex B [ X (t) ]$$, 
     54$latex A [ X (t) ] $$,
     55$latex B [ X (t) ]$$,
    4756$latex D [ X (t) ] $$,
    4857and $latex F [ X(t) ] $$ respectively.
     
    5059
    5160$$
    52 We define $latex Q(x) = 1 - x * x$$
    53 and let $latex q$$ be the corresponding Taylor coefficients for 
     61We define $latex Q(x) = 1 \mp x * x$$
     62and let $latex q$$ be the corresponding Taylor coefficients for
    5463$latex Q[ X(t) ]$$.
    5564It follows that
    5665$latex \[
    5766q^{(j)} = \left\{ \begin{array}{ll}
    58         1 - x^{(0)} * x^{(0)}            & {\rm if} \; j = 0 \\
    59         - \sum_{k=0}^j x^{(k)} x^{(j-k)} & {\rm otherwise}
     67        1 \mp x^{(0)} * x^{(0)}            & {\rm if} \; j = 0 \\
     68        \mp \sum_{k=0}^j x^{(k)} x^{(j-k)} & {\rm otherwise}
    6069\end{array} \right.
    6170\] $$
    62 It follows that 
     71It follows that
    6372$latex B[ X(t) ] = \sqrt{ Q[ X(t) ] }$$ and
    6473from the equations for the
     
    7079\\
    7180b^{(j+1)} & = &
    72         \frac{1}{j+1} \frac{1}{ b^{(0)} } 
     81        \frac{1}{j+1} \frac{1}{ b^{(0)} }
    7382        \left(
    7483                \frac{j+1}{2} q^{(j+1) }
    75                 - \sum_{k=1}^j k b^{(k)} b^{(j+1-k)} 
     84                - \sum_{k=1}^j k b^{(k)} b^{(j+1-k)}
    7685        \right)
    7786\end{array}
     
    8897$latex \[
    8998\begin{array}{rcl}
    90 z^{(0)} & = & \arcsin ( x^{(0)} )
     99z^{(0)} & = & F ( x^{(0)} )
    91100\\
    92 e^{(j)} 
     101e^{(j)}
    93102& = & d^{(j)} + \sum_{k=0}^{j} a^{(j-k)} * z^{(k)}
    94103\\
     
    98107\end{array} \right.
    99108\\
    100 z^{(j+1)} & = & \frac{1}{j+1} \frac{1}{ b^{(0)} } 
     109z^{(j+1)} & = & \frac{1}{j+1} \frac{1}{ b^{(0)} }
    101110\left(
    102         \sum_{k=0}^j e^{(k)} (j+1-k) x^{(j+1-k)} 
    103         - \sum_{k=1}^j b^{(k)} (j+1-k) z^{(j+1-k)} 
     111        \sum_{k=0}^j e^{(k)} (j+1-k) x^{(j+1-k)}
     112        - \sum_{k=1}^j b^{(k)} (j+1-k) z^{(j+1-k)}
    104113\right)
    105114\\
    106 z^{(j+1)} & = & \frac{1}{j+1} \frac{1}{ b^{(0)} } 
     115z^{(j+1)} & = & \frac{1}{j+1} \frac{1}{ b^{(0)} }
    107116\left(
    108117        (j+1) x^{(j+1)}
    109         - \sum_{k=1}^j k z^{(k)}  b^{(j+1-k)} 
     118        - \sum_{k=1}^j k z^{(k)}  b^{(j+1-k)}
    110119\right)
    111120\end{array}
    112 \] $$ 
     121\] $$
    113122
    114123
    115 $end 
     124$end
  • trunk/omh/theory/asin_reverse.omh

    r3169 r3675  
    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 AsinReverse$$
     15$begin asin_reverse$$
    1616$spell
    1717        asin
     
    2424$index reverse, asin theory$$
    2525
    26 $section Arcsine Function Reverse Mode Theory$$
     26$section Arc Sine and Hyperbolic Sine Reverse Mode Theory$$
    2727
    2828
     
    3434%$$
    3535definition for the functions $latex H$$ and $latex G$$.
    36 In addition,
    37 
    38 we use $latex q$$ and $latex b$$
    39 for the $th p$$ order Taylor coefficient
    40 row vectors corresponding to functions
     36In addition, we use the forward mode notation in
     37$cref asin_forward$$ for
    4138$latex \[
    4239\begin{array}{rcl}
    43         Q(t) & = & 1 - X(t) * X(t) \\
     40        Q(t) & = & 1 \mp X(t) * X(t) \\
    4441        B(t) & = & \sqrt{ Q(t) }
    4542\end{array}
    46 \] $$
     43\] $$
     44We use $latex q$$ and $latex b$$
     45for the $th p$$ order Taylor coefficient
     46row vectors corresponding to these functions
    4747and replace $latex z^{(j)}$$ by
    4848$latex \[
    4949        ( z^{(j)} , b^{(j)} )
    50 \] $$ 
     50\] $$
    5151in the definition for $latex G$$ and $latex H$$.
    52 The forward mode formulas for the
    53 $cref/asin/AsinForward/$$
     52The zero order forward mode formulas for the
     53$cref/asin/asin_forward/$$
    5454function are
    5555$latex \[
    5656\begin{array}{rcl}
    57         q^{(0)}  & = & 1 - x^{(0)} x^{(0)} \\
    58         b^{(j)}  & = & \sqrt{ q^{(0)} }    \\
    59         z^{(j)}  & = & \arcsin ( x^{(0)} )
     57        q^{(0)}  & = & 1 \mp x^{(0)} x^{(0)} \\
     58        b^{(0)}  & = & \sqrt{ q^{(0)} }    \\
     59        z^{(0)}  & = & F( x^{(0)} )
    6060\end{array}
    6161\] $$
    62 
    63 for the case $latex j = 0$$, and for $latex j > 0$$,
    64 
     62where $latex F(x) = \R{arcsin} (x)$$ for $latex -$$
     63and $latex F(x) = \R{arcsinh} (x) $$ for $latex +$$.
     64For the orders $latex j$$ greater than zero we have
    6565$latex \[
    6666\begin{array}{rcl}
    67 q^{(j)} & = & 
    68         - \sum_{k=0}^j x^{(k)} x^{(j-k)}
     67q^{(j)} & = &
     68        \mp \sum_{k=0}^j x^{(k)} x^{(j-k)}
    6969\\
    7070b^{(j)} & = &
    71         \frac{1}{j} \frac{1}{ b^{(0)} } 
     71        \frac{1}{j} \frac{1}{ b^{(0)} }
    7272        \left(
    7373                \frac{j}{2} q^{(j)}
    74                 - \sum_{k=1}^{j-1} k b^{(k)} b^{(j-k)} 
     74                - \sum_{k=1}^{j-1} k b^{(k)} b^{(j-k)}
    7575        \right)
    7676\\
    77 z^{(j)} & = & \frac{1}{j} \frac{1}{ b^{(0)} } 
     77z^{(j)} & = & \frac{1}{j} \frac{1}{ b^{(0)} }
    7878\left(
    7979        j x^{(j)}
    80         - \sum_{k=1}^{j-1} k z^{(k)}  b^{(j-k)} 
     80        - \sum_{k=1}^{j-1} k z^{(k)}  b^{(j-k)}
    8181\right)
    8282\end{array}
    83 \] $$ 
     83\] $$
    8484
    8585If $latex j = 0$$, we have the relation
     
    8787$latex \[
    8888\begin{array}{rcl}
    89 \D{H}{ x^{(j)} } & = & 
    90 \D{G}{ x^{(0)} } 
     89\D{H}{ x^{(j)} } & = &
     90\D{G}{ x^{(0)} }
    9191+ \D{G}{ z^{(j)} } \D{ z^{(j)} }{ x^{(0)} }
    9292+ \D{G}{ b^{(j)} } \D{ b^{(j)} }{ q^{(0)} } \D{ q^{(0)} }{ x^{(0)} }
    9393\\
    9494& = &
    95 \D{G}{ x^{(j)} } 
     95\D{G}{ x^{(j)} }
    9696+ \D{G}{ z^{(j)} } \frac{1}{ b^{(0)} }
    97 - \D{G}{ b^{(j)} } \frac{ x^{(0)} }{ b^{(0)} }
     97\mp \D{G}{ b^{(j)} } \frac{ x^{(0)} }{ b^{(0)} }
    9898\end{array}
    99 \] $$ 
     99\] $$
    100100
    101101If $latex j > 0$$, then for $latex k = 1, \ldots , j-1$$
     
    103103$latex \[
    104104\begin{array}{rcl}
    105 \D{H}{ b^{(0)} } & = & 
    106 \D{G}{ b^{(0)} } 
     105\D{H}{ b^{(0)} } & = &
     106\D{G}{ b^{(0)} }
    107107+ \D{G}{ z^{(j)} } \D{ z^{(j)} }{ b^{(0)} }
    108108+ \D{G}{ b^{(j)} } \D{ b^{(j)} }{ b^{(0)} }
    109109\\
    110110& = &
    111 \D{G}{ b^{(0)} } 
    112 - \D{G}{ z^{(j)} } \frac{ z^{(j)} }{ b^{(0)} } 
     111\D{G}{ b^{(0)} }
     112- \D{G}{ z^{(j)} } \frac{ z^{(j)} }{ b^{(0)} }
    113113- \D{G}{ b^{(j)} } \frac{ b^{(j)} }{ b^{(0)} }
    114114\\
    115 \D{H}{ x^{(0)} } & = & 
    116 \D{G}{ x^{(0)} } 
     115\D{H}{ x^{(0)} } & = &
     116\D{G}{ x^{(0)} }
    117117+
    118118\D{G}{ b^{(j)} } \D{ b^{(j)} }{ q^{(j)} } \D{ q^{(j)} }{ x^{(0)} }
    119119\\
    120 & = & 
    121 \D{G}{ x^{(0)} } 
    122 - \D{G}{ b^{(j)} } \frac{ x^{(j)} }{ b^{(0)} }
     120& = &
     121\D{G}{ x^{(0)} }
     122\mp \D{G}{ b^{(j)} } \frac{ x^{(j)} }{ b^{(0)} }
    123123\\
    124 \D{H}{ x^{(j)} } & = & 
    125 \D{G}{ x^{(j)} } 
     124\D{H}{ x^{(j)} } & = &
     125\D{G}{ x^{(j)} }
    126126+ \D{G}{ z^{(j)} } \D{ z^{(j)} }{ x^{(j)} }
    127127+ \D{G}{ b^{(j)} } \D{ b^{(j)} }{ q^{(j)} } \D{ q^{(j)} }{ x^{(j)} }
    128128\\
    129 & = & 
    130 \D{G}{ x^{(j)} } 
    131 + \D{G}{ z^{(j)} } \frac{1}{ b^{(0)} } 
    132 - \D{G}{ b^{(j)} } \frac{ x^{(0)} }{ b^{(0)} }
     129& = &
     130\D{G}{ x^{(j)} }
     131+ \D{G}{ z^{(j)} } \frac{1}{ b^{(0)} }
     132\mp \D{G}{ b^{(j)} } \frac{ x^{(0)} }{ b^{(0)} }
    133133\\
    134 \D{H}{ b^{(j - k)} } & = & 
    135 \D{G}{ b^{(j - k)} } 
     134\D{H}{ b^{(j - k)} } & = &
     135\D{G}{ b^{(j - k)} }
    136136+ \D{G}{ z^{(j)} } \D{ z^{(j)} }{ b^{(j - k)} }
    137137+ \D{G}{ b^{(j)} } \D{ b^{(j)} }{ b^{(j - k)} }
    138138\\
    139139& = &
    140 \D{G}{ b^{(j - k)} } 
     140\D{G}{ b^{(j - k)} }
    141141- \D{G}{ z^{(j)} } \frac{k z^{(k)} }{j b^{(0)} }
    142142- \D{G}{ b^{(j)} } \frac{ b^{(k)} }{ b^{(0)} }
    143143\\
    144 \D{H}{ x^{(k)} } & = & 
    145 \D{G}{ x^{(k)} } 
     144\D{H}{ x^{(k)} } & = &
     145\D{G}{ x^{(k)} }
    146146+ \D{G}{ z^{(j)} } \D{ z^{(j)} }{ x^{(k)} }
    147147+ \D{G}{ b^{(j)} } \D{ b^{(j)} }{ q^{(j)} } \D{ q^{(j)} }{ x^{(k)} }
    148148\\
    149 & = & 
    150 \D{G}{ x^{(k)} } 
    151 - \D{G}{ b^{(j)} } \frac{ x^{(j-k)} }{ b^{(0)} }
     149& = &
     150\D{G}{ x^{(k)} }
     151\mp \D{G}{ b^{(j)} } \frac{ x^{(j-k)} }{ b^{(0)} }
    152152\\
    153 \D{H}{ z^{(k)} } & = & 
    154 \D{G}{ z^{(k)} } 
     153\D{H}{ z^{(k)} } & = &
     154\D{G}{ z^{(k)} }
    155155+ \D{G}{ z^{(j)} } \D{ z^{(j)} }{ z^{(k)} }
    156156+ \D{G}{ b^{(j)} } \D{ b^{(j)} }{ z^{(k)} }
    157157\\
    158158& = &
    159 \D{G}{ z^{(k)} } 
    160 - \D{G}{ z^{(j)} } \frac{k b^{(j-k)} }{ j b^{(0)} } 
     159\D{G}{ z^{(k)} }
     160- \D{G}{ z^{(j)} } \frac{k b^{(j-k)} }{ j b^{(0)} }
    161161\end{array}
    162 \] $$ 
     162\] $$
    163163
    164164$end
  • trunk/omh/theory/forward_theory.omh

    r3495 r3675  
    11$Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 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
     
    1919
    2020$head Taylor Notation$$
    21 In Taylor notation, each variable corresponds to 
     21In Taylor notation, each variable corresponds to
    2222a function of a single argument which we denote by $icode t$$
    23 (see Section 10.2 of 
     23(see Section 10.2 of
    2424$cref/Evaluating Derivatives/Bib/Evaluating Derivatives/$$).
    2525Here and below
    26 $latex X(t)$$, $latex Y(t)$$, and $icode Z(t)$$ are scalar valued functions 
     26$latex X(t)$$, $latex Y(t)$$, and $icode Z(t)$$ are scalar valued functions
    2727and the corresponding $th p$$ order Taylor coefficients row vectors are
    2828$latex x$$, $latex y$$ and $latex z$$; i.e.,
     
    3131X(t) & = & x^{(0)} + x^{(1)} * t + \cdots + x^{(p)} * t^p + o( t^p ) \\
    3232Y(t) & = & y^{(0)} + y^{(1)} * t + \cdots + y^{(p)} * t^p + o( t^p ) \\
    33 Z(t) & = & z^{(0)} + z^{(1)} * t + \cdots + z^{(p)} * t^p + o( t^p ) 
     33Z(t) & = & z^{(0)} + z^{(1)} * t + \cdots + z^{(p)} * t^p + o( t^p )
    3434\end{array}
    3535\] $$
     
    4242$latex \[
    4343\begin{array}{rcl}
    44 Z(t)   
    45 & = & X(t)   + Y(t) 
    46 \\
    47 \sum_{j=0}^p z^{(j)} * t^j   
     44Z(t)
     45& = & X(t)   + Y(t)
     46\\
     47\sum_{j=0}^p z^{(j)} * t^j
    4848& = & \sum_{j=0}^p x^{(j)} * t^j + \sum_{j=0}^p y^{(j)} * t^j  + o( t^p )
    4949\\
    5050z^{(j)} & = & x^{(j)} + y^{(j)}
    51 \end{array} 
     51\end{array}
    5252\] $$
    5353
     
    5555$latex \[
    5656\begin{array}{rcl}
    57 Z(t)   
    58 & = & X(t) - Y(t) 
    59 \\
    60 \sum_{j=0}^p z^{(j)} * t^j   
     57Z(t)
     58& = & X(t) - Y(t)
     59\\
     60\sum_{j=0}^p z^{(j)} * t^j
    6161& = & \sum_{j=0}^p x^{(j)} * t^j - \sum_{j=0}^p y^{(j)} * t^j  + o( t^p )
    6262\\
    6363z^{(j)} & = & x^{(j)} - y^{(j)}
    64 \end{array} 
     64\end{array}
    6565\] $$
    6666
     
    6868$latex \[
    6969\begin{array}{rcl}
    70 Z(t)   
    71 & = & X(t) * Y(t) 
    72 \\
    73 \sum_{j=0}^p z^{(j)} * t^j   
     70Z(t)
     71& = & X(t) * Y(t)
     72\\
     73\sum_{j=0}^p z^{(j)} * t^j
    7474& = & \left( \sum_{j=0}^p x^{(j)} * t^j \right)
    75 * 
     75*
    7676\left( \sum_{j=0}^p y^{(j)} * t^j \right) + o( t^p )
    7777\\
    7878z^{(j)} & = & \sum_{k=0}^j x^{(j-k)} * y^{(k)}
    79 \end{array} 
     79\end{array}
    8080\] $$
    8181
     
    8383$latex \[
    8484\begin{array}{rcl}
    85 Z(t)   
    86 & = & X(t) / Y(t) 
    87 \\
    88 x 
     85Z(t)
     86& = & X(t) / Y(t)
     87\\
     88x
    8989& = & z * y
    9090\\
    91 \sum_{j=0}^p x^{(j)} * t^j   
    92 & = & 
     91\sum_{j=0}^p x^{(j)} * t^j
     92& = &
    9393\left( \sum_{j=0}^p z^{(j)} * t^j \right)
    94 * 
    95 \left( \sum_{j=0}^p y^{(j)} * t^j \right) 
    96 + 
     94*
     95\left( \sum_{j=0}^p y^{(j)} * t^j \right)
     96+
    9797o( t^p )
    9898\\
     
    116116        B(u) * F^{(1)} (u) - A(u) * F (u)  = D(u)
    117117\] $$
    118 We use $latex a$$, $latex b$$ and $latex d$$ to denote the 
     118We use $latex a$$, $latex b$$ and $latex d$$ to denote the
    119119$th p$$ order Taylor coefficient row vectors for
    120120$latex A [ X (t) ] $$, $latex B [ X (t) ]$$ and $latex D [ X (t) ] $$
    121121respectively.
    122 We assume that these coefficients are known functions of $latex x$$, 
     122We assume that these coefficients are known functions of $latex x$$,
    123123the $th p$$ order Taylor coefficients for $latex X(t)$$.
    124124
    125125$subhead Taylor Coefficients Recursion Formula$$
    126 Our problem here is to express $latex z$$, 
     126Our problem here is to express $latex z$$,
    127127the $th p$$ order Taylor coefficient row vector for $latex Z(t)$$,
    128128in terms of these other known coefficients.
     
    130130$latex \[
    131131\begin{array}{rcl}
    132 Z^{(1)} (t) 
    133 & = & F^{(1)} [ X(t) ] * X^{(1)} (t) 
    134 \\
    135 B[ X(t) ] * Z^{(1)} (t) 
     132Z^{(1)} (t)
     133& = & F^{(1)} [ X(t) ] * X^{(1)} (t)
     134\\
     135B[ X(t) ] * Z^{(1)} (t)
    136136& = & \{ D[ X(t) ] + A[ X(t) ] * Z(t) \} * X^{(1)} (t)
    137137\\
     
    141141where we define
    142142$latex \[
    143 E(t) =  D[X(t)] + A[X(t)] * Z(t) 
    144 \] $$ 
     143E(t) =  D[X(t)] + A[X(t)] * Z(t)
     144\] $$
    145145
    146146We can compute the value of $latex z^{(0)}$$ using the formula
     
    148148        z^{(0)} = F ( x^{(0)} )
    149149\]$$
    150 Suppose by induction (on $latex j$$) that we are given the 
     150Suppose by induction (on $latex j$$) that we are given the
    151151Taylor coefficients of $latex E(t)$$ up to order $latex j-1$$; i.e.,
    152152$latex e^{(k)}$$ for $latex k = 0 , \ldots , j-1$$
    153 and the coefficients 
     153and the coefficients
    154154$latex z^{(k)}$$ for $latex k = 0 , \ldots , j$$.
    155 We can compute $latex e^{(j)}$$ using the formula 
     155We can compute $latex e^{(j)}$$ using the formula
    156156$latex \[
    157157        e^{(j)} = d^{(j)} + \sum_{k=0}^j a^{(j-k)} * z^{(k)}
    158158\] $$
    159 We need to complete the induction by finding formulas for $latex z^{(j+1)}$$. 
    160 It follows for the formula for the 
    161 $cref/multiplication/ForwardTheory/Binary Operators/Multiplication/$$ 
     159We need to complete the induction by finding formulas for $latex z^{(j+1)}$$.
     160It follows for the formula for the
     161$cref/multiplication/ForwardTheory/Binary Operators/Multiplication/$$
    162162operator that
    163163$latex  \[
     
    166166*
    167167\left( \sum_{k=1}^{j+1} k z^{(k)} * t^{k-1} \right)
    168 & = & 
    169 \left( \sum_{k=0}^j e^{(k)} * t^k \right) 
     168& = &
     169\left( \sum_{k=0}^j e^{(k)} * t^k \right)
    170170*
    171171\left( \sum_{k=1}^{j+1} k x^{(k)} * t^{k-1} \right)
     
    173173o( t^p )
    174174\\
    175 z^{(j+1)} & = & \frac{1}{j+1} \frac{1}{ b^{(0)} } 
     175z^{(j+1)} & = & \frac{1}{j+1} \frac{1}{ b^{(0)} }
    176176\left(
    177         \sum_{k=0}^j e^{(k)} (j+1-k) x^{(j+1-k)} 
    178         - \sum_{k=1}^j b^{(k)} (j+1-k) z^{(j+1-k)} 
     177        \sum_{k=0}^j e^{(k)} (j+1-k) x^{(j+1-k)}
     178        - \sum_{k=1}^j b^{(k)} (j+1-k) z^{(j+1-k)}
    179179\right)
    180180\\
    181 z^{(j+1)} & = & \frac{1}{j+1} \frac{1}{ b^{(0)} } 
     181z^{(j+1)} & = & \frac{1}{j+1} \frac{1}{ b^{(0)} }
    182182\left(
    183         \sum_{k=1}^{j+1} k x^{(k)} e^{(j+1-k)} 
    184         - \sum_{k=1}^j k z^{(k)}  b^{(j+1-k)} 
     183        \sum_{k=1}^{j+1} k x^{(k)} e^{(j+1-k)}
     184        - \sum_{k=1}^j k z^{(k)}  b^{(j+1-k)}
    185185\right)
    186186\end{array}
     
    211211$rref SinCosForward$$
    212212$rref AtanForward$$
    213 $rref AsinForward$$
     213$rref asin_forward$$
    214214$rref AcosForward$$
    215215$tend
  • trunk/omh/whats_new/whats_new_15.omh

    r3673 r3675  
    1414$dollar @$$
    1515$spell
     16        asinh
    1617        src
    1718        op
     
    4849The purpose of this section is to
    4950assist you in learning about changes between various versions of CppAD.
     51
     52$head 05-05$$
     53Add the inverse hyperbolic sine function $cref asinh$$.
     54If you are defining your own base type,
     55note that $cref/asinh/base_std_math/asinh/$$
     56was added to the base type requirements.
    5057
    5158$head 04-18$$
  • trunk/omh/wish_list.omh

    r3674 r3675  
    4848The following functions are part of the C++11 standard math library
    4949and could be added to CppAD:
    50 $code atanh$$, $code asinh$$, $code acosh$$, $code expm1$$, $code log1p$$
     50$code atanh$$, $code acosh$$, $code expm1$$, $code log1p$$
    5151
    5252$subhead atan2$$
  • trunk/test_more/CMakeLists.txt

    r3666 r3675  
    6969        adfun_copy.cpp
    7070        asin.cpp
     71        asinh.cpp
    7172        assign.cpp
    7273        add.cpp
  • trunk/test_more/asin.cpp

    r2506 r3675  
    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
     
    1717# include <cppad/cppad.hpp>
    1818
    19 bool Asin(void)
     19bool asin(void)
    2020{       bool ok = true;
    2121
     
    2929
    3030        // a temporary values
    31         AD<double> x = sin(U[0]); 
     31        AD<double> x = sin(U[0]);
    3232
    33         // dependent variable vector 
     33        // dependent variable vector
    3434        CPPAD_TESTVECTOR(AD<double>) Z(1);
    3535        Z[0] = asin(x); // asin( sin(u) )
    3636
    3737        // create f: U -> Z and vectors used for derivative calculations
    38         ADFun<double> f(U, Z); 
     38        ADFun<double> f(U, Z);
    3939        CPPAD_TESTVECTOR(double) v(1);
    4040        CPPAD_TESTVECTOR(double) w(1);
    4141
    42         // check value 
     42        // check value
    4343        ok &= NearEqual(U[0] , Z[0],  1e-10 , 1e-10);
    4444
     
    5151        for(j = 1; j < p; j++)
    5252        {       jfac *= j;
    53                 w     = f.Forward(j, v);       
     53                w     = f.Forward(j, v);
    5454                ok &= NearEqual(jfac*w[0], value, 1e-10 , 1e-10); // d^jz/du^j
    5555                v[0]  = 0.;
     
    5858
    5959        // reverse computation of partials of Taylor coefficients
    60         CPPAD_TESTVECTOR(double) r(p); 
     60        CPPAD_TESTVECTOR(double) r(p);
    6161        w[0]  = 1.;
    6262        r     = f.Reverse(p, w);
  • trunk/test_more/test_more.cpp

    r3666 r3675  
    2525extern bool AddZero(void);
    2626extern bool alloc_openmp(void);
    27 extern bool Asin(void);
     27extern bool asin(void);
     28extern bool asinh(void);
    2829extern bool assign(void);
    2930extern bool Atan(void);
     
    139140        ok &= Run( AddEq,           "AddEq"          );
    140141        ok &= Run( AddZero,         "AddZero"        );
    141         ok &= Run( Asin,            "Asin"           );
     142        ok &= Run( asin,            "asin"           );
     143        ok &= Run( asinh,           "asinh"          );
    142144        ok &= Run( assign,          "assign"         );
    143145        ok &= Run( Atan,            "Atan"           );
Note: See TracChangeset for help on using the changeset viewer.