Changeset 3666


Ignore:
Timestamp:
Feb 28, 2015 11:54:17 AM (5 years ago)
Author:
bradbell
Message:

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

commit 9d68051c35a88aaabc1532f00e74e38eb6befff0
Author: Brad Bell <bradbell@…>
Date: Sat Feb 28 09:34:47 2015 -0700

Squashed commit of merge from local cond_exp_rev branch to master.
This implemented the feature change (bug fix) in whats new on 2015-02-28.


commit 7c67a66cf3576c7b4d7917efd7b77a0351ba41b8
Author: Brad Bell <bradbell@…>
Date: Sat Feb 28 08:47:14 2015 -0700


Remove trailing white space.


commit 35ff6eed1be671077704f2e705001f6e9f11997f
Author: Brad Bell <bradbell@…>
Date: Sat Feb 28 08:45:09 2015 -0700


cond_exp.cpp: change example to match new reverse mode feature.
whats_new_15.omh: user description of change in reverse mode.
cond_exp.cpp: check test to match new reverse mode feature .


commit 4fac1b7e3bd5fd8d6a27812cdb1cef0c975d9a5b
Author: Brad Bell <bradbell@…>
Date: Sat Feb 28 07:35:04 2015 -0700


Stop nan from propagating through unused option in reverse erf operator.
reverse_sweep.hpp: some white space edits.
tanh_op.hpp: remove trailing white space.
cond_exp_rev.cpp: note difference between pow and erf.


commit fb1ace29478101e98e1cef4da5cfbf8b485de73b
Author: Brad Bell <bradbell@…>
Date: Sat Feb 28 07:22:17 2015 -0700


Stop nan from propagating through unused option in reverse tanh operator.
tanh_op.hpp: remove trailing white space.


commit d03663ac2cd5f7d1fc21d2fefa9b9b3a2790c171
Author: Brad Bell <bradbell@…>
Date: Sat Feb 28 07:20:01 2015 -0700


Stop nan from propagating through unused option in reverse tan operator.


commit 079c4f75f447c3cb223ff82893fc86a754d2f982
Author: Brad Bell <bradbell@…>
Date: Sat Feb 28 07:17:14 2015 -0700


sqrt_op.hpp: remove trailing white space.
cond_exp_rev.cpp: check that subtraction does not need action.


commit b2b55bf409173d07085b675cc2bda0808bf63210
Author: Brad Bell <bradbell@…>
Date: Sat Feb 28 07:13:04 2015 -0700


Stop nan from propagating through unused option in reverse sqrt operator.
sinh_op.hpp: remove trailing white space.


commit c83231ce59f0d77cfc2f058a8e9ba785a2216e09
Author: Brad Bell <bradbell@…>
Date: Sat Feb 28 07:09:18 2015 -0700


Stop nan from propagating through unused option in reverse sinh operator.
sinh_op.hpp: remove trailing white space.


commit 596f7ebe6e014bf0c19c6b3b517cf020a972a943
Author: Brad Bell <bradbell@…>
Date: Sat Feb 28 07:06:57 2015 -0700


Stop nan from propagating through unused option in reverse sin operator.


commit 9e161155b55c299c5f9ab1fdb06e332d4cdd6bc4
Author: Brad Bell <bradbell@…>
Date: Sat Feb 28 07:04:11 2015 -0700


cond_exp_rev.cpp: test some more operations that need no further action.


commit 394d552933c8033fda66f1e9977e558506cba90f
Author: Brad Bell <bradbell@…>
Date: Sat Feb 28 06:55:37 2015 -0700


Stop nan from propagating through unused option in reverse mulvv operator.
log_op.hpp: remove trailing white space.


commit 6ed9754950e49df4246c0937d763686e07f0a14c
Author: Brad Bell <bradbell@…>
Date: Sat Feb 28 06:48:08 2015 -0700


Stop nan from propagating through unused option in reverse log operator.


commit 43791ad41011aa56865135418f1620c6ea5a00c6
Author: Brad Bell <bradbell@…>
Date: Sat Feb 28 06:41:31 2015 -0700


exp_op.hpp: remove traling white space.
cond_exp_rev.cpp: check reverse divvp operator doesn't propagate nans.


commit f2ba8c592073c0318367440fe22f491945f7af8a
Author: Brad Bell <bradbell@…>
Date: Sat Feb 28 06:35:42 2015 -0700


Stop nan from propagating through unused option in reverse exp operator.


commit 5a0ee67c3869465bdd39cddbe26c966fc09f8113
Author: Brad Bell <bradbell@…>
Date: Sat Feb 28 06:30:25 2015 -0700


cond_exp_rev.cpp: white space edit and skip some cases for now.


commit 5cb70435dfb14e7f67728003395f68f6f6201798
Author: Brad Bell <bradbell@…>
Date: Sat Feb 28 06:15:32 2015 -0700


Stop nan from propagating through unused option in reverse divpv operator.


commit dcd072898764ffac2434950c77037475788ffe79
Author: Brad Bell <bradbell@…>
Date: Sat Feb 28 06:11:01 2015 -0700


Stop nan from propagating through unused option in reverse divvv operator.
cosh_op.hpp: remove trailing white space.


commit eb43bfc9e9f0fc3bb28c6f6d686473ac6d1114c7
Author: Brad Bell <bradbell@…>
Date: Sat Feb 28 06:07:06 2015 -0700


Stop nan from propagating through unused option in reverse cosh operator.
cos_op.hpp: remove trailing white space.


commit 21a1adb8b3acad7cccf470a62248aeb28de34be3
Author: Brad Bell <bradbell@…>
Date: Sat Feb 28 06:03:23 2015 -0700


Stop nan from propagating through unused option in reverse cos operator.
atan_op.hpp: remove trailing white space.


commit 8b7f2ddaaad129bdabdf2df213f3f3161d25d073
Author: Brad Bell <bradbell@…>
Date: Sat Feb 28 05:57:17 2015 -0700


Stop nan from propagating through unused option in reverse atan operator.
asin_op.hpp: remove trailing white space.


commit b23cc3a860f6a5818f544fc2b601ccad3900b709
Author: Brad Bell <bradbell@…>
Date: Sat Feb 28 05:52:53 2015 -0700


Stop nan from propagating through unused option in reverse asin operator.
acos_op.hpp: fix spelling in comment.


commit 07b5395ba34def704deb56bbc834dfba5e616014
Author: Brad Bell <bradbell@…>
Date: Sat Feb 28 05:49:15 2015 -0700


acos_op.hpp: remove traliing white space.
cond_exp_rev.cpp: check add operators.


commit 7391e9b74f8350d5a210a21cd0fe16577a16824a
Author: Brad Bell <bradbell@…>
Date: Sat Feb 28 05:42:50 2015 -0700


Stop nan from propagating through unused option in reverse acos operator.

commit 9619d407996da03fd287cd24fa9f8604bcd92ef5
Author: Brad Bell <bradbell@…>
Date: Fri Feb 27 22:14:32 2015 -0700

Remove trailing white space.

commit 70a04a4c19a02624f5defb7ec0ce213d58d6e0cd
Author: Brad Bell <bradbell@…>
Date: Fri Feb 27 22:13:33 2015 -0700

Add a test for reverse mode of conditional expressions.
This will test that nans and infinities do not propagate though the
conditional case that is not used.


reverse_sweep.hpp: Fix alphabetical order of operators.

commit 957bc6090d454642d72b7d47d591a6f9f6b74f82
Author: Brad Bell <bradbell@…>
Date: Fri Feb 27 06:34:49 2015 -0700

template.sh: remove trailing white space.

commit f3c75db95aa06ab0e0f48872ed3e6518e61f3dec
Author: Brad Bell <bradbell@…>
Date: Fri Feb 27 06:23:24 2015 -0700

Split cond_exp.sh into cond_exp_1.sh, cond_exp_2.sh because they have very
different causes.


template.sh: imporve message at end.

commit bee51f2cf231a714f7736b09f39bc5e366d04e2c
Author: Brad Bell <bradbell@…>
Date: Wed Feb 25 22:58:05 2015 -0700

cond_exp.sh: Better names for AD variables.

commit 82229bcfc244540a9bb5e679296c0b9e5846871e
Author: Brad Bell <bradbell@…>
Date: Wed Feb 25 22:02:18 2015 -0700

push_git2svn.py: remove trailing white space.

commit 69c85cf7842b344b046ed5325897b2748485358e
Author: Brad Bell <bradbell@…>
Date: Wed Feb 25 22:01:06 2015 -0700

push_git2svn.py: Handle trailing white space deleted and directory created.

Location:
trunk
Files:
3 added
1 deleted
25 edited

Legend:

Unmodified
Added
Removed
  • trunk/bin/push_git2svn.py

    r3607 r3666  
    55#
    66# CppAD is distributed under multiple licenses. This distribution is under
    7 # the terms of the 
     7# the terms of the
    88#                     Eclipse Public License Version 1.0.
    99#
     
    1717import re
    1818import subprocess
     19import pdb
    1920# -----------------------------------------------------------------------------
    2021# command line arguments
     
    7273                sys.exit(msg)
    7374        return output
     75
     76id_pattern    = re.compile(r'^.*\$Id.*$',      re.MULTILINE)
     77white_pattern = re.compile(r'[ \t]+$',         re.MULTILINE)
     78date_pattern  = re.compile(r'2003-[0-9][0-9]', re.MULTILINE)
     79def ignore_data(data) :
     80        data = re.sub(id_pattern,    '', data)
     81        data = re.sub(white_pattern, '', data)
     82        data = re.sub(date_pattern,  '', data)
     83        return data
    7484# -----------------------------------------------------------------------------
    7585# determine git_branch_name
     
    8595# -----------------------------------------------------------------------------
    8696# hash code for the git branch
    87 cmd = 'git show-ref origin/' + git_branch_name 
     97cmd = 'git show-ref origin/' + git_branch_name
    8898git_hash_code = system(cmd)
    8999pattern       = ' refs/remotes/origin/' + git_branch_name
     
    97107svn_directory = work_directory + '/svn'
    98108if os.path.isdir(svn_directory) :
    99         question    = 'Use existing svn directory:\n\t' 
     109        question    = 'Use existing svn directory:\n\t'
    100110        question   +=  svn_directory + '\n'
    101111        question   += 'or remove it and check out a new copy ? [use/new] '
     
    152162svn_pattern = re.compile(svn_directory + '/')
    153163svn_file_list = []
     164svn_dir_list  = []
    154165for directory, dir_list, file_list in os.walk(svn_directory) :
    155166        ok = ( directory.find('/.svn/') == -1 )
    156167        ok = ok and ( not directory.endswith('/.svn') )
    157168        if ok :
     169                if directory != svn_directory :
     170                        local_name = re.sub(svn_pattern, '', directory)
     171                        svn_dir_list.append(local_name)
    158172                for name in file_list :
    159173                        local_name = directory + '/' + name
     
    163177git_pattern = re.compile(git_directory + '/')
    164178git_file_list = []
     179git_dir_list  = []
    165180for directory, dir_list, file_list in os.walk(git_directory) :
    166181        index =  directory.find('/.svn/')
    167182        assert index == -1
     183        if directory != git_directory :
     184                local_name = re.sub(git_pattern, '', directory)
     185                git_dir_list.append(local_name)
    168186        for name in file_list :
    169187                local_name = directory + '/' + name
     
    172190# -----------------------------------------------------------------------------
    173191# list of files that have been created and deleted
    174 created_list=[]
     192created_file_list=[]
    175193for name in git_file_list :
    176194        if not name in svn_file_list :
    177                 created_list.append(name)
    178 #
    179 deleted_list=[]
     195                created_file_list.append(name)
     196#
     197deleted_file_list=[]
    180198for name in svn_file_list :
    181199        if not name in git_file_list :
    182                 deleted_list.append(name)
    183 
     200                deleted_file_list.append(name)
     201# -----------------------------------------------------------------------------
     202# list of directories that have been created and deleted
     203created_dir_list=[]
     204for name in git_dir_list :
     205        if not name in svn_dir_list :
     206                created_dir_list.append(name)
     207#
     208deleted_dir_list=[]
     209for name in svn_dir_list :
     210        if not name in git_dir_list :
     211                deleted_dir_list.append(name)
    184212# -----------------------------------------------------------------------------
    185213# automated svn commands
    186 id_pattern = re.compile(r'^.*\$Id.*$', re.MULTILINE)
    187 #
    188 for git_file in created_list :
     214#
     215for git_dir in created_dir_list :
     216        cmd  = 'svn mkdir ' + svn_directory + '/' + git_dir
     217        print_system(cmd)
     218#
     219for git_file in created_file_list :
    189220        git_f     = open(git_directory + '/' + git_file, 'rb')
    190221        git_data  = git_f.read()
    191222        git_f.close()
    192         git_data  = re.sub(id_pattern, '', git_data)
     223        git_data  = ignore_data(git_data)
    193224        #
    194225        found = False
    195         for svn_file in deleted_list :
     226        for svn_file in deleted_file_list :
    196227                svn_f    = open(svn_directory + '/' + svn_file, 'rb')
    197228                svn_data = svn_f.read()
    198229                svn_f.close()
    199                 svn_data = re.sub(id_pattern, '', svn_data)
     230                svn_data = ignore_data(svn_data)
    200231                #
    201232                if svn_data == git_data :
     
    204235                        cmd += svn_directory + '/' + git_file
    205236                        print_system(cmd)
     237                        cmd  = 'cp ' + git_directory + '/' + git_file + ' \\\n\t'
     238                        cmd += svn_directory + '/' + git_file
     239                        system(cmd)
    206240                        found = True
    207241        if not found :
    208242                        cmd  = 'cp ' + git_directory + '/' + git_file + ' \\\n\t'
    209                         cmd += svn_directory + '/' + git_file 
     243                        cmd += svn_directory + '/' + git_file
    210244                        system(cmd)
    211245                        cmd  = 'svn add ' + svn_directory + '/' + git_file
    212246                        print_system(cmd)
    213247#
    214 for svn_file in deleted_list :
     248for svn_file in deleted_file_list :
    215249        svn_file_path = svn_directory + '/' + svn_file
    216250        if os.path.isfile(svn_file_path) :
     
    220254for git_file in git_file_list :
    221255        do_cp = True
    222         do_cp = do_cp and git_file not in created_list
     256        do_cp = do_cp and git_file not in created_file_list
    223257        if git_file in svn_file_list :
    224258                git_f     = open(git_directory + '/' + git_file, 'rb')
    225259                git_data  = git_f.read()
    226260                git_f.close()
    227                 git_data  = re.sub(id_pattern, '', git_data)
     261                git_data  = ignore_data(git_data)
    228262                #
    229263                svn_f    = open(svn_directory + '/' + git_file, 'rb')
    230264                svn_data = svn_f.read()
    231265                svn_f.close()
    232                 svn_data = re.sub(id_pattern, '', svn_data)
     266                svn_data = ignore_data(svn_data)
    233267                #
    234268                do_cp = do_cp and git_data != svn_data
    235269        if do_cp :
    236270                cmd  = 'cp ' + git_directory + '/' + git_file + ' \\\n\t'
    237                 cmd += svn_directory + '/' + git_file 
     271                cmd += svn_directory + '/' + git_file
    238272                system(cmd)
     273#
     274for svn_dir in deleted_dir_list :
     275        cmd  = 'svn rm ' + svn_directory + '/' + svn_dir
     276        print_system(cmd)
    239277# -----------------------------------------------------------------------------
    240278data  = 'merge to branch: ' + svn_branch_path + '\n'
  • trunk/bug/template.sh

    r3615 r3666  
    22# $Id$
    33# -----------------------------------------------------------------------------
    4 # CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 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
    7 # the terms of the 
     7# the terms of the
    88#                     Eclipse Public License Version 1.0.
    99#
     
    1717# include <iostream>
    1818int main(void)
    19 {       // C++ source code 
     19{       // C++ source code
    2020        using std::cout;
    2121
    2222        cout << "1. copy template.sh to <name>.sh\n";
    23         cout << "2. Edit <name>.sh replacing description and C++ source code\n"; 
     23        cout << "2. Edit <name>.sh replacing description and C++ source code\n";
    2424        cout << "3. Run ./<name>.sh\n";
    2525        cout << "where <name> is a name that describes the bug\n";
    26        
     26
    2727        return 0;
    2828}
     
    4141#
    4242echo "./$name"
    43 if ./$name
     43if ! ./$name
    4444then
    45         echo "OK"
    46 else
    47         echo "Error"
     45        echo
     46        echo "$name.sh: Error"
     47        exit 1
    4848fi
     49echo
     50echo "$name.sh: OK"
     51exit 0
  • trunk/cppad/local/acos_op.hpp

    r3320 r3666  
    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
     
    4444        size_t i_z         ,
    4545        size_t i_x         ,
    46         size_t cap_order   , 
     46        size_t cap_order   ,
    4747        Base*  taylor      )
    48 {       
     48{
    4949        // check assumptions
    5050        CPPAD_ASSERT_UNKNOWN( NumArg(AcosOp) == 1 );
     
    108108        size_t i_z         ,
    109109        size_t i_x         ,
    110         size_t cap_order   , 
     110        size_t cap_order   ,
    111111        Base*  taylor      )
    112 {       
     112{
    113113        // check assumptions
    114114        CPPAD_ASSERT_UNKNOWN( NumArg(AcosOp) == 1 );
     
    128128        {       Base uq = - 2.0 * x[m + ell] * x[0];
    129129                for(k = 1; k < q; k++)
    130                         uq -= x[(k-1)*r+1+ell] * x[(q-k-1)*r+1+ell]; 
     130                        uq -= x[(k-1)*r+1+ell] * x[(q-k-1)*r+1+ell];
    131131                b[m+ell] = Base(0);
    132132                z[m+ell] = Base(0);
    133133                for(k = 1; k < q; k++)
    134                 {       b[m+ell] += Base(k) * b[(k-1)*r+1+ell] * b[(q-k-1)*r+1+ell]; 
    135                         z[m+ell] += Base(k) * z[(k-1)*r+1+ell] * b[(q-k-1)*r+1+ell]; 
     134                {       b[m+ell] += Base(k) * b[(k-1)*r+1+ell] * b[(q-k-1)*r+1+ell];
     135                        z[m+ell] += Base(k) * z[(k-1)*r+1+ell] * b[(q-k-1)*r+1+ell];
    136136                }
    137137                b[m+ell] =  ( uq / Base(2) - b[m+ell] / Base(q) ) / b[0];
     
    159159        size_t i_z         ,
    160160        size_t i_x         ,
    161         size_t cap_order   , 
     161        size_t cap_order   ,
    162162        Base*  taylor      )
    163163{
     
    196196        size_t      i_z          ,
    197197        size_t      i_x          ,
    198         size_t      cap_order    , 
     198        size_t      cap_order    ,
    199199        const Base* taylor       ,
    200200        size_t      nc_partial   ,
     
    218218        const Base* b  = z  - cap_order; // called y in documentation
    219219        Base* pb       = pz - nc_partial;
     220
     221        // If pz is zero, make sure this operation has no effect
     222        // (zero times infinity or nan would be non-zero).
     223        bool skip(true);
     224        Base bzero(0.0);
     225        for(size_t i_d = 0; i_d <= d; i_d++)
     226                skip &= pz[i_d] == bzero;
     227        if( skip )
     228                return;
    220229
    221230        // number of indices to access
     
    230239                pz[j] /= b[0];
    231240
    232                 // update partials w.r.t b^0 
    233                 pb[0] -= pz[j] * z[j] + pb[j] * b[j]; 
     241                // update partials w.r.t b^0
     242                pb[0] -= pz[j] * z[j] + pb[j] * b[j];
    234243
    235244                // update partial w.r.t. x^0
     
    246255                        pb[j-k] -= Base(k) * pz[j] * z[k] + pb[j] * b[k];
    247256
    248                         // update partials w.r.t. x^k 
     257                        // update partials w.r.t. x^k
    249258                        px[k]   -= pb[j] * x[j-k];
    250259
  • trunk/cppad/local/asin_op.hpp

    r3320 r3666  
    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
     
    4444        size_t i_z         ,
    4545        size_t i_x         ,
    46         size_t cap_order   , 
     46        size_t cap_order   ,
    4747        Base*  taylor      )
    48 {       
     48{
    4949        // check assumptions
    5050        CPPAD_ASSERT_UNKNOWN( NumArg(AsinOp) == 1 );
     
    108108        size_t i_z         ,
    109109        size_t i_x         ,
    110         size_t cap_order   , 
     110        size_t cap_order   ,
    111111        Base*  taylor      )
    112 {       
     112{
    113113        // check assumptions
    114114        CPPAD_ASSERT_UNKNOWN( NumArg(AcosOp) == 1 );
     
    128128        {       Base uq = - 2.0 * x[m + ell] * x[0];
    129129                for(k = 1; k < q; k++)
    130                         uq -= x[(k-1)*r+1+ell] * x[(q-k-1)*r+1+ell]; 
     130                        uq -= x[(k-1)*r+1+ell] * x[(q-k-1)*r+1+ell];
    131131                b[m+ell] = Base(0);
    132132                z[m+ell] = Base(0);
    133133                for(k = 1; k < q; k++)
    134                 {       b[m+ell] += Base(k) * b[(k-1)*r+1+ell] * b[(q-k-1)*r+1+ell]; 
    135                         z[m+ell] += Base(k) * z[(k-1)*r+1+ell] * b[(q-k-1)*r+1+ell]; 
     134                {       b[m+ell] += Base(k) * b[(k-1)*r+1+ell] * b[(q-k-1)*r+1+ell];
     135                        z[m+ell] += Base(k) * z[(k-1)*r+1+ell] * b[(q-k-1)*r+1+ell];
    136136                }
    137137                b[m+ell] = ( uq / Base(2) - b[m+ell] / Base(q) ) / b[0];
     
    159159        size_t i_z         ,
    160160        size_t i_x         ,
    161         size_t cap_order   , 
     161        size_t cap_order   ,
    162162        Base*  taylor      )
    163163{
     
    196196        size_t      i_z          ,
    197197        size_t      i_x          ,
    198         size_t      cap_order    , 
     198        size_t      cap_order    ,
    199199        const Base* taylor       ,
    200200        size_t      nc_partial   ,
     
    218218        const Base* b  = z  - cap_order; // called y in documentation
    219219        Base* pb       = pz - nc_partial;
     220
     221        // If pz is zero, make sure this operation has no effect
     222        // (zero times infinity or nan would be non-zero).
     223        bool skip(true);
     224        Base bzero(0.0);
     225        for(size_t i_d = 0; i_d <= d; i_d++)
     226                skip &= pz[i_d] == bzero;
     227        if( skip )
     228                return;
    220229
    221230        // number of indices to access
     
    230239                pz[j] /= b[0];
    231240
    232                 // update partials w.r.t b^0 
    233                 pb[0] -= pz[j] * z[j] + pb[j] * b[j]; 
     241                // update partials w.r.t b^0
     242                pb[0] -= pz[j] * z[j] + pb[j] * b[j];
    234243
    235244                // update partial w.r.t. x^0
     
    246255                        pb[j-k] -= Base(k) * pz[j] * z[k] + pb[j] * b[k];
    247256
    248                         // update partials w.r.t. x^k 
     257                        // update partials w.r.t. x^k
    249258                        px[k]   -= pb[j] * x[j-k];
    250259
  • trunk/cppad/local/atan_op.hpp

    r3320 r3666  
    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
     
    4444        size_t i_z         ,
    4545        size_t i_x         ,
    46         size_t cap_order   , 
     46        size_t cap_order   ,
    4747        Base*  taylor      )
    48 {       
     48{
    4949        // check assumptions
    5050        CPPAD_ASSERT_UNKNOWN( NumArg(AtanOp) == 1 );
     
    100100        size_t i_z         ,
    101101        size_t i_x         ,
    102         size_t cap_order   , 
     102        size_t cap_order   ,
    103103        Base*  taylor      )
    104 {       
     104{
    105105        // check assumptions
    106106        CPPAD_ASSERT_UNKNOWN( NumArg(AtanOp) == 1 );
     
    146146        size_t i_z         ,
    147147        size_t i_x         ,
    148         size_t cap_order   , 
     148        size_t cap_order   ,
    149149        Base*  taylor      )
    150150{
     
    183183        size_t      i_z          ,
    184184        size_t      i_x          ,
    185         size_t      cap_order    , 
     185        size_t      cap_order    ,
    186186        const Base* taylor       ,
    187187        size_t      nc_partial   ,
     
    205205        const Base* b  = z  - cap_order; // called y in documentation
    206206        Base* pb       = pz - nc_partial;
     207
     208        // If pz is zero, make sure this operation has no effect
     209        // (zero times infinity or nan would be non-zero).
     210        bool skip(true);
     211        Base bzero(0.0);
     212        for(size_t i_d = 0; i_d <= d; i_d++)
     213                skip &= pz[i_d] == bzero;
     214        if( skip )
     215                return;
    207216
    208217        // number of indices to access
     
    214223                pb[j] *= Base(2);
    215224
    216                 pb[0] -= pz[j] * z[j]; 
     225                pb[0] -= pz[j] * z[j];
    217226                px[j] += pz[j] + pb[j] * x[0];
    218227                px[0] += pb[j] * x[j];
  • trunk/cppad/local/cos_op.hpp

    r3320 r3666  
    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
     
    4343        size_t i_z         ,
    4444        size_t i_x         ,
    45         size_t cap_order   , 
     45        size_t cap_order   ,
    4646        Base*  taylor      )
    47 {       
     47{
    4848        // check assumptions
    4949        CPPAD_ASSERT_UNKNOWN( NumArg(CosOp) == 1 );
     
    101101        size_t i_z         ,
    102102        size_t i_x         ,
    103         size_t cap_order   , 
     103        size_t cap_order   ,
    104104        Base*  taylor      )
    105 {       
     105{
    106106        // check assumptions
    107107        CPPAD_ASSERT_UNKNOWN( NumArg(CosOp) == 1 );
     
    152152        size_t i_z         ,
    153153        size_t i_x         ,
    154         size_t cap_order   , 
     154        size_t cap_order   ,
    155155        Base*  taylor      )
    156156{
     
    189189        size_t      i_z          ,
    190190        size_t      i_x          ,
    191         size_t      cap_order    , 
     191        size_t      cap_order    ,
    192192        const Base* taylor       ,
    193193        size_t      nc_partial   ,
     
    212212        Base* ps       = pc - nc_partial;
    213213
     214        // If pc is zero, make sure this operation has no effect
     215        // (zero times infinity or nan would be non-zero).
     216        bool skip(true);
     217        Base bzero(0.0);
     218        for(size_t i_d = 0; i_d <= d; i_d++)
     219                skip &= pc[i_d] == bzero;
     220        if( skip )
     221                return;
    214222
    215223        // rest of this routine is identical for the following cases:
     
    225233                        px[k]   += ps[j] * Base(k) * c[j-k];
    226234                        px[k]   -= pc[j] * Base(k) * s[j-k];
    227        
     235
    228236                        ps[j-k] -= pc[j] * Base(k) * x[k];
    229237                        pc[j-k] += ps[j] * Base(k) * x[k];
  • trunk/cppad/local/cosh_op.hpp

    r3320 r3666  
    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
     
    4444        size_t i_z         ,
    4545        size_t i_x         ,
    46         size_t cap_order   , 
     46        size_t cap_order   ,
    4747        Base*  taylor      )
    48 {       
     48{
    4949        // check assumptions
    5050        CPPAD_ASSERT_UNKNOWN( NumArg(CoshOp) == 1 );
     
    101101        size_t i_z         ,
    102102        size_t i_x         ,
    103         size_t cap_order   , 
     103        size_t cap_order   ,
    104104        Base*  taylor      )
    105 {       
     105{
    106106        // check assumptions
    107107        CPPAD_ASSERT_UNKNOWN( NumArg(CoshOp) == 1 );
     
    152152        size_t i_z         ,
    153153        size_t i_x         ,
    154         size_t cap_order   , 
     154        size_t cap_order   ,
    155155        Base*  taylor      )
    156156{
     
    189189        size_t      i_z          ,
    190190        size_t      i_x          ,
    191         size_t      cap_order    , 
     191        size_t      cap_order    ,
    192192        const Base* taylor       ,
    193193        size_t      nc_partial   ,
     
    211211        const Base* s  = c  - cap_order; // called y in documentation
    212212        Base* ps       = pc - nc_partial;
     213
     214        // If pc is zero, make sure this operation has no effect
     215        // (zero times infinity or nan would be non-zero).
     216        bool skip(true);
     217        Base bzero(0.0);
     218        for(size_t i_d = 0; i_d <= d; i_d++)
     219                skip &= pc[i_d] == bzero;
     220        if( skip )
     221                return;
    213222
    214223        // rest of this routine is identical for the following cases:
     
    224233                        px[k]   += ps[j] * Base(k) * c[j-k];
    225234                        px[k]   += pc[j] * Base(k) * s[j-k];
    226        
     235
    227236                        ps[j-k] += pc[j] * Base(k) * x[k];
    228237                        pc[j-k] += ps[j] * Base(k) * x[k];
  • trunk/cppad/local/div_op.hpp

    r3321 r3666  
    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
     
    3737template <class Base>
    3838inline void forward_divvv_op(
    39         size_t        p           , 
    40         size_t        q           , 
     39        size_t        p           ,
     40        size_t        q           ,
    4141        size_t        i_z         ,
    4242        const addr_t* arg         ,
     
    8383template <class Base>
    8484inline void forward_divvv_op_dir(
    85         size_t        q           , 
    86         size_t        r           , 
     85        size_t        q           ,
     86        size_t        r           ,
    8787        size_t        i_z         ,
    8888        const addr_t* arg         ,
     
    109109        for(size_t ell = 0; ell < r; ell++)
    110110        {       z[m+ell] = x[m+ell] - z[0] * y[m+ell];
    111                 for(size_t k = 1; k < q; k++)           
     111                for(size_t k = 1; k < q; k++)
    112112                        z[m+ell] -= z[(q-k-1)*r+1+ell] * y[(k-1)*r+1+ell];
    113113                z[m+ell] /= y[0];
     
    166166template <class Base>
    167167inline void reverse_divvv_op(
    168         size_t        d           , 
     168        size_t        d           ,
    169169        size_t        i_z         ,
    170170        const addr_t* arg         ,
     
    189189        Base* py = partial + arg[1] * nc_partial;
    190190        Base* pz = partial + i_z    * nc_partial;
     191
     192        // If pz is zero, make sure this operation has no effect
     193        // (zero times infinity or nan would be non-zero).
     194        bool skip(true);
     195        Base bzero(0.0);
     196        for(size_t i_d = 0; i_d <= d; i_d++)
     197                skip &= pz[i_d] == bzero;
     198        if( skip )
     199                return;
    191200
    192201        // Using CondExp, it can make sense to divide by zero
     
    205214                {       pz[j-k] -= pz[j] * y[k];
    206215                        py[k]   -= pz[j] * z[j-k];
    207                 }       
     216                }
    208217                py[0] -= pz[j] * z[j];
    209218        }
     
    226235template <class Base>
    227236inline void forward_divpv_op(
    228         size_t        p           , 
    229         size_t        q           , 
     237        size_t        p           ,
     238        size_t        q           ,
    230239        size_t        i_z         ,
    231240        const addr_t* arg         ,
     
    276285template <class Base>
    277286inline void forward_divpv_op_dir(
    278         size_t        q           , 
    279         size_t        r           , 
     287        size_t        q           ,
     288        size_t        r           ,
    280289        size_t        i_z         ,
    281290        const addr_t* arg         ,
     
    356365template <class Base>
    357366inline void reverse_divpv_op(
    358         size_t        d           , 
     367        size_t        d           ,
    359368        size_t        i_z         ,
    360369        const addr_t* arg         ,
     
    378387        Base* py = partial + arg[1] * nc_partial;
    379388        Base* pz = partial + i_z    * nc_partial;
     389
     390        // If pz is zero, make sure this operation has no effect
     391        // (zero times infinity or nan would be non-zero).
     392        bool skip(true);
     393        Base bzero(0.0);
     394        for(size_t i_d = 0; i_d <= d; i_d++)
     395                skip &= pz[i_d] == bzero;
     396        if( skip )
     397                return;
    380398
    381399        // Using CondExp, it can make sense to divide by zero so do not
     
    393411                {       pz[j-k] -= pz[j] * y[k];
    394412                        py[k]   -= pz[j] * z[j-k];
    395                 }       
     413                }
    396414                py[0] -= pz[j] * z[j];
    397415        }
     
    415433template <class Base>
    416434inline void forward_divvp_op(
    417         size_t        p           , 
    418         size_t        q           , 
     435        size_t        p           ,
     436        size_t        q           ,
    419437        size_t        i_z         ,
    420438        const addr_t* arg         ,
     
    436454        Base y = parameter[ arg[1] ];
    437455
    438         // Using CondExp and multiple levels of AD, it can make sense 
     456        // Using CondExp and multiple levels of AD, it can make sense
    439457        // to divide by zero so do not make it an error.
    440458        for(size_t d = p; d <= q; d++)
     
    456474template <class Base>
    457475inline void forward_divvp_op_dir(
    458         size_t        q           , 
    459         size_t        r           , 
     476        size_t        q           ,
     477        size_t        r           ,
    460478        size_t        i_z         ,
    461479        const addr_t* arg         ,
     
    478496        Base y = parameter[ arg[1] ];
    479497
    480         // Using CondExp and multiple levels of AD, it can make sense 
     498        // Using CondExp and multiple levels of AD, it can make sense
    481499        // to divide by zero so do not make it an error.
    482500        size_t m = (q-1)*r + 1;
     
    536554template <class Base>
    537555inline void reverse_divvp_op(
    538         size_t        d           , 
     556        size_t        d           ,
    539557        size_t        i_z         ,
    540558        const addr_t* arg         ,
  • trunk/cppad/local/erf_op.hpp

    r3646 r3666  
    361361        addr_t addr[2];
    362362
     363        // If pz is zero, make sure this operation has no effect
     364        // (zero times infinity or nan would be non-zero).
     365        Base* pz  = partial + i_z * nc_partial;
     366        bool skip(true);
     367        Base bzero(0.0);
     368        for(size_t i_d = 0; i_d <= d; i_d++)
     369                skip &= pz[i_d] == bzero;
     370        if( skip )
     371                return;
     372
    363373        // convert from final result to first result
    364374        i_z -= 4; // 4 = NumRes(ErfOp) - 1;
  • trunk/cppad/local/exp_op.hpp

    r3320 r3666  
    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
     
    3838        size_t i_z         ,
    3939        size_t i_x         ,
    40         size_t cap_order   , 
     40        size_t cap_order   ,
    4141        Base*  taylor      )
    42 {       
     42{
    4343        // check assumptions
    4444        CPPAD_ASSERT_UNKNOWN( NumArg(ExpOp) == 1 );
     
    8282        size_t i_z         ,
    8383        size_t i_x         ,
    84         size_t cap_order   , 
     84        size_t cap_order   ,
    8585        Base*  taylor      )
    86 {       
     86{
    8787        // check assumptions
    8888        CPPAD_ASSERT_UNKNOWN( NumArg(ExpOp) == 1 );
     
    9494        size_t num_taylor_per_var = (cap_order-1) * r + 1;
    9595        Base* x = taylor + i_x * num_taylor_per_var;
    96         Base* z = taylor + i_z * num_taylor_per_var; 
     96        Base* z = taylor + i_z * num_taylor_per_var;
    9797
    9898        size_t m = (q-1)*r + 1;
     
    119119        size_t i_z         ,
    120120        size_t i_x         ,
    121         size_t cap_order   , 
     121        size_t cap_order   ,
    122122        Base*  taylor      )
    123123{
     
    149149        size_t      i_z          ,
    150150        size_t      i_x          ,
    151         size_t      cap_order    , 
     151        size_t      cap_order    ,
    152152        const Base* taylor       ,
    153153        size_t      nc_partial   ,
     
    168168        Base* pz       = partial + i_z * nc_partial;
    169169
     170        // If pz is zero, make sure this operation has no effect
     171        // (zero times infinity or nan would be non-zero).
     172        bool skip(true);
     173        Base bzero(0.0);
     174        for(size_t i_d = 0; i_d <= d; i_d++)
     175                skip &= pz[i_d] == bzero;
     176        if( skip )
     177                return;
     178
    170179        // loop through orders in reverse
    171180        size_t j, k;
     
    176185
    177186                for(k = 1; k <= j; k++)
    178                 {       px[k]   += pz[j] * Base(k) * z[j-k];   
     187                {       px[k]   += pz[j] * Base(k) * z[j-k];
    179188                        pz[j-k] += pz[j] * Base(k) * x[k];
    180189                }
  • trunk/cppad/local/log_op.hpp

    r3320 r3666  
    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
     
    3636        size_t i_z         ,
    3737        size_t i_x         ,
    38         size_t cap_order   , 
     38        size_t cap_order   ,
    3939        Base*  taylor      )
    40 {       
     40{
    4141        size_t k;
    4242
     
    8888        size_t i_z         ,
    8989        size_t i_x         ,
    90         size_t cap_order   , 
     90        size_t cap_order   ,
    9191        Base*  taylor      )
    92 {       
     92{
    9393
    9494        // check assumptions
     
    109109                        z[m+ell] -= Base(k) * z[(k-1)*r+1+ell] * x[(q-k-1)*r+1+ell];
    110110                z[m+ell] /= (Base(q) * x[0]);
    111         }       
     111        }
    112112}
    113113
     
    126126        size_t i_z         ,
    127127        size_t i_x         ,
    128         size_t cap_order   , 
     128        size_t cap_order   ,
    129129        Base*  taylor      )
    130130{
     
    158158        size_t      i_z          ,
    159159        size_t      i_x          ,
    160         size_t      cap_order    , 
     160        size_t      cap_order    ,
    161161        const Base* taylor       ,
    162162        size_t      nc_partial   ,
    163163        Base*       partial      )
    164 {       size_t j, k;   
     164{       size_t j, k;
    165165
    166166        // check assumptions
     
    177177        const Base* z  = taylor  + i_z * cap_order;
    178178        Base* pz       = partial + i_z * nc_partial;
     179
     180        // If pz is zero, make sure this operation has no effect
     181        // (zero times infinity or nan would be non-zero).
     182        bool skip(true);
     183        Base bzero(0.0);
     184        for(size_t i_d = 0; i_d <= d; i_d++)
     185                skip &= pz[i_d] == bzero;
     186        if( skip )
     187                return;
    179188
    180189        j = d;
  • trunk/cppad/local/mul_op.hpp

    r3646 r3666  
    182182        Base* pz = partial + i_z    * nc_partial;
    183183
     184        // If pz is zero, make sure this operation has no effect
     185        // (zero times infinity or nan would be non-zero).
     186        bool skip(true);
     187        Base bzero(0.0);
     188        for(size_t i_d = 0; i_d <= d; i_d++)
     189                skip &= pz[i_d] == bzero;
     190        if( skip )
     191                return;
    184192
    185193        // number of indices to access
  • trunk/cppad/local/reverse_sweep.hpp

    r3607 r3666  
    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
     
    3232        user_ok = user_atom->reverse
    3333\endcode
    34 This maco is undefined at the end of this file to facillitate is 
     34This maco is undefined at the end of this file to facillitate is
    3535use with a different definition in other files.
    3636*/
     
    4343/*!
    4444\def CPPAD_REVERSE_SWEEP_TRACE
    45 This value is either zero or one. 
     45This value is either zero or one.
    4646Zero is the normal operational value.
    4747If it is one, a trace of every reverse_sweep computation is printed.
     
    5454\tparam Base
    5555base type for the operator; i.e., this operation sequence was recorded
    56 using AD< \a Base > and computations by this routine are done using type 
     56using AD< \a Base > and computations by this routine are done using type
    5757\a Base.
    5858
    5959\param d
    60 is the highest order Taylor coefficients that 
     60is the highest order Taylor coefficients that
    6161we are computing the derivative of.
    6262
     
    8282        f.Forward(k, x_k)
    8383</code>
    84 We define 
     84We define
    8585\f$ X : {\bf R}^{n \times d} \rightarrow {\bf R}^n \f$ by
    8686\f[
    8787        X(t, u) =  u^{(0)} + u^{(1)} t + \cdots + u^{(d)} t^d
    8888\f]
    89 We define 
     89We define
    9090\f$ Y : {\bf R}^{n \times d} \rightarrow {\bf R}^m \f$ by
    9191\f[
    9292        Y(t, u) =  F[ X(t, u) ]
    9393\f]
    94 We define the function 
     94We define the function
    9595\f$ W : {\bf R}^{n \times d} \rightarrow {\bf R} \f$ by
    9696\f[
    97 W(u) 
    98 = 
    99 \sum_{k=0}^{d} ( w^{(k)} )^{\rm T} 
     97W(u)
     98=
     99\sum_{k=0}^{d} ( w^{(k)} )^{\rm T}
    100100        \frac{1}{k !} \frac{\partial^k}{\partial t^k} Y(0, u)
    101101\f]
    102102(The matrix \f$ w \in {\bf R}^m \f$,
    103103is defined below under the heading Partial.)
    104 Note that the scale factor  1 / k  converts 
     104Note that the scale factor  1 / k  converts
    105105the k-th partial derivative to the k-th order Taylor coefficient.
    106106This routine computes the derivative of \f$ W(u) \f$
     
    113113while palying back the tape
    114114the object \a play holds information about the current location
    115 with in the tape and this changes during palyback. 
     115with in the tape and this changes during palyback.
    116116
    117117\param J
     
    122122For i = 1 , ... , \a numvar, and for k = 0 , ... , \a d,
    123123\a Taylor [ i * J + k ]
    124 is the k-th order Taylor coefficient corresponding to 
     124is the k-th order Taylor coefficient corresponding to
    125125variable with index i on the tape.
    126126The value \f$ u \in {\bf R}^{n \times d} \f$,
     
    138138The last \f$ m \f$ rows of \a Partial are inputs.
    139139The matrix \f$ w \f$, used to define \f$ W(u) \f$,
    140 is specified by these rows. 
    141 For i = 0 , ... , m - 1, 
     140is specified by these rows.
     141For i = 0 , ... , m - 1,
    142142for k = 0 , ... , d,
    143143<code>Partial [ (numvar - m + i ) * K + k ] = w[i,k]</code>.
     
    145145\n
    146146\b Temporary:
    147 For i = n+1 , ... , \a numvar - 1 and for k = 0 , ... , d, 
     147For i = n+1 , ... , \a numvar - 1 and for k = 0 , ... , d,
    148148the value of \a Partial [ i * K + k ] is used for temporary work space
    149 and its output value is not defined. 
     149and its output value is not defined.
    150150\n
    151151\n
    152152\b Output:
    153 For j = 1 , ... , n and for k = 0 , ... , d, 
    154 \a Partial [ j * K + k ] 
    155 is the partial derivative of \f$ W( u ) \f$ with 
     153For j = 1 , ... , n and for k = 0 , ... , d,
     154\a Partial [ j * K + k ]
     155is the partial derivative of \f$ W( u ) \f$ with
    156156respect to \f$ u_j^{(k)} \f$.
    157157
     
    170170\par Assumptions
    171171The first operator on the tape is a BeginOp,
    172 and the next \a n operators are InvOp operations for the 
     172and the next \a n operators are InvOp operations for the
    173173corresponding independent variables.
    174174*/
     
    274274                const Base*  pZ_tmp = Partial + i_var * K;
    275275                printOp(
    276                         std::cout, 
     276                        std::cout,
    277277                        play,
    278278                        i_op,
    279279                        i_tmp,
    280                         op, 
     280                        op,
    281281                        arg
    282282                );
    283283                if( NumRes(op) > 0 && op != BeginOp ) printOpResult(
    284                         std::cout, 
    285                         d + 1, 
    286                         Z_tmp, 
    287                         d + 1, 
    288                         pZ_tmp 
     284                        std::cout,
     285                        d + 1,
     286                        Z_tmp,
     287                        d + 1,
     288                        pZ_tmp
    289289                );
    290290                std::cout << std::endl;
     
    295295                        case AbsOp:
    296296                        reverse_abs_op(
     297                                d, i_var, arg[0], J, Taylor, K, Partial
     298                        );
     299                        break;
     300                        // --------------------------------------------------
     301
     302                        case AcosOp:
     303                        // sqrt(1 - x * x), acos(x)
     304                        CPPAD_ASSERT_UNKNOWN( i_var < numvar );
     305                        reverse_acos_op(
    297306                                d, i_var, arg[0], J, Taylor, K, Partial
    298307                        );
     
    315324                        // --------------------------------------------------
    316325
    317                         case AcosOp:
    318                         // sqrt(1 - x * x), acos(x)
    319                         CPPAD_ASSERT_UNKNOWN( i_var < numvar );
    320                         reverse_acos_op(
    321                                 d, i_var, arg[0], J, Taylor, K, Partial
    322                         );
    323                         break;
    324                         // --------------------------------------------------
    325 
    326326                        case AsinOp:
    327                         // sqrt(1 - x * x), asin(x)
     327                        // sqrt(1 - x * x), asin(x)
    328328                        CPPAD_ASSERT_UNKNOWN( i_var < numvar );
    329329                        reverse_asin_op(
     
    334334
    335335                        case AtanOp:
    336                         // 1 + x * x, atan(x)
     336                        // 1 + x * x, atan(x)
    337337                        CPPAD_ASSERT_UNKNOWN( i_var < numvar );
    338338                        reverse_atan_op(
     
    374374                        case CExpOp:
    375375                        reverse_cond_op(
    376                                 d, 
    377                                 i_var, 
    378                                 arg, 
    379                                 num_par, 
    380                                 parameter, 
    381                                 J, 
     376                                d,
     377                                i_var,
     378                                arg,
     379                                num_par,
     380                                parameter,
     381                                J,
    382382                                Taylor,
    383                                 K, 
     383                                K,
    384384                                Partial
    385385                        );
     
    405405                        case DisOp:
    406406                        // Derivative of discrete operation is zero so no
    407                         // contribution passes through this operation. 
     407                        // contribution passes through this operation.
    408408                        break;
    409409                        // --------------------------------------------------
     
    454454                        case LdpOp:
    455455                        reverse_load_op(
    456                 op, d, i_var, arg, J, Taylor, K, Partial, var_by_load_op.data()
     456                        op, d, i_var, arg, J, Taylor, K, Partial, var_by_load_op.data()
    457457                        );
    458458                        break;
     
    461461                        case LdvOp:
    462462                        reverse_load_op(
    463                 op, d, i_var, arg, J, Taylor, K, Partial, var_by_load_op.data()
     463                        op, d, i_var, arg, J, Taylor, K, Partial, var_by_load_op.data()
    464464                        );
    465465                        break;
     
    631631# ifndef NDEBUG
    632632                                if( user_atom == CPPAD_NULL )
    633                                 {       std::string msg = 
     633                                {       std::string msg =
    634634                                                atomic_base<Base>::class_name(user_index)
    635635                                                + ": atomic_base function has been deleted";
     
    665665# ifndef NDEBUG
    666666                                if( ! user_ok )
    667                                 {       std::string msg = 
     667                                {       std::string msg =
    668668                                                atomic_base<Base>::class_name(user_index)
    669669                                                + ": atomic_base.reverse: returned false";
     
    691691                        for(ell = 1; ell < user_k1; ell++)
    692692                                user_tx[user_j * user_k1 + ell] = Base(0.);
    693                        
     693
    694694                        if( user_j == 0 )
    695695                                user_state = user_start;
  • trunk/cppad/local/sin_op.hpp

    r3320 r3666  
    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
     
    4444        size_t i_z         ,
    4545        size_t i_x         ,
    46         size_t cap_order   , 
     46        size_t cap_order   ,
    4747        Base*  taylor      )
    48 {       
     48{
    4949        // check assumptions
    5050        CPPAD_ASSERT_UNKNOWN( NumArg(SinOp) == 1 );
     
    101101        size_t i_z         ,
    102102        size_t i_x         ,
    103         size_t cap_order   , 
     103        size_t cap_order   ,
    104104        Base*  taylor      )
    105 {       
     105{
    106106        // check assumptions
    107107        CPPAD_ASSERT_UNKNOWN( NumArg(SinOp) == 1 );
     
    153153        size_t i_z         ,
    154154        size_t i_x         ,
    155         size_t cap_order   , 
     155        size_t cap_order   ,
    156156        Base*  taylor      )
    157157{
     
    191191        size_t      i_z          ,
    192192        size_t      i_x          ,
    193         size_t      cap_order    , 
     193        size_t      cap_order    ,
    194194        const Base* taylor       ,
    195195        size_t      nc_partial   ,
     
    213213        const Base* c  = s  - cap_order; // called y in documentation
    214214        Base* pc       = ps - nc_partial;
     215
     216        // If ps is zero, make sure this operation has no effect
     217        // (zero times infinity or nan would be non-zero).
     218        bool skip(true);
     219        Base bzero(0.0);
     220        for(size_t i_d = 0; i_d <= d; i_d++)
     221                skip &= ps[i_d] == bzero;
     222        if( skip )
     223                return;
    215224
    216225        // rest of this routine is identical for the following cases:
     
    226235                        px[k]   += ps[j] * Base(k) * c[j-k];
    227236                        px[k]   -= pc[j] * Base(k) * s[j-k];
    228        
     237
    229238                        ps[j-k] -= pc[j] * Base(k) * x[k];
    230239                        pc[j-k] += ps[j] * Base(k) * x[k];
  • trunk/cppad/local/sinh_op.hpp

    r3320 r3666  
    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
     
    4444        size_t i_z         ,
    4545        size_t i_x         ,
    46         size_t cap_order   , 
     46        size_t cap_order   ,
    4747        Base*  taylor      )
    48 {       
     48{
    4949        // check assumptions
    5050        CPPAD_ASSERT_UNKNOWN( NumArg(SinhOp) == 1 );
     
    102102        size_t i_z         ,
    103103        size_t i_x         ,
    104         size_t cap_order   , 
     104        size_t cap_order   ,
    105105        Base*  taylor      )
    106 {       
     106{
    107107        // check assumptions
    108108        CPPAD_ASSERT_UNKNOWN( NumArg(SinhOp) == 1 );
     
    153153        size_t i_z         ,
    154154        size_t i_x         ,
    155         size_t cap_order   , 
     155        size_t cap_order   ,
    156156        Base*  taylor      )
    157157{
     
    190190        size_t      i_z          ,
    191191        size_t      i_x          ,
    192         size_t      cap_order    , 
     192        size_t      cap_order    ,
    193193        const Base* taylor       ,
    194194        size_t      nc_partial   ,
     
    212212        const Base* c  = s  - cap_order; // called y in documentation
    213213        Base* pc       = ps - nc_partial;
     214
     215        // If ps is zero, make sure this operation has no effect
     216        // (zero times infinity or nan would be non-zero).
     217        bool skip(true);
     218        Base bzero(0.0);
     219        for(size_t i_d = 0; i_d <= d; i_d++)
     220                skip &= ps[i_d] == bzero;
     221        if( skip )
     222                return;
    214223
    215224        // rest of this routine is identical for the following cases:
     
    225234                        px[k]   += ps[j] * Base(k) * c[j-k];
    226235                        px[k]   += pc[j] * Base(k) * s[j-k];
    227        
     236
    228237                        ps[j-k] += pc[j] * Base(k) * x[k];
    229238                        pc[j-k] += ps[j] * Base(k) * x[k];
  • trunk/cppad/local/sqrt_op.hpp

    r3320 r3666  
    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
     
    3838        size_t i_z         ,
    3939        size_t i_x         ,
    40         size_t cap_order   , 
     40        size_t cap_order   ,
    4141        Base*  taylor      )
    42 {       
     42{
    4343        // check assumptions
    4444        CPPAD_ASSERT_UNKNOWN( NumArg(SqrtOp) == 1 );
     
    8787        size_t i_z         ,
    8888        size_t i_x         ,
    89         size_t cap_order   , 
     89        size_t cap_order   ,
    9090        Base*  taylor      )
    91 {       
     91{
    9292        // check assumptions
    9393        CPPAD_ASSERT_UNKNOWN( NumArg(SqrtOp) == 1 );
     
    113113                z[m+ell] += x[m+ell] / Base(2);
    114114                z[m+ell] /= z[0];
    115         }       
     115        }
    116116}
    117117
     
    130130        size_t i_z         ,
    131131        size_t i_x         ,
    132         size_t cap_order   , 
     132        size_t cap_order   ,
    133133        Base*  taylor      )
    134134{
     
    160160        size_t      i_z          ,
    161161        size_t      i_x          ,
    162         size_t      cap_order    , 
     162        size_t      cap_order    ,
    163163        const Base* taylor       ,
    164164        size_t      nc_partial   ,
     
    177177        const Base* z  = taylor  + i_z * cap_order;
    178178        Base* pz       = partial + i_z * nc_partial;
     179
     180        // If pz is zero, make sure this operation has no effect
     181        // (zero times infinity or nan would be non-zero).
     182        bool skip(true);
     183        Base bzero(0.0);
     184        for(size_t i_d = 0; i_d <= d; i_d++)
     185                skip &= pz[i_d] == bzero;
     186        if( skip )
     187                return;
    179188
    180189        CPPAD_ASSERT_KNOWN(
  • trunk/cppad/local/tan_op.hpp

    r3320 r3666  
    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
     
    4444        size_t i_z         ,
    4545        size_t i_x         ,
    46         size_t cap_order   , 
     46        size_t cap_order   ,
    4747        Base*  taylor      )
    48 {       
     48{
    4949        // check assumptions
    5050        CPPAD_ASSERT_UNKNOWN( NumArg(TanOp) == 1 );
     
    9999        size_t i_z         ,
    100100        size_t i_x         ,
    101         size_t cap_order   , 
     101        size_t cap_order   ,
    102102        Base*  taylor      )
    103 {       
     103{
    104104        // check assumptions
    105105        CPPAD_ASSERT_UNKNOWN( NumArg(TanOp) == 1 );
     
    148148        size_t i_z         ,
    149149        size_t i_x         ,
    150         size_t cap_order   , 
     150        size_t cap_order   ,
    151151        Base*  taylor      )
    152152{
     
    186186        size_t      i_z          ,
    187187        size_t      i_x          ,
    188         size_t      cap_order    , 
     188        size_t      cap_order    ,
    189189        const Base* taylor       ,
    190190        size_t      nc_partial   ,
     
    208208        const Base* y  = z  - cap_order; // called y in documentation
    209209        Base* py       = pz - nc_partial;
     210
     211        // If pz is zero, make sure this operation has no effect
     212        // (zero times infinity or nan would be non-zero).
     213        bool skip(true);
     214        Base bzero(0.0);
     215        for(size_t i_d = 0; i_d <= d; i_d++)
     216                skip &= pz[i_d] == bzero;
     217        if( skip )
     218                return;
    210219
    211220        size_t j = d;
     
    222231                for(k = 0; k < j; k++)
    223232                        pz[k] += py[j-1] * z[j-k-1] * base_two;
    224        
     233
    225234                --j;
    226235        }
  • trunk/cppad/local/tanh_op.hpp

    r3320 r3666  
    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
     
    4444        size_t i_z         ,
    4545        size_t i_x         ,
    46         size_t cap_order   , 
     46        size_t cap_order   ,
    4747        Base*  taylor      )
    48 {       
     48{
    4949        // check assumptions
    5050        CPPAD_ASSERT_UNKNOWN( NumArg(TanOp) == 1 );
     
    9999        size_t i_z         ,
    100100        size_t i_x         ,
    101         size_t cap_order   , 
     101        size_t cap_order   ,
    102102        Base*  taylor      )
    103 {       
     103{
    104104        // check assumptions
    105105        CPPAD_ASSERT_UNKNOWN( NumArg(TanOp) == 1 );
     
    147147        size_t i_z         ,
    148148        size_t i_x         ,
    149         size_t cap_order   , 
     149        size_t cap_order   ,
    150150        Base*  taylor      )
    151151{
     
    185185        size_t      i_z          ,
    186186        size_t      i_x          ,
    187         size_t      cap_order    , 
     187        size_t      cap_order    ,
    188188        const Base* taylor       ,
    189189        size_t      nc_partial   ,
     
    207207        const Base* y  = z  - cap_order; // called y in documentation
    208208        Base* py       = pz - nc_partial;
     209
     210        // If pz is zero, make sure this operation has no effect
     211        // (zero times infinity or nan would be non-zero).
     212        bool skip(true);
     213        Base bzero(0.0);
     214        for(size_t i_d = 0; i_d <= d; i_d++)
     215                skip &= pz[i_d] == bzero;
     216        if( skip )
     217                return;
    209218
    210219        size_t j = d;
     
    221230                for(k = 0; k < j; k++)
    222231                        pz[k] += py[j-1] * z[j-k-1] * base_two;
    223        
     232
    224233                --j;
    225234        }
  • trunk/example/cond_exp.cpp

    r2892 r3666  
    11/* $Id$ */
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 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
     
    5656        using CppAD::AD;
    5757        using CppAD::NearEqual;
    58         using CppAD::log; 
     58        using CppAD::log;
    5959        using CppAD::abs;
    6060        double eps  = 100. * CppAD::numeric_limits<double>::epsilon();
    61         double fmax = std::numeric_limits<double>::max();
    6261
    6362        // domain space vector
    6463        size_t n = 5;
    65         CPPAD_TESTVECTOR(AD<double>) X(n);
     64        CPPAD_TESTVECTOR(AD<double>) ax(n);
    6665        size_t j;
    6766        for(j = 0; j < n; j++)
    68                 X[j] = 1.;
     67                ax[j] = 1.;
    6968
    7069        // declare independent variables and start tape recording
    71         CppAD::Independent(X);
     70        CppAD::Independent(ax);
    7271
    73         AD<double> Sum  = 0.;
    74         AD<double> Zero = 0.;
     72        AD<double> asum  = 0.;
     73        AD<double> azero = 0.;
    7574        for(j = 0; j < n; j++)
    7675        {       // if x_j > 0, add x_j * log( x_j ) to the sum
    77                 Sum += CppAD::CondExpGt(X[j], Zero, X[j] * log(X[j]),    Zero);
     76                asum += CppAD::CondExpGt(ax[j], azero, ax[j] * log(ax[j]), azero);
    7877        }
    7978
    80         // range space vector 
     79        // range space vector
    8180        size_t m = 1;
    82         CPPAD_TESTVECTOR(AD<double>) Y(m);
    83         Y[0] = Sum;
     81        CPPAD_TESTVECTOR(AD<double>) ay(m);
     82        ay[0] = asum;
    8483
    85         // create f: X -> Y and stop tape recording
    86         CppAD::ADFun<double> f(X, Y);
     84        // create f: x -> ay and stop tape recording
     85        CppAD::ADFun<double> f(ax, ay);
    8786
    8887        // vectors for arguments to the function object f
    8988        CPPAD_TESTVECTOR(double) x(n);   // argument values
    90         CPPAD_TESTVECTOR(double) y(m);   // function values 
    91         CPPAD_TESTVECTOR(double) w(m);   // function weights 
     89        CPPAD_TESTVECTOR(double) y(m);   // function values
     90        CPPAD_TESTVECTOR(double) w(m);   // function weights
    9291        CPPAD_TESTVECTOR(double) dw(n);  // derivative of weighted function
    9392
     
    9594        double check  = 0.;
    9695        for(j = 0; j < n; j++)
    97         {       x[j]   = double(j + 1); 
     96        {       x[j]   = double(j + 1);
    9897                check += x[j] * log( x[j] );
    9998        }
    10099
    101         // function value 
     100        // function value
    102101        y  = f.Forward(0, x);
    103102        ok &= NearEqual(y[0], check, eps, eps);
     
    107106        dw   = f.Reverse(1, w);
    108107        for(j = 0; j < n; j++)
    109                 ok &= NearEqual(dw[j], log(x[j]) + 1., eps, eps); 
     108                ok &= NearEqual(dw[j], log(x[j]) + 1., eps, eps);
    110109
    111110        // a case where x[3] is equal to zero
     
    113112        x[3]   = 0.;
    114113
    115         // function value 
     114        // function value
    116115        y   = f.Forward(0, x);
    117116        ok &= NearEqual(y[0], check, eps, eps);
     
    123122        for(j = 0; j < n; j++)
    124123        {       if( x[j] > 0 )
    125                         ok &= NearEqual(dw[j], log(x[j]) + 1., eps, eps); 
     124                        ok &= NearEqual(dw[j], log(x[j]) + 1., eps, eps);
    126125                else
    127                 {       // In this case computing dw[j] is computed using
    128                         //      log(x[j]) + x[j] / x[j]
    129                         // which has limit minus infinity but computes as nan.
    130                         ok &= ( isnan( dw[j] ) || dw[j] <= -fmax );
    131                 }
     126                        ok &= NearEqual(dw[j], 0.0, eps, eps);
    132127        }
    133        
     128
    134129        return ok;
    135130}
  • trunk/omh/whats_new/whats_new_15.omh

    r3656 r3666  
    3636        NumRes
    3737        chrono
     38        aeps
     39        CondExpGt
     40        hasnan
    3841$$
    3942
     
    4548The purpose of this section is to
    4649assist you in learning about changes between various versions of CppAD.
     50
     51$head 02-28$$
     52It used to be the case that the
     53$cref/Reverse mode/reverse/$$ would propagate $cref nan$$
     54through the $cref/conditional expression/condexp/$$
     55case that is not used.
     56For example, if
     57$codep
     58        Independent(ax);
     59        AD<double> aeps = 1e-10;
     60        ay[0] = CondExpGt( ax[0], aeps, 1.0/ax[0], 1.0/aeps );
     61        ADFun<double> f(ax, ay);
     62$$
     63The corresponding reverse mode calculation,
     64at $code x[0] = 0.0$$, would result in
     65$codep
     66        Error detected by false result for
     67        ! ( hasnan(value) && check_for_nan_ )
     68$$
     69This has been fixed so that only the conditional expression case that is used
     70affects the reverse mode results.
     71The example $cref cond_exp.cpp$$ was changed to reflect this
     72(a check for $code nan$$ was changed to a check for zero).
    4773
    4874$head 02-18$$
  • trunk/test_more/CMakeLists.txt

    r3519 r3666  
    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#
     
    1010# Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
    1111# -----------------------------------------------------------------------------
    12 # Build the test_more directory tests 
     12# Build the test_more directory tests
    1313# Inherit environment from ../CMakeList.txt
    1414
    15 # Specifies build type for this directory. Possible values are 
     15# Specifies build type for this directory. Possible values are
    1616# empty, Debug, Release, RelWithDebInfo and MinSizeRel
    1717SET(CMAKE_BUILD_TYPE DEBUG)
     
    3636IF ( eigen_prefix )
    3737        # compile eigen library separately so can use different compiler flags
    38         ADD_LIBRARY(test_more_eigen_lib EXCLUDE_FROM_ALL 
     38        ADD_LIBRARY(test_more_eigen_lib EXCLUDE_FROM_ALL
    3939                cppad_eigen.cpp
    4040        )
    4141        # Adds -D define flags to the compilation of source files.
    4242        ADD_DEFINITIONS("-DCPPAD_EIGEN_TEST")
    43         # Add other compiler flags 
    44         add_cppad_cxx_flags(test_more_eigen_lib) 
     43        # Add other compiler flags
     44        add_cppad_cxx_flags(test_more_eigen_lib)
    4545        #
    4646        # Add eigen to list of libraries
     
    5454# configure_file(InputFile OutputFile [COPYONLY] [ESCAPE_QUOTES] [@ONLY])
    5555CONFIGURE_FILE(
    56         ${CMAKE_CURRENT_SOURCE_DIR}/test_one.sh.in             
     56        ${CMAKE_CURRENT_SOURCE_DIR}/test_one.sh.in
    5757        ${CMAKE_CURRENT_SOURCE_DIR}/test_one.sh
    5858)
     
    8282        cond_exp.cpp
    8383        cond_exp_ad.cpp
     84        cond_exp_rev.cpp
    8485        copy.cpp
    8586        cos.cpp
     
    141142        vec_ad.cpp
    142143        vec_ad_par.cpp
    143         vec_unary.cpp 
     144        vec_unary.cpp
    144145)
    145146
     
    148149
    149150# List of libraries to be linked into the specified target
    150 TARGET_LINK_LIBRARIES(test_more 
     151TARGET_LINK_LIBRARIES(test_more
    151152        ${colpack_libs}
    152         ${adolc_libs} 
     153        ${adolc_libs}
    153154        ${ipopt_libs}
    154155        ${eigen_libs}
  • trunk/test_more/cond_exp.cpp

    r2893 r3666  
    11/* $Id$ */
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 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 Comprehensive test built on 08/07 for new user interface to CondExp 
     14Comprehensive test built on 08/07 for new user interface to CondExp
    1515*/
    1616// BEGIN C++
     
    3333
    3434        // parameter value
    35         AD<double> one = 1.; 
    36 
    37         // dependent variable vector 
     35        AD<double> one = 1.;
     36
     37        // dependent variable vector
    3838        CPPAD_TESTVECTOR(AD<double>) Y(5);
    3939
     
    4545        Y[4] = CondExpGt(one, X[0], X[1], X[2]);
    4646
    47         // create f: X -> Y 
     47        // create f: X -> Y
    4848        ADFun<double> f(X, Y);
    4949
     
    6363        ok &= Y[4] == X[1];
    6464
    65         // function values 
     65        // function values
    6666        v[0] = 2.;
    6767        v[1] = 1.;
     
    9595        ok   &= (dv[1] == dw[0] + dw[1] );
    9696        ok   &= (dv[2] == dw[2] + dw[3] + dw[4] );
    97        
     97
    9898        return ok;
    9999}
     
    111111
    112112        // parameter value
    113         AD<double> one = 1.; 
    114 
    115         // dependent variable vector 
     113        AD<double> one = 1.;
     114
     115        // dependent variable vector
    116116        CPPAD_TESTVECTOR(AD<double>) Y(5);
    117117
     
    123123        Y[4] = CondExpGt(X[0], one, X[1], X[2]);
    124124
    125         // create f: X -> Y 
     125        // create f: X -> Y
    126126        ADFun<double> f(X, Y);
    127127
     
    141141        ok &= Y[4] == X[2];
    142142
    143         // function values 
     143        // function values
    144144        v[0] = 2.;
    145145        v[1] = 1.;
     
    173173        ok   &= (dv[1] == dw[3] + dw[4] );
    174174        ok   &= (dv[2] == dw[0] + dw[1] + dw[2] );
    175        
     175
    176176        return ok;
    177177}
     
    189189
    190190        // parameter value
    191         AD<double> three = 3.; 
    192 
    193         // dependent variable vector 
     191        AD<double> three = 3.;
     192
     193        // dependent variable vector
    194194        CPPAD_TESTVECTOR(AD<double>) Y(5);
    195195
     
    201201        Y[4] = CondExpGt(X[0], X[1], three, X[2]);
    202202
    203         // create f: X -> Y 
     203        // create f: X -> Y
    204204        ADFun<double> f(X, Y);
    205205
     
    219219        ok &= Y[4] == X[2];
    220220
    221         // function values 
     221        // function values
    222222        v[0] = 2.;
    223223        v[1] = 1.;
     
    251251        ok   &= (dv[1] == 0.);
    252252        ok   &= (dv[2] == dw[0] + dw[1] + dw[2] );
    253        
     253
    254254        return ok;
    255255}
     
    267267
    268268        // parameter value
    269         AD<double> three = 3.; 
    270 
    271         // dependent variable vector 
     269        AD<double> three = 3.;
     270
     271        // dependent variable vector
    272272        CPPAD_TESTVECTOR(AD<double>) Y(5);
    273273
     
    279279        Y[4] = CondExpGt(X[0], X[1], X[2], three);
    280280
    281         // create f: X -> Y 
     281        // create f: X -> Y
    282282        ADFun<double> f(X, Y);
    283283
     
    297297        ok &= Y[4] == three;
    298298
    299         // function values 
     299        // function values
    300300        v[0] = 2.;
    301301        v[1] = 1.;
     
    329329        ok   &= (dv[1] == 0.);
    330330        ok   &= (dv[2] == dw[3] + dw[4] );
    331        
     331
    332332        return ok;
    333333}
     
    335335# include <limits>
    336336bool SecondOrderReverse(void)
    337 {       // Bradley M. Bell 2009-07-04 
     337{       // Bradley M. Bell 2009-07-04
    338338        // Reverse mode for CExpOp was only modifying the highest order partial
    339339        // This test demonstrated the bug
     
    352352
    353353        AD<double> left = X[0];
    354         AD<double> right = X[0] * X[0]; 
     354        AD<double> right = X[0] * X[0];
    355355        AD<double> exp_if_true  = left;
    356356        AD<double> exp_if_false = right;
     
    366366        Z            = CondExpGt(left, right, exp_if_true, exp_if_false);
    367367        Y[1]         = Z * Z;
    368        
     368
    369369        CppAD::ADFun<double> f(X, Y);
    370370
     
    384384        // check first derivative in dw
    385385        double check = 2. * Value( X[0] );
    386         ok &= NearEqual(dw[0], check, eps, eps); 
     386        ok &= NearEqual(dw[0], check, eps, eps);
    387387
    388388        // check second derivative in dw
    389389        check = 2.;
    390         ok &= NearEqual(dw[1], check, eps, eps); 
     390        ok &= NearEqual(dw[1], check, eps, eps);
    391391
    392392        // test exp_if_false case
     
    398398        // check first derivative in dw
    399399        check = 2. * Value( X[0] );
    400         ok &= NearEqual(dw[0], check, eps, eps); 
     400        ok &= NearEqual(dw[0], check, eps, eps);
    401401
    402402        // check second derivative in dw
    403403        check = 2.;
    404         ok &= NearEqual(dw[1], check, eps, eps); 
     404        ok &= NearEqual(dw[1], check, eps, eps);
    405405
    406406        return ok;
     
    415415        using CppAD::AD;
    416416        using CppAD::NearEqual;
    417         using CppAD::log; 
     417        using CppAD::log;
    418418        using CppAD::abs;
    419419        double eps = 100. * std::numeric_limits<double>::epsilon();
     
    445445        }
    446446
    447         // range space vector 
     447        // range space vector
    448448        size_t m = 1;
    449449        CPPAD_TESTVECTOR(AD<double>) Y(m);
     
    455455        // vectors for arguments to the function object f
    456456        CPPAD_TESTVECTOR(double) x(n);   // argument values
    457         CPPAD_TESTVECTOR(double) y(m);   // function values 
    458         CPPAD_TESTVECTOR(double) w(m);   // function weights 
     457        CPPAD_TESTVECTOR(double) y(m);   // function values
     458        CPPAD_TESTVECTOR(double) w(m);   // function weights
    459459        CPPAD_TESTVECTOR(double) dw(n);  // derivative of weighted function
    460460
     
    464464        for(j = 0; j < n; j++)
    465465        {       sign *= -1.;
    466                 x[j] = sign * double(j + 1); 
     466                x[j] = sign * double(j + 1);
    467467                check += log( abs( x[j] ) );
    468468        }
    469469
    470         // function value 
     470        // function value
    471471        y  = f.Forward(0, x);
    472472        ok &= ( y[0] == check );
     
    477477        for(j = 0; j < n; j++)
    478478        {       if( x[j] > 0. )
    479                         ok &= NearEqual(dw[j], 1./abs( x[j] ), eps, eps); 
    480                 else    ok &= NearEqual(dw[j], -1./abs( x[j] ), eps, eps); 
     479                        ok &= NearEqual(dw[j], 1./abs( x[j] ), eps, eps);
     480                else    ok &= NearEqual(dw[j], -1./abs( x[j] ), eps, eps);
    481481        }
    482482
     
    485485        for(j = 0; j < n; j++)
    486486        {       sign *= -1.;
    487                 x[j] = sign * double(j); 
     487                x[j] = sign * double(j);
    488488        }
    489489
    490         // function value 
     490        // function value
    491491        y   = f.Forward(0, x);
    492492        ok &= ( y[0] == -Infinity(0.) );
     
    498498        for(j = 0; j < n; j++)
    499499        {       if( x[j] > 0. )
    500                         ok &= NearEqual(dw[j], 1./abs( x[j] ), eps, eps); 
     500                        ok &= NearEqual(dw[j], 1./abs( x[j] ), eps, eps);
    501501                else if( x[j] < 0. )
    502                         ok &= NearEqual(dw[j], -1./abs( x[j] ), eps, eps); 
     502                        ok &= NearEqual(dw[j], -1./abs( x[j] ), eps, eps);
    503503                else
    504                 {       // in this case computing dw[j] ends up multiplying
    505                         // -infinity * zero and hence results in Nan
    506                         ok &= CppAD::isnan(dw[j]);
    507                 }
     504                        ok &= NearEqual(dw[j], 0.0, eps, eps);
    508505        }
    509        
     506
    510507        return ok;
    511508}
  • trunk/test_more/makefile.am

    r3519 r3666  
    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#
     
    1717# -------------------------------------------------------------------------
    1818if CppAD_OPENMP
    19 OPENMP_SRC_FILES   = alloc_openmp.cpp 
     19OPENMP_SRC_FILES   = alloc_openmp.cpp
    2020else
    2121OPENMP_SRC_FILES   =
     
    2323# -------------------------------------------------------------------------
    2424if CppAD_ADOLC
    25 ADOLC_SRC_FILES   = base_adolc.cpp 
     25ADOLC_SRC_FILES   = base_adolc.cpp
    2626ADOLC_EXTRA_FILES =
    2727ADOLC_LIB         = -ladolc -lColPack -L$(ADOLC_DIR)/lib -L$(ADOLC_DIR)/lib64
    28 ADOLC_FLAGS       = -DCPPAD_ADOLC_TEST -I$(ADOLC_DIR)/include 
     28ADOLC_FLAGS       = -DCPPAD_ADOLC_TEST -I$(ADOLC_DIR)/include
    2929else
    3030ADOLC_EXTRA_FILES = base_adolc.cpp
     
    3535# -------------------------------------------------------------------------
    3636if CppAD_IPOPT
    37 IPOPT_SRC_FILES   = ipopt_solve.cpp 
     37IPOPT_SRC_FILES   = ipopt_solve.cpp
    3838IPOPT_EXTRA_FILES =
    3939IPOPT_LIB         = -lipopt \
    4040        $(CPPAD_IPOPT_LIBS) $(FCLIBS) $(PTHREAD_LIB) $(DL_LIB)
    41 IPOPT_FLAGS       = -DCPPAD_IPOPT_TEST -I$(IPOPT_DIR)/include 
     41IPOPT_FLAGS       = -DCPPAD_IPOPT_TEST -I$(IPOPT_DIR)/include
    4242else
    4343IPOPT_EXTRA_FILES = ipopt_solve.cpp
     
    5757        $(CXX_FLAGS_EIGEN) \
    5858        -DCPPAD_EIGEN_TEST \
    59          -I$(EIGEN_DIR)/include 
     59         -I$(EIGEN_DIR)/include
    6060else
    6161EIGEN_EXTRA_FILES   = cppad_eigen.cpp
     
    7878        $(ADOLC_FLAGS) \
    7979        $(IPOPT_FLAGS) \
    80         $(OPENMP_FLAGS) 
     80        $(OPENMP_FLAGS)
    8181#
    8282AM_CXXFLAGS       = -g $(ADOLC_FLAGS) $(IPOPT_FLAGS) $(CXX_FLAGS)
    8383#
    84 AM_LDFLAGS        = $(OPENMP_FLAGS) 
    85 LDADD             = $(ADOLC_LIB) $(IPOPT_LIB) $(EIGEN_LIB) $(OPENMP_FLAGS) 
     84AM_LDFLAGS        = $(OPENMP_FLAGS)
     85LDADD             = $(ADOLC_LIB) $(IPOPT_LIB) $(EIGEN_LIB) $(OPENMP_FLAGS)
    8686#
    8787test_more_SOURCES  = \
     
    107107        cond_exp.cpp \
    108108        cond_exp_ad.cpp \
     109        cond_exp_rev.cpp \
    109110        copy.cpp \
    110111        cos.cpp \
     
    167168        vec_ad.cpp \
    168169        vec_ad_par.cpp \
    169         vec_unary.cpp 
     170        vec_unary.cpp
    170171
    171172test: check
  • trunk/test_more/makefile.in

    r3650 r3666  
    107107        atan2.cpp base_alloc.cpp check_simple_vector.cpp \
    108108        checkpoint.cpp compare.cpp compare_change.cpp cond_exp.cpp \
    109         cond_exp_ad.cpp copy.cpp cos.cpp cosh.cpp dbl_epsilon.cpp \
    110         div.cpp div_eq.cpp div_zero_one.cpp erf.cpp exp.cpp \
    111         extern_value.cpp extern_value.hpp for_hess.cpp \
     109        cond_exp_ad.cpp cond_exp_rev.cpp copy.cpp cos.cpp cosh.cpp \
     110        dbl_epsilon.cpp div.cpp div_eq.cpp div_zero_one.cpp erf.cpp \
     111        exp.cpp extern_value.cpp extern_value.hpp for_hess.cpp \
    112112        for_sparse_jac.cpp forward.cpp forward_dir.cpp \
    113113        forward_order.cpp from_base.cpp fun_check.cpp jacobian.cpp \
     
    133133        checkpoint.$(OBJEXT) compare.$(OBJEXT) \
    134134        compare_change.$(OBJEXT) cond_exp.$(OBJEXT) \
    135         cond_exp_ad.$(OBJEXT) copy.$(OBJEXT) cos.$(OBJEXT) \
    136         cosh.$(OBJEXT) dbl_epsilon.$(OBJEXT) div.$(OBJEXT) \
    137         div_eq.$(OBJEXT) div_zero_one.$(OBJEXT) erf.$(OBJEXT) \
    138         exp.$(OBJEXT) extern_value.$(OBJEXT) for_hess.$(OBJEXT) \
    139         for_sparse_jac.$(OBJEXT) forward.$(OBJEXT) \
     135        cond_exp_ad.$(OBJEXT) cond_exp_rev.$(OBJEXT) copy.$(OBJEXT) \
     136        cos.$(OBJEXT) cosh.$(OBJEXT) dbl_epsilon.$(OBJEXT) \
     137        div.$(OBJEXT) div_eq.$(OBJEXT) div_zero_one.$(OBJEXT) \
     138        erf.$(OBJEXT) exp.$(OBJEXT) extern_value.$(OBJEXT) \
     139        for_hess.$(OBJEXT) for_sparse_jac.$(OBJEXT) forward.$(OBJEXT) \
    140140        forward_dir.$(OBJEXT) forward_order.$(OBJEXT) \
    141141        from_base.$(OBJEXT) fun_check.$(OBJEXT) jacobian.$(OBJEXT) \
     
    491491        cond_exp.cpp \
    492492        cond_exp_ad.cpp \
     493        cond_exp_rev.cpp \
    493494        copy.cpp \
    494495        cos.cpp \
     
    630631@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/cond_exp.Po@am__quote@
    631632@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/cond_exp_ad.Po@am__quote@
     633@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/cond_exp_rev.Po@am__quote@
    632634@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/copy.Po@am__quote@
    633635@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/cos.Po@am__quote@
  • trunk/test_more/test_more.cpp

    r3646 r3666  
    3737extern bool CondExp(void);
    3838extern bool CondExpAD(void);
     39extern bool cond_exp_rev(void);
    3940extern bool copy(void);
    4041extern bool Cos(void);
     
    148149        ok &= Run( CondExp,         "CondExp"        );
    149150        ok &= Run( CondExpAD,       "CondExpAD"      );
     151        ok &= Run( cond_exp_rev,    "cond_exp_rev"   );
    150152        ok &= Run( copy,            "copy"           );
    151153        ok &= Run( Cos,             "Cos"            );
Note: See TracChangeset for help on using the changeset viewer.