Changeset 4023


Ignore:
Timestamp:
Aug 27, 2018 8:29:27 AM (15 months ago)
Author:
bradbell
Message:

merge to branch: trunk
from repository: https://github.com/coin-or/CppAD
start hash code: 2e1a66d90fc4d50f9681014fb67115500af63e64
end hash code: 46be2e2dbcaba47d8a38e8d9110efc48c7245754

commit 46be2e2dbcaba47d8a38e8d9110efc48c7245754
Author: Brad Bell <bradbell@…>
Date: Fri Aug 24 07:52:59 2018 -0700

master: Advance to cppad-20180824

commit 7e9064adadd484ffd67dc31aa9b02aa8c8244a94
Author: Brad Bell <bradbell@…>
Date: Fri Aug 24 07:52:48 2018 -0700

master: automatic changes to autotools files (caused by previous commit).

commit 626cf04b54cf93587fb9d17353ff065a57befc30
Author: Brad Bell <bradbell@…>
Date: Fri Aug 24 07:50:01 2018 -0700

master: pkgconfig: attempt to fix autotools version of pkgconfig files.

commit 9028c8b97f772a8fde2cd8b9830c14bc1f6a64fc
Author: Brad Bell <bradbell@…>
Date: Tue Aug 21 14:31:50 2018 -0700

master:
test_one.sh.in: execute test when compliation has warnings.
trace.sh: update directory where sweeps are stored.

commit e1d3725874be8a721457c279bc7a7445e8710edf
Author: Brad Bell <bradbell@…>
Date: Tue Aug 21 10:50:04 2018 -0700

master: Advance to cppad-20180821

commit 34516eb1ecf5417f2e0f21b741f983ff130b8cad
Author: Brad Bell <bradbell@…>
Date: Tue Aug 21 10:49:57 2018 -0700

master: dynamic_parameter: optimize: test dynamic parameter that is not used.

commit b5649cd756aeedaa0d7e42c88c5fabc6b2198479
Author: Brad Bell <bradbell@…>
Date: Mon Aug 20 14:49:41 2018 -0700

master: fix parenthesis warning.

commit 907bbf2cdb3c33614e20149d88a73ddbf18a06e6
Author: Brad Bell <bradbell@…>
Date: Mon Aug 20 14:26:43 2018 -0700

master: optimize dynamic parameters: check communative operators.


check_all.sh: fix checking packages that are skipped.
optimize_run.hpp: fix uses of parameters that are optimized out.
dynamic.hpp: fix invalid memory access.

commit 647af6ecdbd714d82877f324a60850b50b988997
Author: Brad Bell <bradbell@…>
Date: Mon Aug 20 13:01:30 2018 -0700

master: optimize dynamic parameters: first cut.

commit 876d26715ef3fab311213c732d25065b2563bda8
Author: Brad Bell <bradbell@…>
Date: Mon Aug 20 09:35:02 2018 -0700

master: optimize: change hash coding so can be used with dynamic parameter operators.
get_op_previous.hpp: improve doc for op_previous.
hash_code.hpp: extend
player.hpp: improve dyn_ind2par_ind doc;.
dynamic.hpp: fix comment about i_arg.

commit 7a505e89f51f873ff8ea3c8f5ec25195fbcc1f77
Author: Brad Bell <bradbell@…>
Date: Mon Aug 20 04:35:28 2018 -0700

master: Advance to cppad-20180820

commit 28a56b6e029a9c9049cdfee10fabd6a25bca5908
Author: Brad Bell <bradbell@…>
Date: Mon Aug 20 04:35:19 2018 -0700

master: fix dynamic arguments to discrete functions, fix checking for Identical zero and one.

commit 10522e462c6e0cb6973727831e03b83e0cc55f3e
Author: Brad Bell <bradbell@…>
Date: Sun Aug 19 05:54:16 2018 -0700

master: move use ov var_ad_type instead of not dyn_ad_type, get_previous -> get_op_previous.

commit d6d01434bf021afd8ffc3cb83da9f0271f70ada4
Author: Brad Bell <bradbell@…>
Date: Sun Aug 19 04:50:51 2018 -0700

master: set and check for var_ad_type.

commit e27af978573269faebf365a65f6db78e8355d509
Author: Brad Bell <bradbell@…>
Date: Sun Aug 19 04:24:47 2018 -0700

master: Advance to cppad-20180819

commit 37445683bec2a0c9c3f40035c165946bddc04e24
Author: Brad Bell <bradbell@…>
Date: Sun Aug 19 04:24:40 2018 -0700

master: AD<Base>: change dynamic_ -> ad_type_.

commit fd4937060b978cf5840fc5bc54744805ac5930fd
Author: Brad Bell <bradbell@…>
Date: Sat Aug 18 14:57:28 2018 -0700

master: change tape_manage_* -> *_tape_manage.

commit df8271a3ed4b7d91c21b88ebbfac3067971fa14d
Author: Brad Bell <bradbell@…>
Date: Sat Aug 18 14:38:02 2018 -0700

master: remove make_parameter: only used one place.

commit 97956cb21c69c40387187a6d6972559aaf5ebcc9
Author: Brad Bell <bradbell@…>
Date: Sat Aug 18 08:37:03 2018 -0700

master: check_all: fix cheking which packages have been skipped

commit f28610a7ca2f854624c3103664449a5db46c2030
Author: Brad Bell <bradbell@…>
Date: Sat Aug 18 06:32:28 2018 -0700

master: user's view of todays changes.

commit 3c9c5737307909b0675ae69b1c5e372b8a8ae2a1
Author: Brad Bell <bradbell@…>
Date: Sat Aug 18 06:24:30 2018 -0700

master: fix Integer and unary minus for dynamic parameters.

commit a9f775fff5ffdfebb53478c8d7e0931d24b95a3e
Author: Brad Bell <bradbell@…>
Date: Sat Aug 18 04:50:01 2018 -0700

master: test: eigen_mat_inv.cpp: fix clang warning.

commit 89f1d68ff7ea7994af476302938328ffcf0abd30
Author: Brad Bell <bradbell@…>
Date: Sat Aug 18 04:20:02 2018 -0700

master: Advance to cppad-20180818

commit ef86011d8bd7b53a8681be26843d4ea84f091068
Author: Brad Bell <bradbell@…>
Date: Sat Aug 18 04:19:55 2018 -0700

master: dynamic: fix unused variable warning.


new_dynamic.hpp: change unknonw assert to know assert.

commit 59a79a15accaa33a18fda8c933ce95b727983750
Author: Brad Bell <bradbell@…>
Date: Fri Aug 17 23:06:01 2018 -0700

master: correct compound assignment for constant op dynamic.

commit f21aa3b4cc329e44ded0c1f2125029b3ce7d8d5c
Author: Brad Bell <bradbell@…>
Date: Fri Aug 17 19:43:57 2018 -0700

master: Advance to cppad-20180817

commit 00d1579ab9d34bbb8171a8395562d0f0841f616e
Author: Brad Bell <bradbell@…>
Date: Fri Aug 17 19:43:39 2018 -0700

master: sweep: dynamic: include setting of independent parameters.

commit 9cea5f03f560338fbb86a42a8a03d492c576b8e2
Author: Brad Bell <bradbell@…>
Date: Thu Aug 16 13:01:19 2018 -0700

master: 1. fix compound assignments with dynamic parameter on left, varialbe on right.

  1. Advance to cppad-20180816.
  2. Fix clange typename not inside template errors.

commit ca1cf7702eb26806e5cad1bd908072f67a752b0f
Author: Brad Bell <bradbell@…>
Date: Tue Aug 14 19:36:13 2018 -0700

master:
check_all.sh: fix checking which packages have been skipped.
eigen_mat_inv.cpp: remove use of typename outside of template.

commit 1a0dc12756fb3bec7916630e14ffa0d0cddd5625
Author: Brad Bell <bradbell@…>
Date: Tue Aug 14 09:45:48 2018 -0700

master: fix computed assignment dynamic parameter operations.

commit ffed4de3a4191619385c078401644736ae90bc04
Author: Brad Bell <bradbell@…>
Date: Tue Aug 14 06:38:43 2018 -0700

master: Advance to cppad-20180814

commit 5919c9ff26010fea65c0ade2a269027d50f05dd4
Author: Brad Bell <bradbell@…>
Date: Tue Aug 14 06:38:32 2018 -0700

master: independent: improve discussion of abort_op_index.

commit b86abebc7541b29c23ec3a6095b383f964620e58
Author: Brad Bell <bradbell@…>
Date: Mon Aug 13 06:51:36 2018 -0700

master: user's view fixing clang++ conversion warnings.

commit 08befa4a4a7a268884a5caf94702cd50c5b904bd
Author: Brad Bell <bradbell@…>
Date: Mon Aug 13 05:22:43 2018 -0700

master: Advance to cppad-20180813

commit 5e0ef18f4c2494955fe9eda3598e0cb608f96f5d
Author: Brad Bell <bradbell@…>
Date: Mon Aug 13 05:22:37 2018 -0700

master: add random choice of clang during check_all.
new_dynamic.cpp: add explicit conversion size_t -> double.
check_all.sh: fix check for adolc

commit e6711c83c59ed5ea70086b0f0be95e0d8bd4a7ec
Author: Brad Bell <bradbell@…>
Date: Sun Aug 12 21:44:09 2018 -0700

master: fix remaining clang warnings in check_test_more.


test_one.sh.in: configue compiler.
.gitignore: ignore *.warn.

commit 0f5c201ea32354eb1704f8e39dfce0dfba7720eb
Author: Brad Bell <bradbell@…>
Date: Sun Aug 12 15:36:04 2018 -0700

master: fix remaining warnings in example/utility, example/sparse.

commit ac1987ab79f63958bb0f7eebad8cfc89c7315dec
Author: Brad Bell <bradbell@…>
Date: Sun Aug 12 15:02:14 2018 -0700

master: fix remaining clang warnings in example/general.

commit 5e47577bc54a3d7f803a398821e57a2de6f707e5
Author: Brad Bell <bradbell@…>
Date: Sun Aug 12 14:28:19 2018 -0700

master: create eigen_vector wrapper so it is a true simple vector.


check_all.sh: fix spelling of default.

commit 9e542c21239580552e7b322f867c277445639043
Author: Brad Bell <bradbell@…>
Date: Sun Aug 12 10:34:36 2018 -0700

master: fix some clang warnings in example/general.

commit 243ac655e7dfbba45031b2177f35120361709d6f
Author: Brad Bell <bradbell@…>
Date: Sun Aug 12 09:12:22 2018 -0700

master: fix clang warnings in make check_example_atomic.

commit a9adcde224220cd6571a3019fd989c78394acaa5
Author: Brad Bell <bradbell@…>
Date: Sun Aug 12 07:40:33 2018 -0700

master: fix clang warnings in make check_example_abs_normal.

commit 569b9514f8d7faecae4b27a79f7d6e38cbc07d67
Author: Brad Bell <bradbell@…>
Date: Sun Aug 12 07:21:57 2018 -0700

master: fix clang warnings in make check_speed_fadbad.

commit 20a0a8887bb0acf4c86f36b95a5188e0bbcc3c54
Author: Brad Bell <bradbell@…>
Date: Sun Aug 12 06:37:29 2018 -0700

master: fix clang warnings in make check_spped_cppad.

commit bdeab60791f21386159fa2a387c8483c9ef0d069
Author: Brad Bell <bradbell@…>
Date: Sun Aug 12 05:59:41 2018 -0700

master: fix remainin clange warnings in make cppad_ipopt_example.

commit 5829350b0071bfd5ec35ec529ba2788d768d8d3e
Author: Brad Bell <bradbell@…>
Date: Sun Aug 12 05:22:31 2018 -0700

master: gitignore: improve comments, remove and restrict some ignores.

commit e2070caf9e190b88ab46c9e9e4bb43da6e5ac653
Author: Brad Bell <bradbell@…>
Date: Sun Aug 12 05:05:00 2018 -0700

master: Advance to cppad-20180812

commit ede76511f29725ab73f17651095c86285efbadce
Author: Brad Bell <bradbell@…>
Date: Sun Aug 12 05:04:53 2018 -0700

master: adding clang to run bin/check_all (still has warnings).

commit a476071d0ece4d069d70f9c81909797871b509cd
Author: Brad Bell <bradbell@…>
Date: Sat Aug 11 09:35:45 2018 -0700

master: fix some more clang warnings.

commit 5f6ece227dfa6746272389a1051b8fa11387d466
Author: Brad Bell <bradbell@…>
Date: Sat Aug 11 09:24:43 2018 -0700

master: fix some more clang warnings.

commit 1d5141a623b840337aa0dac993ae46db90d961e9
Author: Brad Bell <bradbell@…>
Date: Sat Aug 11 09:03:53 2018 -0700

master: fix some more clang warnings.

commit d531b5713a668d296c182788f95b12ac75672346
Author: Brad Bell <bradbell@…>
Date: Sat Aug 11 08:59:41 2018 -0700

master: fix some more clang warnings.


cexp_info.hpp: reduce memory usage by vectors of this struuct.

commit 94231747b63cd56790a52b2fdf86e7792856e5d0
Author: Brad Bell <bradbell@…>
Date: Sat Aug 11 08:26:07 2018 -0700

master: fix some more clang warnings.


cexp_info.hpp: reduce memory usage by vectors of this struuct.

commit 76ec95d116b4a8982ced5565edb1f6e291fd4f52
Author: Brad Bell <bradbell@…>
Date: Sat Aug 11 08:05:16 2018 -0700

master: fix some more clang warnings.

commit 934019a6a3c9eba7a7b4313a03d10ee197ed086f
Author: Brad Bell <bradbell@…>
Date: Sat Aug 11 07:40:32 2018 -0700

master: fix some more clang warnings.

commit 57b6bc32f3762ffbac20be7fde63b212bfc5e30d
Author: Brad Bell <bradbell@…>
Date: Sat Aug 11 06:56:07 2018 -0700

master: fix some more clang warnings.

commit b2a84502b9dfd2d47e2f8a8143cdd541259158b3
Author: Brad Bell <bradbell@…>
Date: Sat Aug 11 06:34:05 2018 -0700

master: fix some more clang warnings.

commit fb7c3798279ee2d6a12a7f08d1a8360eb3270c84
Author: Brad Bell <bradbell@…>
Date: Sat Aug 11 06:13:12 2018 -0700

master: fix some more clang warnings.

commit 1acad7de4f0479369006076c694af8fe29cb9a2a
Author: Brad Bell <bradbell@…>
Date: Sat Aug 11 05:47:11 2018 -0700

master: fix some more clang warnings.

commit c1ac818492eede871b8c3361261131728203d589
Author: Brad Bell <bradbell@…>
Date: Sat Aug 11 05:22:02 2018 -0700

master: fix more clang++ wanrings, advance to cppad-20180811.


pod_vector.hpp: extend index to any type with cast to size_t.
vector.hpp: extend index to any type with cast to size_t.

commit 3a46ae2d7b6e13dcb5746a90531d895f7046b87f
Author: Brad Bell <bradbell@…>
Date: Fri Aug 10 17:15:37 2018 -0700

master: fix some clang++ compiler warnings.

commit 6a7b805ccd1ab3e1c99a86a7dc93b5aaa151be23
Author: Brad Bell <bradbell@…>
Date: Fri Aug 10 15:55:43 2018 -0700

master: fix some clang++ compiler warnings.

commit 88bcca2a3c4f6c970788d0a49802dc4c6cffe90e
Author: Brad Bell <bradbell@…>
Date: Fri Aug 10 15:22:24 2018 -0700

master: fix some clang++ compiler warnings.

commit 25a2c5ad4ec6927cd33cb968b4b4b25f92e23ce4
Author: Brad Bell <bradbell@…>
Date: Fri Aug 10 11:08:47 2018 -0700

master: fix some clang++ compiler warnings.

commit 6db63fc55036aa5aebb578b09d42afaa11e79853
Author: Brad Bell <bradbell@…>
Date: Fri Aug 10 10:16:26 2018 -0700

master: fix some clang++ compiler warnings.

commit fefaa572a88dd8e12362075a642d546928b26f34
Author: Brad Bell <bradbell@…>
Date: Fri Aug 10 09:32:17 2018 -0700

master: Advance to cppad-20180810

commit fafb45ae00b571b9b573065fb0deef84a9bf4a8c
Author: Brad Bell <bradbell@…>
Date: Fri Aug 10 09:32:10 2018 -0700

master: fix some clang++ compiler warnings.

commit 3fc1776c0dd160e040b9f455d0a299427fa98047
Author: Brad Bell <bradbell@…>
Date: Thu Aug 9 10:34:57 2018 -0700

master: clang_simple.sh: attempt to make bug report for issue 31.

commit 9dd2ff1f01dfc83e6da0b415232c5322af25f293
Author: Brad Bell <bradbell@…>
Date: Thu Aug 9 10:15:58 2018 -0700

master: optimize: PrintFor?.


batch_edit.sh: add to plan for batch_edit all files.
optimize.hpp: suppress PrintFor? operations during optimize.
print_for.hpp: improve documentation.
op_code.hpp: improve comments about PriOp?.
get_par_usage.hpp: fix bug in optimzation of PrintFor?.
optimize.cpp: Add test for bug.

commit 35178709b91f2aa572d0a542d462201d6b29afcf
Author: Brad Bell <bradbell@…>
Date: Thu Aug 9 05:01:29 2018 -0700

master: Advance to cppad-20180809

commit e770421816e7ea5002731551ffae93dcb2738617
Author: Brad Bell <bradbell@…>
Date: Thu Aug 9 05:01:22 2018 -0700

master: ADFun assignment operator: fix some valgrind warnings.
One step in doing this is making AD<Base> a special case when hash coding.


pod_vector.hpp: fix bug in assignment operator.

Location:
trunk
Files:
4 added
1 deleted
164 edited

Legend:

Unmodified
Added
Removed
  • trunk/.gitignore

    r3991 r4023  
     1# ----------------------------------------------------------------------------
    12# specific files
    23/aclocal.m4
     
    1011/test_one.cpp
    1112/test_one.exe
     13# ----------------------------------------------------------------------------
    1214# specific directories
    13 /bug/build/
    1415/build/
    15 /doc/
    1616/doxydoc/
    17 # specific extensions in all directories
    18 *.err
    19 *.log
    20 *.swp
    21 *.tmp
    22 # all new directories
    2317/new/
    2418/new.*/
    25 # all junk files and direcrories
     19# directory that is ignored by master, but not by gh-pages
     20/doc/
     21# ----------------------------------------------------------------------------
     22# specific extensions in top direcotry
     23/*.err
     24/*.log
     25/*.warn
     26# ----------------------------------------------------------------------------
     27# vim swap files in any directory
     28*.swp
     29# ----------------------------------------------------------------------------
     30# junk and temp files in any directory
    2631junk
    2732junk.*
    28 # all temp files and directories
    2933temp
    3034temp.*
  • trunk/CMakeLists.txt

    r4021 r4023  
    2525#
    2626# cppad_version is used by version.sh to get the version number.
    27 SET(cppad_version "20180730")
     27SET(cppad_version "20180824")
    2828SET(cppad_url          "http://www.coin-or.org/CppAD" )
    2929SET(cppad_description  "Differentiation of C++ Algorithms" )
     
    236236        ENDIF( cppad_postfix )
    237237ENDFOREACH(dir_types includedirs libdirs datadir docdir)
     238# -----------------------------------------------------------------------------
     239# OPENMP_FOUND, OpenMP_CXX_FLAGS
     240FIND_PACKAGE(OpenMP)
    238241# -----------------------------------------------------------------------------
    239242# boost_prefix
  • trunk/bin/batch_edit.sh

    r4022 r4023  
    2626# 13. Remove CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION
    2727# 14. Remove all inlines for functions that depend on template parameters.
     28# 15. Change 'ind[0-9] -> arg[0-9] when used as operator arguments.
    2829# -----------------------------------------------------------------------------
    2930spell_list='
     
    3637#
    3738cat << EOF > junk.sed
    38 s|inv_dyn|ind_dyn|g
     39s/if( ! IdenticalZero( *right.value_ *) )/if( dyn_right | (! IdenticalZero(right.value_) ) )/
     40#
     41s|if( IdenticalZero( *right.value_ *) )|if( (! dyn_right) \\& IdenticalZero(right.value_) )|
     42s|if( IdenticalOne( *right.value_ *) )|if( (! dyn_right) \\& IdenticalOne(right.value_) )|
     43#
     44s|if( IdenticalZero( *left *) )|if( (! dyn_left) \\& IdenticalZero(left) )|
     45s|if( IdenticalZero( *left.value_ *) )|if( (! dyn_left) \\& IdenticalZero(left.value_) )|
     46s|if( IdenticalOne( *left *) )|if( (! dyn_left) \\& IdenticalOne(left) )|
     47s|if( IdenticalOne( *left.value_ *) )|if( (! dyn_left) \\& IdenticalOne(left.value_) )|
    3948EOF
    4049# -----------------------------------------------------------------------------
  • trunk/bin/check_all.sh

    r4016 r4023  
    2525        fi
    2626fi
     27# -----------------------------------------------------------------------------
     28check_all_warn() {
     29cat << EOF > check_all.$$
     30# Lines that describe where error is
     31/^In file included from/d
     32/: note:/d
     33#
     34# Ipopt has sign conversion warnings
     35/\/coin\/.*-Wsign-conversion/d
     36#
     37# Adolc has multiple types of conversion warnings
     38/\/adolc\/.*-W[a-z-]*conversion/d
     39/\/adolc\/.*-Wshorten-64-to-32/d
     40#
     41# Lines describing the error begin with space
     42/^ /d
     43#
     44# Lines summarizing results
     45/^[0-9]* warnings generated/d
     46EOF
     47        sed $top_srcdir/check_all.err -f check_all.$$ > $top_srcdir/check_all.warn
     48        rm check_all.$$
     49}
     50# -----------------------------------------------------------------------------
    2751echo_log_eval() {
    2852        echo $*
    2953        echo $* >> $top_srcdir/check_all.log
    30         echo $* > $top_srcdir/check_all.err
    31         if ! eval $* >> $top_srcdir/check_all.log 2>> $top_srcdir/check_all.err
    32         then
    33                 cat $top_srcdir/check_all.err
    34                 echo 'Error: see check_all.log'
    35                 exit 1
    36         fi
    37         count=`wc -l $top_srcdir/check_all.err | sed -e 's|\([0-9]*\) .*|\1|'`
    38         if [ "$count" != '1' ]
    39         then
    40                 cat "$top_srcdir/check_all.err"
    41                 echo 'Warning: see check_all.err'
    42                 exit 1
    43         fi
    44         rm $top_srcdir/check_all.err
     54        if ! eval $* >> $top_srcdir/check_all.log 2> $top_srcdir/check_all.err
     55        then
     56                tail $top_srcdir/check_all.err
     57                echo 'Error: see check_all.err, check_all.log'
     58                exit 1
     59        fi
     60        check_all_warn
     61        count=`wc -l $top_srcdir/check_all.warn | sed -e 's|^\([0-9]*\) .*|\1|'`
     62        if [ "$count" != '0' ]
     63        then
     64                head "$top_srcdir/check_all.warn"
     65                echo 'Warning: see check_all.warn, check_all.log'
     66                exit 1
     67        fi
     68        rm $top_srcdir/check_all.warn $top_srcdir/check_all.err
    4569}
    4670echo_log() {
     
    5377        set -e
    5478}
     79# -----------------------------------------------------------------------------
    5580if [ -e check_all.log ]
    5681then
     
    82107fi
    83108#
     109random_01 compiler
     110if [ "$random_01_compiler" == '0' ]
     111then
     112        compiler='default'
     113else
     114        compiler='--clang'
     115fi
    84116random_01 standard
    85117if [ "$random_01_standard" == '0' ]
    86118then
    87119        standard='--c++98 --no_adolc --no_sacado'
    88         random_standard="$standard"
    89 else
    90         standard=''
    91         random_standard="--c++11"
     120else
     121        standard='--c++11'
    92122fi
    93123#
     
    115145cat << EOF
    116146tarball         = $tarball
    117 standard        = $random_standard
     147compiler        = $compiler
     148standard        = $standard
    118149debug_which     = $debug_which
    119150package_vector  = $package_vector
     
    121152cat << EOF >> $top_srcdir/check_all.log
    122153tarball         = $tarball
    123 standard        = $random_standard
     154compiler        = $compiler
     155standard        = $standard
    124156debug_which     = $debug_which
    125157package_vector  = $package_vector
    126158EOF
     159if [ "$compiler" == 'default' ]
     160then
     161        compiler=''
     162fi
     163if [ "$standard" == '--c++11' ]
     164then
     165        standard='' # default for run_cmake.sh
     166fi
    127167# ---------------------------------------------------------------------------
    128168# Run automated checks for the form bin/check_*.sh with a few exceptions.
     
    147187echo_log_eval cd cppad-$version
    148188# -----------------------------------------------------------------------------
    149 echo_log_eval bin/run_cmake.sh $package_vector $debug_which $standard
     189echo_log_eval bin/run_cmake.sh $compiler $standard $debug_which $package_vector
    150190echo_log_eval cd build
    151191# -----------------------------------------------------------------------------
     
    159199        then
    160200                skip="$skip $package"
    161         elif [ "$package" == 'adolc' ] || [ "$package" == 'sacado' ]
    162         then
    163                 if [ "$standard" != '' ]
    164                 then
    165                         skip="$skip $package"
    166                 fi
     201        elif echo $standard | grep "no_$package" > /dev/null
     202        then
     203                skip="$skip $package"
    167204        fi
    168205done
     
    173210        echo_eval speed/cppad/speed_cppad correct 432 $option
    174211done
    175 if echo "$skip_package" | grep 'adolc' > /dev/null
     212if ! echo "$skip" | grep 'adolc' > /dev/null
    176213then
    177214        echo_eval speed/adolc/speed_adolc correct         432 onetape
  • trunk/bin/get_colpack.sh

    r3834 r4023  
    11#! /bin/bash -e
    2 # $Id$
    32# -----------------------------------------------------------------------------
    4 # CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
     3# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-18 Bradley M. Bell
    54#
    65# CppAD is distributed under multiple licenses. This distribution is under
     
    9493then
    9594        echo_eval tar -xzf ColPack-$version.tar.gz
     95        #
     96        # patch source: newline missing at end of file in verions 1.0.10
     97        sed -i ColPack-$version/Recovery/RecoveryCore.h -e '$,$ s|$|\n|'
    9698fi
    9799echo_eval cd ColPack-$version
  • trunk/bin/test_one.sh.in

    r3969 r4023  
    11#! /bin/bash -e
    22# -----------------------------------------------------------------------------
    3 # CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-17 Bradley M. Bell
     3# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-18 Bradley M. Bell
    44#
    55# CppAD is distributed under multiple licenses. This distribution is under
     
    1010# Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
    1111# -----------------------------------------------------------------------------
    12 # Run one of the tests
     12# Command line arguments
    1313if [ "$0" != 'bin/test_one.sh' ]
    1414then
     
    1818dir:   directory in front of file name
    1919file:  name of *.cpp file, with extension, that contains the test
    20 extra: extra source files and/or options for the g++ command
     20extra: extra source files and/or options for the compile command
    2121EOF
    2222        exit 1
     
    3131fi
    3232# ---------------------------------------------------------------------------
     33# Check command line arguments
    3334if [ "$dir" == '' ]
    3435then
     
    4647        exit 1
    4748fi
     49# ---------------------------------------------------------------------------
     50# Clean out old output files
    4851if [ -e test_one.exe ]
    4952then
     
    5659original_dir=`pwd`
    5760# ---------------------------------------------------------------------------
    58 # check for cppad_lib
     61# Make sure cppad_lib is there
    5962count=`ls build/cppad_lib/libcppad_lib.* | wc -l`
    6063if [ "$count" == '0' ]
     
    8487fi
    8588# --------------------------------------------------------------------------
     89# Create test_one.exe
     90#
    8691# determine the function name
    8792fun=`grep "^bool *[a-zA-Z0-9_]* *( *void *)" $dir/$file | tail -1 | \
     
    9196main=`echo *$dir | sed -e 's|.*/||' -e 's|$|.cpp|'`
    9297#
    93 # create test_one.cpp
    9498sed < $dir/$main > test_one.cpp \
    9599-e '/^\tRun( /d' \
    96100-e "s/.*This line is used by test_one.sh.*/\tRun( $fun, \"$fun\");/"
     101# --------------------------------------------------------------------------
     102# Create test_one.exe
    97103#
    98104# compiler flags
     
    118124#
    119125# compile command
    120 compile_command="g++ test_one.cpp -o test_one.exe
     126compile_command="@CMAKE_CXX_COMPILER@ test_one.cpp -o test_one.exe
    121127        $dir/$file $extra
    122128        -g
     
    125131        $library_flags
    126132"
    127 echo "$compile_command"
    128 $compile_command
     133echo "$compile_command 2> test_one.err"
     134if ! $compile_command 2> test_one.err
     135then
     136        tail test_one.err
     137        echo 'test_one.sh: see test_one.err'
     138        exit 1
     139fi
    129140# --------------------------------------------------------------------------
     141# LD_LIBRARY_PATH
    130142library_path='@PROJECT_BINARY_DIR@/cppad_lib'
    131143if ! echo $LD_LIBRARY_PATH | grep "$library_path"
     
    136148fi
    137149# --------------------------------------------------------------------------
     150# Execute the test
    138151echo_eval ./test_one.exe
     152# --------------------------------------------------------------------------
     153# Check for compiler warnings
     154cat << EOF > test_one.sed
     155# Lines that describe where error is
     156/^In file included from/d
     157/: note:/d
     158#
     159# Ipopt has sign conversion warnings
     160/\/coin\/.*-Wsign-conversion/d
     161#
     162# Adolc has multiple types of conversion warnings
     163/\/adolc\/.*-W[a-z-]*conversion/d
     164/\/adolc\/.*-Wshorten-64-to-32/d
     165#
     166# Lines describing the error begin with space
     167/^ /d
     168#
     169# Lines summarizing results
     170/^[0-9]* warnings generated/d
     171EOF
     172sed -f test_one.sed < test_one.err > test_one.warn
     173rm test_one.sed
     174if [ -s test_one.warn ]
     175then
     176        cat test_one.warn
     177        echo 'test_one.sh: unexpected warnings: see  test_one.warn, test_one.err'
     178        exit 1
     179fi
     180# --------------------------------------------------------------------------
     181echo 'test_one.sh: OK'
    139182exit 0
  • trunk/bin/trace.sh

    r3768 r4023  
    22# $Id$
    33# -----------------------------------------------------------------------------
    4 # CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     4# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-18 Bradley M. Bell
    55#
    66# CppAD is distributed under multiple licenses. This distribution is under
     
    1818name="$1"
    1919option="$2"
    20 file="cppad/local/$name.hpp"
     20file="cppad/local/sweep/$name.hpp"
    2121#
    2222ok='yes'
     
    3333then
    3434        echo 'usage: bin/trace.sh name (0|1)'
    35         echo '  where the file cppad/local/name.hpp has a defined TRACE option'
     35        echo 'name:e cppad/local/sweep/name.hpp defined *_TRACE as 0 or 1'
    3636        exit 1
    3737fi
  • trunk/configure

    r4021 r4023  
    11#! /bin/sh
    22# Guess values for system-dependent variables and create Makefiles.
    3 # Generated by GNU Autoconf 2.69 for cppad 20180730.
     3# Generated by GNU Autoconf 2.69 for cppad 20180824.
    44#
    55# Report bugs to <cppad@list.coin-or.org>.
     
    580580PACKAGE_NAME='cppad'
    581581PACKAGE_TARNAME='cppad'
    582 PACKAGE_VERSION='20180730'
    583 PACKAGE_STRING='cppad 20180730'
     582PACKAGE_VERSION='20180824'
     583PACKAGE_STRING='cppad 20180824'
    584584PACKAGE_BUGREPORT='cppad@list.coin-or.org'
    585585PACKAGE_URL=''
     
    594594eigen_prefix
    595595adolc_prefix
    596 cppad_SOURCE_DIR
    597 cppad_abs_includedir
    598 cppad_prefix
     596cppad_pkgconfig_requires_uninstalled
    599597cppad_pkgconfig_requires
    600598cppad_pkgconfig_libs
     599cppad_pkgconfig_libs_uninstalled
    601600cppad_pkgconfig_cflags
     601cppad_pkgconfig_cflags_uninstalled
    602602cppad_url
    603603cppad_version
     
    13751375  # This message is too long to be a string in the A/UX 3.1 sh.
    13761376  cat <<_ACEOF
    1377 \`configure' configures cppad 20180730 to adapt to many kinds of systems.
     1377\`configure' configures cppad 20180824 to adapt to many kinds of systems.
    13781378
    13791379Usage: $0 [OPTION]... [VAR=VALUE]...
     
    14451445if test -n "$ac_init_help"; then
    14461446  case $ac_init_help in
    1447      short | recursive ) echo "Configuration of cppad 20180730:";;
     1447     short | recursive ) echo "Configuration of cppad 20180824:";;
    14481448   esac
    14491449  cat <<\_ACEOF
     
    15791579if $ac_init_version; then
    15801580  cat <<\_ACEOF
    1581 cppad configure 20180730
     1581cppad configure 20180824
    15821582generated by GNU Autoconf 2.69
    15831583
     
    19521952running configure, to aid debugging if configure makes a mistake.
    19531953
    1954 It was created by cppad $as_me 20180730, which was
     1954It was created by cppad $as_me 20180824, which was
    19551955generated by GNU Autoconf 2.69.  Invocation command line was
    19561956
     
    28422842# Define the identity of the package.
    28432843 PACKAGE='cppad'
    2844  VERSION='20180730'
     2844 VERSION='20180824'
    28452845
    28462846
     
    71707170cppad_url="http://www.coin-or.org/CppAD"
    71717171
     7172cppad_pkgconfig_cflags_uninstalled="-I$abs_top_srcdir"
     7173
    71727174if test "$prefix" == "NONE" ; then
    7173         cppad_pkgconfig_cflags_value="-I$HOME/include"
    7174         cppad_pkgconfig_libs_value="-L$HOME/lib"
    7175 else
    7176         cppad_pkgconfig_cflags_value="-I$prefix/include"
    7177         cppad_pkgconfig_libs_value="-L$prefix/lib"
     7175        value="-I$HOME/include"
     7176else
     7177        value="-I$prefix/include"
    71787178fi
    71797179if test "$POSTFIX_DIR" != "" ; then
    7180         cppad_pkgconfig_cflags_value="$cppad_pkgconfig_cflags_value/$POSTFIX_DIR"
    7181         cppad_pkgconfig_libs_value="$cppad_pkgconfig_libs_value/$POSTFIX_DIR"
    7182 fi
     7180        value="$value/$POSTFIX_DIR"
     7181fi
     7182cppad_pkgconfig_cflags="$value"
     7183
    71837184if test "$IPOPT_DIR" == "" ; then
    7184         cppad_pkgconfig_libs_value=""
    7185         cppad_pkgconfig_requires_value=""
    7186 else
    7187         cppad_pkgconfig_libs_value="$cppad_pkgconfig_libs_value -lcppad_ipopt"
    7188         cppad_pkgconfig_requires_value="ipopt"
    7189 fi
    7190 cppad_pkgconfig_cflags="$cppad_pkgconfig_cflags_value"
    7191 
    7192 cppad_pkgconfig_libs="$cppad_pkgconfig_libs_value"
    7193 
    7194 cppad_pkgconfig_requires="$cppad_pkgconfig_requires_value"
    7195 
    7196 cppad_prefix="$prefix"
    7197 
    7198 cppad_abs_includedir="$includedir"
    7199 
    7200 cppad_SOURCE_DIR=${ABS_TOP_SRCDIR}
     7185        value=""
     7186else
     7187        value="-L$abs_top_builddir/cppad_ipopt/src -lcppad_ipopt"
     7188fi
     7189cppad_pkgconfig_libs_uninstalled="$value"
     7190
     7191if test "$prefix" == "NONE" ; then
     7192        value="-L$HOME/lib"
     7193else
     7194        value="-L$prefix/lib"
     7195fi
     7196if test "$POSTFIX_DIR" != "" ; then
     7197        value="$value/$POSTFIX_DIR"
     7198fi
     7199if test "$IPOPT_DIR" == "" ; then
     7200        value=""
     7201else
     7202        value="$value -lcppad_ipopt"
     7203fi
     7204cppad_pkgconfig_libs="$value"
     7205
     7206if test "$IPOPT_DIR" == "" ; then
     7207        value=""
     7208else
     7209        value="ipopt"
     7210fi
     7211cppad_pkgconfig_requires="$value"
     7212
     7213cppad_pkgconfig_requires_uninstalled="$value"
    72017214
    72027215adolc_prefix=${ADOLC_DIR}
     
    78567869# values after options handling.
    78577870ac_log="
    7858 This file was extended by cppad $as_me 20180730, which was
     7871This file was extended by cppad $as_me 20180824, which was
    78597872generated by GNU Autoconf 2.69.  Invocation command line was
    78607873
     
    79137926ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`"
    79147927ac_cs_version="\\
    7915 cppad config.status 20180730
     7928cppad config.status 20180824
    79167929configured by $0, generated by GNU Autoconf 2.69,
    79177930  with options \\"\$ac_cs_config\\"
  • trunk/configure.ac

    r4021 r4023  
    1212dnl Process this file with autoconf to produce a configure script.
    1313dnl   package   version              bug-report
    14 AC_INIT([cppad], [20180730], [cppad@list.coin-or.org])
     14AC_INIT([cppad], [20180824], [cppad@list.coin-or.org])
    1515AM_SILENT_RULES([yes])
    1616
     
    765765AC_MSG_RESULT([cppad_ipopt_nlp libraries: $CPPAD_IPOPT_LIBS])
    766766dnl --------------------------------------------------------------------------
    767 dnl Names set here so same cppad.pc.in works for both with cmake and autoconf.
    768 dnl (note that autoconf configuration does not allow for Colpack).
    769 dnl
     767dnl Set the values of the names needed by the files
     768dnl pkgconfig/cppad.pc.in and pkgconfig/cppad-uninstalled.pc.in.
     769dnl
     770dnl These settings are an attempt to be the same as in CMakeLists.txt
     771dnl and pkgconfig/CMakeLists.txt with the following restrictions:
     772dnl 1. The default prefix for the autoconf install is $HOME.
     773dnl 2. autoconf configuration does not allow for Colpack.
     774dnl 3. Assume that libraries are being installed in prefix/lib.
     775dnl 4. Only install pkgconfig files below prefix/lib (not in datadir).
     776dnl
     777dnl cppad_description
    770778AC_SUBST(cppad_description, "Differentiation of C++ Algorithms")
     779dnl
     780dnl cppad_version
    771781AC_SUBST(cppad_version, ${PACKAGE_VERSION} )
     782dnl
     783dnl cppad_url
    772784AC_SUBST(cppad_url, "http://www.coin-or.org/CppAD")
     785dnl
     786dnl cppad_pkgconfig_cflags_uninstalled
     787AC_SUBST(cppad_pkgconfig_cflags_uninstalled, "-I$abs_top_srcdir")
     788dnl
     789dnl cppad_pkgconfig_cflags
    773790if test "$prefix" == "NONE" ; then
    774         cppad_pkgconfig_cflags_value="-I$HOME/include"
    775         cppad_pkgconfig_libs_value="-L$HOME/lib"
    776 else
    777         cppad_pkgconfig_cflags_value="-I$prefix/include"
    778         cppad_pkgconfig_libs_value="-L$prefix/lib"
     791        value="-I$HOME/include"
     792else
     793        value="-I$prefix/include"
    779794fi
    780795if test "$POSTFIX_DIR" != "" ; then
    781         cppad_pkgconfig_cflags_value="$cppad_pkgconfig_cflags_value/$POSTFIX_DIR"
    782         cppad_pkgconfig_libs_value="$cppad_pkgconfig_libs_value/$POSTFIX_DIR"
    783 fi
     796        value="$value/$POSTFIX_DIR"
     797fi
     798AC_SUBST(cppad_pkgconfig_cflags, "$value")
     799dnl
     800dnl cppad_pkgconfig_libs_uninstalled
    784801if test "$IPOPT_DIR" == "" ; then
    785         cppad_pkgconfig_libs_value=""
    786         cppad_pkgconfig_requires_value=""
    787 else
    788         cppad_pkgconfig_libs_value="$cppad_pkgconfig_libs_value -lcppad_ipopt"
    789         cppad_pkgconfig_requires_value="ipopt"
    790 fi
    791 AC_SUBST(cppad_pkgconfig_cflags,   "$cppad_pkgconfig_cflags_value")
    792 AC_SUBST(cppad_pkgconfig_libs,     "$cppad_pkgconfig_libs_value")
    793 AC_SUBST(cppad_pkgconfig_requires, "$cppad_pkgconfig_requires_value")
    794 AC_SUBST(cppad_prefix,             "$prefix")
    795 AC_SUBST(cppad_abs_includedir,     "$includedir")
    796 dnl
    797 dnl names set here so cppad.pc-uninstalled works both with cmake and autoconf
    798 AC_SUBST(cppad_SOURCE_DIR,  ${ABS_TOP_SRCDIR} )
    799 dnl
     802        value=""
     803else
     804        value="-L$abs_top_builddir/cppad_ipopt/src -lcppad_ipopt"
     805fi
     806AC_SUBST(cppad_pkgconfig_libs_uninstalled, "$value")
     807dnl
     808dnl cppad_pkgconfig_libs
     809if test "$prefix" == "NONE" ; then
     810        value="-L$HOME/lib"
     811else
     812        value="-L$prefix/lib"
     813fi
     814if test "$POSTFIX_DIR" != "" ; then
     815        value="$value/$POSTFIX_DIR"
     816fi
     817if test "$IPOPT_DIR" == "" ; then
     818        value=""
     819else
     820        value="$value -lcppad_ipopt"
     821fi
     822AC_SUBST(cppad_pkgconfig_libs, "$value")
     823dnl
     824dnl cppad_pkgconfig_requires
     825dnl cppad_pkgconfig_requires_uninstalled
     826if test "$IPOPT_DIR" == "" ; then
     827        value=""
     828else
     829        value="ipopt"
     830fi
     831AC_SUBST(cppad_pkgconfig_requires, "$value")
     832AC_SUBST(cppad_pkgconfig_requires_uninstalled, "$value")
     833dnl
     834dnl -------------------------------------------------------------------------
    800835dnl names set here so */test_one.sh.in works both with cmake and autoconf
    801836dnl (no longer used ?)
  • trunk/cppad/core/abort_recording.hpp

    r3928 r4023  
    33
    44/* --------------------------------------------------------------------------
    5 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-17 Bradley M. Bell
     5CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-18 Bradley M. Bell
    66
    77CppAD is distributed under multiple licenses. This distribution is under
     
    5454        {       local::ADTape<Base>* tape = AD<Base>::tape_ptr();
    5555                if( tape != CPPAD_NULL )
    56                         AD<Base>::tape_manage(tape_manage_delete);
     56                        AD<Base>::tape_manage(delete_tape_manage);
    5757        }
    5858}
  • trunk/cppad/core/abs.hpp

    r4022 r4023  
    9191                return result;
    9292
    93         // check if operand is a constant paramerer
     93        // check if operand is a constant parameter
    9494        if( tape_id_ != tape->id_ )
    9595                return result;
    9696
    97         if( dynamic_ )
     97        if(ad_type_ == local::dyn_ad_type)
    9898        {       // dynamic paramter argument
    9999                result.taddr_   = tape->Rec_.put_dyn_par(
     
    101101                );
    102102                result.tape_id_  = tape_id_;
    103                 result.dynamic_  = true;
     103                result.ad_type_  = local::dyn_ad_type;
    104104        }
    105105        else
     
    116116                // make result a variable
    117117                result.tape_id_  = tape_id_;
    118                 result.dynamic_  = false;
     118                result.ad_type_  = local::var_ad_type;
    119119        }
    120120        return result;
  • trunk/cppad/core/abs_normal_fun.hpp

    r4022 r4023  
    288288
    289289# ifndef NDEBUG
    290 # define CPPAD_J_PAR_EQUAL_REC j_par = rec
     290# define CPPAD_J_PAR_EQUAL_REC j_par = (size_t) rec
    291291# else
    292292# define CPPAD_J_PAR_EQUAL_REC rec
     
    674674                        {       new_arg[3] = arg[3]; // parameter
    675675                        }
    676                         new_arg[2] = rec.PutTxt( play_.GetTxt( arg[2] ) );
    677                         new_arg[4] = rec.PutTxt( play_.GetTxt( arg[4] ) );
     676                        new_arg[2] = rec.PutTxt( play_.GetTxt(size_t(arg[2])) );
     677                        new_arg[4] = rec.PutTxt( play_.GetTxt(size_t(arg[4])) );
    678678                        //
    679679                        rec.PutArg(
     
    845845        // (x, u)
    846846        for(size_t j = 0; j < n; j++)
    847         {       g.ind_taddr_[j] = f2g_var[ ind_taddr_[j] ];
     847        {       g.ind_taddr_[j] = size_t( f2g_var[ ind_taddr_[j] ] );
    848848                CPPAD_ASSERT_UNKNOWN( g.ind_taddr_[j] == j + 1 );
    849849        }
    850850        for(size_t j = 0; j < s; j++)
    851         {       g.ind_taddr_[n + j] = f2g_var[ f_abs_res[j] ];
     851        {       g.ind_taddr_[n + j] = size_t( f2g_var[ f_abs_res[j] ] );
    852852                CPPAD_ASSERT_UNKNOWN( g.ind_taddr_[n + j] == n + j + 1 );
    853853        }
     
    858858        g.dep_taddr_.resize(m + s);
    859859        for(size_t i = 0; i < m; i++)
    860         {       g.dep_taddr_[i] = f2g_var[ dep_taddr_[i] ];
     860        {       g.dep_taddr_[i] = size_t( f2g_var[ dep_taddr_[i] ] );
    861861                CPPAD_ASSERT_UNKNOWN( g.dep_taddr_[i] < num_var );
    862862        }
    863863        for(size_t i = 0; i < s; i++)
    864         {       g.dep_taddr_[m + i] = f2g_var[ f_abs_arg[i] ];
     864        {       g.dep_taddr_[m + i] = size_t( f2g_var[ f_abs_arg[i] ] );
    865865                CPPAD_ASSERT_UNKNOWN( g.dep_taddr_[m + i] < num_var );
    866866        }
  • trunk/cppad/core/ad.hpp

    r4022 r4023  
    2020# include <cppad/local/op_code_dyn.hpp>
    2121# include <cppad/local/op_code.hpp>
     22# include <cppad/local/ad_type.hpp>
    2223# include <cppad/local/recorder.hpp>
    2324# include <cppad/local/player.hpp>
     
    2627namespace CppAD { // BEGIN_CPPAD_NAMESPACE
    2728
     29// tape_manage_enum
    2830typedef enum {
    29         tape_manage_new,
    30         tape_manage_delete
    31 } tape_manage_job;
     31        new_tape_manage,
     32        delete_tape_manage
     33}
     34tape_manage_enum;
    3235
    3336template <class Base>
     
    3538private :
    3639        // -----------------------------------------------------------------------
    37         // value_ corresponding to this object
     40        // Base type value for this object
    3841        Base value_;
    39 
    40         // Tape identifier corresponding to taddr
     42        //
     43        // tape for this object
    4144        tape_id_t tape_id_;
    42 
    43         // taddr_ in tape for this or dynamic parameter
     45        //
     46        // tape address for this object
     47        // (when tape_id is current tape for AD<Base>)
    4448        addr_t taddr_;
    45 
    46         // is this a dynamic parameter (or a variable)
    47         // when tape is current tape and taddr_ is non-zero.
    48         bool   dynamic_;
     49        //
     50        // sub-type for this object
     51        // (when tape_id is current tape for AD<Base>)
     52        local::ad_type_enum ad_type_;
    4953        // -----------------------------------------------------------------------
    5054
     
    7781        friend int  Integer   <Base> (const AD<Base>    &u);
    7882        friend AD   Var2Par   <Base> (const AD<Base>    &u);
     83        //
     84        friend unsigned short hash_code <Base> (const AD<Base> &u);
    7985        //
    8086        // power function
     
    271277
    272278private:
    273         //
    274         // Make this variable a parameter
    275         //
    276         void make_parameter(void)
    277         {       CPPAD_ASSERT_UNKNOWN( Variable(*this) );  // currently a var
    278                 tape_id_ = 0;
    279         }
    280         //
     279        // -----------------------------------------------------------------
    281280        // Make this parameter a new variable
    282         //
    283281        void make_variable(tape_id_t id,  addr_t taddr)
    284282        {       CPPAD_ASSERT_UNKNOWN( Parameter(*this) ); // currently a par
     
    287285                tape_id_ = id;
    288286                taddr_   = taddr;
    289                 dynamic_ = false;
     287                ad_type_ = local::var_ad_type;
    290288        }
    291289        // ---------------------------------------------------------------
     
    298296        inline static tape_id_t*            tape_id_ptr(size_t thread);
    299297        inline static local::ADTape<Base>** tape_handle(size_t thread);
    300         static local::ADTape<Base>*         tape_manage(tape_manage_job job);
     298        static local::ADTape<Base>*         tape_manage(tape_manage_enum job);
    301299        inline static local::ADTape<Base>*  tape_ptr(void);
    302300        inline static local::ADTape<Base>*  tape_ptr(tape_id_t tape_id);
  • trunk/cppad/core/ad_assign.hpp

    r4019 r4023  
    7979        tape_id_  = right.tape_id_;
    8080        taddr_    = right.taddr_;
    81         dynamic_  = right.dynamic_;
     81        ad_type_  = right.ad_type_;
    8282
    8383        return *this;
  • trunk/cppad/core/ad_ctor.hpp

    r4019 r4023  
    9292        tape_id_  = x.tape_id_;
    9393        taddr_    = x.taddr_;
    94         dynamic_  = x.dynmaic_;
     94        ad_type_  = x.ad_type_;
    9595
    9696        return;
     
    110110, tape_id_(0)
    111111, taddr_(0)
    112 , dynamic_(false)
     112, ad_type_(local::no_ad_type)
    113113{ }
    114114
     
    131131, tape_id_(0)
    132132, taddr_(0)
    133 , dynamic_(false)
     133, ad_type_(local::no_ad_type)
    134134{       // check that this is a parameter
    135135        CPPAD_ASSERT_UNKNOWN( Parameter(*this) );
     
    157157, tape_id_(0)
    158158, taddr_(0)
    159 , dynamic_(false)
     159, ad_type_(local::no_ad_type)
    160160{       // check that this is a parameter
    161161        CPPAD_ASSERT_UNKNOWN( Parameter(*this) );
     
    194194, tape_id_(0)
    195195, taddr_(0)
    196 , dynamic_(false)
     196, ad_type_(local::no_ad_type)
    197197{ }
    198198
  • trunk/cppad/core/add.hpp

    r4022 r4023  
    3737
    3838        // check if left and right are dynamic parameters
    39         bool dyn_left  = match_left  & left.dynamic_;
    40         bool dyn_right = match_right & right.dynamic_;
     39        bool dyn_left  = match_left  & (left.ad_type_ == local::dyn_ad_type);
     40        bool dyn_right = match_right & (right.ad_type_ == local::dyn_ad_type);
    4141
    4242        // check if left and right are variables
    43         bool var_left  = match_left  & (! left.dynamic_);
    44         bool var_right = match_right & (! right.dynamic_);
     43        bool var_left  = match_left  & (left.ad_type_ != local::dyn_ad_type);
     44        bool var_right = match_right & (right.ad_type_ != local::dyn_ad_type);
    4545
    4646        CPPAD_ASSERT_KNOWN(
     
    6060                        // make result a variable
    6161                        result.tape_id_ = tape_id;
     62                        result.ad_type_ = local::var_ad_type;
    6263                }
    63                 else if( IdenticalZero(right.value_) )
     64                else if( (! dyn_right) & IdenticalZero(right.value_) )
    6465                {       // result = variable + 0
    6566                        result.make_variable(left.tape_id_, left.taddr_);
     
    8081                        // make result a variable
    8182                        result.tape_id_ = tape_id;
     83                        result.ad_type_ = local::var_ad_type;
    8284                }
    8385        }
    8486        else if( var_right )
    85         {       if( IdenticalZero(left.value_) )
     87        {       if( (! dyn_left) & IdenticalZero(left.value_) )
    8688                {       // result = 0 + variable
    8789                        result.make_variable(right.tape_id_, right.taddr_);
     
    101103                        // make result a variable
    102104                        result.tape_id_ = tape_id;
     105                        result.ad_type_ = local::var_ad_type;
    103106                }
    104107        }
     
    116119                );
    117120                result.tape_id_ = tape_id;
    118                 result.dynamic_ = true;
     121                result.ad_type_ = local::dyn_ad_type;
    119122        }
    120123        return result;
  • trunk/cppad/core/add_eq.hpp

    r4022 r4023  
    3737
    3838        // check if left and right are dynamic parameters
    39 # ifndef NDEBUG
    40         bool dyn_left  = match_left  & dynamic_;
    41 # endif
    42         bool dyn_right = match_right & right.dynamic_;
     39        bool dyn_left  = match_left  & (ad_type_ == local::dyn_ad_type);
     40        bool dyn_right = match_right & (right.ad_type_ == local::dyn_ad_type);
    4341
    4442        // check if left and right are variables
    45         bool var_left  = match_left  & (! dynamic_);
    46         bool var_right = match_right & (! right.dynamic_);
     43        bool var_left  = match_left  & (ad_type_ != local::dyn_ad_type);
     44        bool var_right = match_right & (right.ad_type_ != local::dyn_ad_type);
    4745
    4846        CPPAD_ASSERT_KNOWN(
     
    6058                        // put operator in the tape
    6159                        taddr_ = tape->Rec_.PutOp(local::AddvvOp);
    62                         // make this a variable
     60                        // check that this is a variable
    6361                        CPPAD_ASSERT_UNKNOWN( tape_id_ == tape_id );
     62                        CPPAD_ASSERT_UNKNOWN( ad_type_ == local::var_ad_type);
    6463                }
    65                 else if( ! IdenticalZero( right.value_ ) )
     64                else if( dyn_right | (! IdenticalZero(right.value_) ) )
    6665                {       // this = variable  + parameter
    6766                        //      = parameter + variable
     
    7675                        // put operator in the tape
    7776                        taddr_ = tape->Rec_.PutOp(local::AddpvOp);
    78                         // make this a variable
     77                        // check that this is a variable
    7978                        CPPAD_ASSERT_UNKNOWN( tape_id_ == tape_id );
     79                        CPPAD_ASSERT_UNKNOWN( ad_type_ == local::var_ad_type);
    8080                }
    8181        }
    8282        else if( var_right  )
    83         {       if( IdenticalZero(left) )
     83        {       if( (! dyn_left) & IdenticalZero(left) )
    8484                {       // this = 0 + right
    8585                        make_variable(right.tape_id_, right.taddr_);
     
    9191
    9292                        // put operand addresses in tape
    93                         CPPAD_ASSERT_KNOWN( ! dyn_left,
    94                                 "binary +=: left operand is a dynamic parameter"
    95                         );
    96                         addr_t p = tape->Rec_.put_con_par(left);
     93                        addr_t p = taddr_;
     94                        if( ! dyn_left )
     95                                p = tape->Rec_.put_con_par(left);
    9796                        tape->Rec_.PutArg(p, right.taddr_);
     97
    9898                        // put operator in the tape
    9999                        taddr_ = tape->Rec_.PutOp(local::AddpvOp);
     100
    100101                        // make this a variable
    101102                        tape_id_ = tape_id;
     103                        ad_type_ = local::var_ad_type;
    102104                }
    103105        }
    104         else
    105         {       CPPAD_ASSERT_KNOWN( ! (dyn_left | dyn_right) ,
    106                 "binary +=: one operand is a dynamic parameter and other not a variable"
     106        else if( dyn_left | dyn_right )
     107        {       addr_t arg0 = taddr_;
     108                addr_t arg1 = right.taddr_;
     109                if( ! dyn_left )
     110                        arg0 = tape->Rec_.put_con_par(left);
     111                if( ! dyn_right )
     112                        arg1 = tape->Rec_.put_con_par(right.value_);
     113                //
     114                // parameters with a dynamic parameter results
     115                taddr_ = tape->Rec_.put_dyn_par(
     116                                value_, local::add_dyn, arg0, arg1
    107117                );
     118                tape_id_ = tape_id;
     119                ad_type_ = local::dyn_ad_type;
    108120        }
    109121        return *this;
  • trunk/cppad/core/atomic_base.hpp

    r4022 r4023  
    547547
    548548                // we need to record this operation if
    549                 // any of the eleemnts of ay are variables,
     549                // any of the elemnts of ay are variables,
    550550                record_operation |= vy[i];
    551551        }
     
    601601                        {       ay[i].taddr_    = tape->Rec_.PutOp(local::UsrrvOp);
    602602                                ay[i].tape_id_  = tape_id;
     603                                ay[i].ad_type_  = local::var_ad_type;
    603604                        }
    604605                        else
  • trunk/cppad/core/azmul.hpp

    r4022 r4023  
    111111
    112112        // check if x and y are dynamic parameters
    113         bool dyn_x  = match_x  & x.dynamic_;
    114         bool dyn_y  = match_y  & y.dynamic_;
     113        bool dyn_x  = match_x  & (x.ad_type_ == local::dyn_ad_type);
     114        bool dyn_y  = match_y  & (y.ad_type_ == local::dyn_ad_type);
    115115
    116116        // check if x and y are variables
    117         bool var_x  = match_x  & (! x.dynamic_);
    118         bool var_y  = match_y  & (! y.dynamic_);
     117        bool var_x  = match_x  & (x.ad_type_ != local::dyn_ad_type);
     118        bool var_y  = match_y  & (y.ad_type_ != local::dyn_ad_type);
    119119
    120120        CPPAD_ASSERT_KNOWN(
     
    136136                        // make result a variable
    137137                        result.tape_id_ = tape_id;
     138                        result.ad_type_ = local::var_ad_type;
    138139                }
    139140                else if( IdenticalZero( y.value_ ) )
     
    160161                        // make result a variable
    161162                        result.tape_id_ = tape_id;
     163                        result.ad_type_ = local::var_ad_type;
    162164                }
    163165        }
     
    186188                        // make result a variable
    187189                        result.tape_id_ = tape_id;
     190                        result.ad_type_ = local::var_ad_type;
    188191                }
    189192        }
     
    201204                );
    202205                result.tape_id_ = tape_id;
    203                 result.dynamic_ = true;
     206                result.ad_type_ = local::dyn_ad_type;
    204207        }
    205208        return result;
  • trunk/cppad/core/check_for_nan.hpp

    r3987 r4023  
    33
    44/* --------------------------------------------------------------------------
    5 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-17 Bradley M. Bell
     5CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-18 Bradley M. Bell
    66
    77CppAD is distributed under multiple licenses. This distribution is under
     
    182182void put_check_for_nan(const CppAD::vector<Base>& vec, std::string& file_name)
    183183{
    184         size_t char_size       = sizeof(Base) * vec.size();
     184        size_t char_size = sizeof(Base) * vec.size();
    185185        const char* char_ptr   = reinterpret_cast<const char*>( vec.data() );
    186186# if CPPAD_HAS_MKSTEMP
     
    222222void get_check_for_nan(CppAD::vector<Base>& vec, const std::string& file_name)
    223223{       //
    224         size_t n = vec.size();
    225         size_t char_size = sizeof(Base) * n;
     224        std::streamsize char_size = std::streamsize( sizeof(Base) * vec.size() );
    226225        char* char_ptr   = reinterpret_cast<char*>( vec.data() );
    227226        //
  • trunk/cppad/core/checkpoint.hpp

    r4007 r4023  
    14291429
    14301430        \param optimize [in]
    1431 l       should the operation sequence corresponding to the algo be optimized.
     1431        should the operation sequence corresponding to the algo be optimized.
    14321432        The default value is true, but it is
    14331433        sometimes useful to use false for debugging purposes.
     
    14441444        ) :
    14451445        atomic_base<Base>(name  , sparsity)        ,
    1446         f_( omp_get_max_threads() )                ,
    1447         jac_sparse_set_( omp_get_max_threads() )   ,
    1448         jac_sparse_bool_( omp_get_max_threads() )  ,
    1449         hes_sparse_set_( omp_get_max_threads() )   ,
    1450         hes_sparse_bool_( omp_get_max_threads() )
     1446        f_( size_t( omp_get_max_threads() ) )                ,
     1447        jac_sparse_set_( size_t( omp_get_max_threads() ) )   ,
     1448        jac_sparse_bool_( size_t( omp_get_max_threads() ) )  ,
     1449        hes_sparse_set_( size_t( omp_get_max_threads() ) )   ,
     1450        hes_sparse_bool_( size_t( omp_get_max_threads() ) )
    14511451        {
    14521452                CheckSimpleVector< CppAD::AD<Base> , ADVector>();
  • trunk/cppad/core/compare.hpp

    r4022 r4023  
    143143
    144144        // check if left and right are dynamic parameters
    145         bool dyn_left  = match_left  & left.dynamic_;
    146         bool dyn_right = match_right & right.dynamic_;
     145        bool dyn_left  = match_left  & (left.ad_type_ == local::dyn_ad_type);
     146        bool dyn_right = match_right & (right.ad_type_ == local::dyn_ad_type);
    147147
    148148        // check if left and right are variables
    149         bool var_left  = match_left  & (! left.dynamic_);
    150         bool var_right = match_right & (! right.dynamic_);
     149        bool var_left  = match_left  & (left.ad_type_ != local::dyn_ad_type);
     150        bool var_right = match_right & (right.ad_type_ != local::dyn_ad_type);
    151151
    152152        CPPAD_ASSERT_KNOWN(
     
    239239
    240240        // check if left and right are dynamic parameters
    241         bool dyn_left  = match_left  & left.dynamic_;
    242         bool dyn_right = match_right & right.dynamic_;
     241        bool dyn_left  = match_left  & (left.ad_type_ == local::dyn_ad_type);
     242        bool dyn_right = match_right & (right.ad_type_ == local::dyn_ad_type);
    243243
    244244        // check if left and right are variables
    245         bool var_left  = match_left  & (! left.dynamic_);
    246         bool var_right = match_right & (! right.dynamic_);
     245        bool var_left  = match_left  & (left.ad_type_ != local::dyn_ad_type);
     246        bool var_right = match_right & (right.ad_type_ != local::dyn_ad_type);
    247247
    248248        CPPAD_ASSERT_KNOWN(
     
    335335
    336336        // check if left and right are dynamic parameters
    337         bool dyn_left  = match_left  & left.dynamic_;
    338         bool dyn_right = match_right & right.dynamic_;
     337        bool dyn_left  = match_left  & (left.ad_type_ == local::dyn_ad_type);
     338        bool dyn_right = match_right & (right.ad_type_ == local::dyn_ad_type);
    339339
    340340        // check if left and right are variables
    341         bool var_left  = match_left  & (! left.dynamic_);
    342         bool var_right = match_right & (! right.dynamic_);
     341        bool var_left  = match_left  & (left.ad_type_ != local::dyn_ad_type);
     342        bool var_right = match_right & (right.ad_type_ != local::dyn_ad_type);
    343343
    344344        CPPAD_ASSERT_KNOWN(
     
    431431
    432432        // check if left and right are dynamic parameters
    433         bool dyn_left  = match_left  & left.dynamic_;
    434         bool dyn_right = match_right & right.dynamic_;
     433        bool dyn_left  = match_left  & (left.ad_type_ == local::dyn_ad_type);
     434        bool dyn_right = match_right & (right.ad_type_ == local::dyn_ad_type);
    435435
    436436        // check if left and right are variables
    437         bool var_left  = match_left  & (! left.dynamic_);
    438         bool var_right = match_right & (! right.dynamic_);
     437        bool var_left  = match_left  & (left.ad_type_ != local::dyn_ad_type);
     438        bool var_right = match_right & (right.ad_type_ != local::dyn_ad_type);
    439439
    440440        CPPAD_ASSERT_KNOWN(
     
    527527
    528528        // check if left and right are dynamic parameters
    529         bool dyn_left  = match_left  & left.dynamic_;
    530         bool dyn_right = match_right & right.dynamic_;
     529        bool dyn_left  = match_left  & (left.ad_type_ == local::dyn_ad_type);
     530        bool dyn_right = match_right & (right.ad_type_ == local::dyn_ad_type);
    531531
    532532        // check if left and right are variables
    533         bool var_left  = match_left  & (! left.dynamic_);
    534         bool var_right = match_right & (! right.dynamic_);
     533        bool var_left  = match_left  & (left.ad_type_ != local::dyn_ad_type);
     534        bool var_right = match_right & (right.ad_type_ != local::dyn_ad_type);
    535535
    536536        CPPAD_ASSERT_KNOWN(
     
    611611
    612612        // check if left and right are dynamic parameters
    613         bool dyn_left  = match_left  & left.dynamic_;
    614         bool dyn_right = match_right & right.dynamic_;
     613        bool dyn_left  = match_left  & (left.ad_type_ == local::dyn_ad_type);
     614        bool dyn_right = match_right & (right.ad_type_ == local::dyn_ad_type);
    615615
    616616        // check if left and right are variables
    617         bool var_left  = match_left  & (! left.dynamic_);
    618         bool var_right = match_right & (! right.dynamic_);
     617        bool var_left  = match_left  & (left.ad_type_ != local::dyn_ad_type);
     618        bool var_right = match_right & (right.ad_type_ != local::dyn_ad_type);
    619619
    620620        CPPAD_ASSERT_KNOWN(
  • trunk/cppad/core/con_dyn_var.hpp

    r4022 r4023  
    115115        template <class Base>
    116116        bool Dynamic(const AD<Base> &x)
    117         {       if( (x.tape_id_ == 0) | (! x.dynamic_ ) )
     117        {       if( (x.tape_id_ == 0) | (x.ad_type_ != local::dyn_ad_type) )
    118118                        return false;
    119119                //
     
    129129        template <class Base>
    130130        bool Parameter(const AD<Base> &x)
    131         {       if( (x.tape_id_ == 0) | x.dynamic_ )
     131        {       if( (x.tape_id_ == 0) | (x.ad_type_ == local::dyn_ad_type) )
    132132                        return true;
    133133                //
     
    148148        template <class Base>
    149149        bool Variable(const AD<Base> &x)
    150         {       if( (x.tape_id_ == 0) | x.dynamic_ )
     150        {       if( (x.tape_id_ == 0) | (x.ad_type_ != local::var_ad_type) )
    151151                        return false;
    152152                //
  • trunk/cppad/core/dependent.hpp

    r4022 r4023  
    238238        size_t   m = y.size();
    239239        size_t   n = tape->size_independent_;
    240         size_t   i, j;
    241         size_t   y_taddr;
    242240
    243241        // check ADvector is Simple Vector class with AD<Base> elements
     
    255253        dep_parameter_.resize(m);
    256254        dep_taddr_.resize(m);
    257         for(i = 0; i < m; i++)
     255        for(size_t i = 0; i < m; i++)
    258256        {       dep_parameter_[i] = CppAD::Parameter(y[i]);
     257                addr_t y_taddr;
    259258                if( dep_parameter_[i] )
    260259                {       // make a tape copy of dependent variables that are parameters,
     
    264263
    265264                CPPAD_ASSERT_UNKNOWN( y_taddr > 0 );
    266                 dep_taddr_[i] = y_taddr;
     265                dep_taddr_[i] = size_t( y_taddr );
    267266        }
    268267
     
    302301        ind_taddr_.resize(n);
    303302        CPPAD_ASSERT_UNKNOWN( n < num_var_tape_);
    304         for(j = 0; j < n; j++)
     303        for(size_t j = 0; j < n; j++)
    305304        {       CPPAD_ASSERT_UNKNOWN( play_.GetOp(j+1) == local::InvOp );
    306305                ind_taddr_[j] = j+1;
     
    323322
    324323        // now we can delete the tape
    325         AD<Base>::tape_manage(tape_manage_delete);
     324        AD<Base>::tape_manage(delete_tape_manage);
    326325
    327326        // total number of varables in this recording
  • trunk/cppad/core/discrete.hpp

    r4019 r4023  
    259259        AD<Base> ad(const AD<Base> &ax) const
    260260        {
    261 # ifndef NDEBUG
    262                 if( Dynamic(ax) )
    263                 {       std::string msg = name_
    264                         + ": argument to this discrete function is a dynamic parameter";
    265                         CPPAD_ASSERT_KNOWN(false, msg.c_str());
    266                 }
    267 # endif
     261                CPPAD_ASSERT_KNOWN(
     262                        size_t( std::numeric_limits<addr_t>::max() ) >= index_,
     263                        "discrete: cppad_tape_addr_type maximum not large enough"
     264                );
     265                //
    268266                AD<Base> ay;
    269267                ay.value_ = f_(ax.value_);
    270                 if( Variable(ax) )
    271                 {       local::ADTape<Base> *tape = ax.tape_this();
     268                //
     269                // check if there is a recording in progress
     270                local::ADTape<Base>* tape = AD<Base>::tape_ptr();
     271                if( tape == CPPAD_NULL )
     272                        return ay;
     273                //
     274                // check if argument is a constant parameter
     275                if( ax.tape_id_ != tape->id_ )
     276                        return ay;
     277                //
     278                if( ax.ad_type_ == local::dyn_ad_type )
     279                {
     280                        // tape dynamic paramter operation
     281                        ay.taddr_   = tape->Rec_.put_dyn_par(
     282                                ay.value_, local::dis_dyn, addr_t(index_), ax.taddr_
     283                        );
     284                        ay.tape_id_  = ax.tape_id_;
     285                        ay.ad_type_  = local::dyn_ad_type;
     286
     287                        // make result a dynamic parameter
     288                        ay.tape_id_    = tape->id_;
     289                        ay.ad_type_    = local::dyn_ad_type;
     290
     291                        CPPAD_ASSERT_UNKNOWN( Dynamic(ay) );
     292                }
     293                else if( ax.ad_type_ == local::var_ad_type )
     294                {
    272295                        CPPAD_ASSERT_UNKNOWN( local::NumRes(local::DisOp) == 1 );
    273296                        CPPAD_ASSERT_UNKNOWN( local::NumArg(local::DisOp) == 2 );
     
    283306                        // make result a variable
    284307                        ay.tape_id_    = tape->id_;
     308                        ay.ad_type_    = local::var_ad_type;
    285309
    286310                        CPPAD_ASSERT_UNKNOWN( Variable(ay) );
     311                }
     312                else
     313                {       // other types not yet being used and should have this tape id
     314                        CPPAD_ASSERT_UNKNOWN(false);
    287315                }
    288316                return ay;
  • trunk/cppad/core/div.hpp

    r4022 r4023  
    3737
    3838        // check if left and right are dynamic parameters
    39         bool dyn_left  = match_left  & left.dynamic_;
    40         bool dyn_right = match_right & right.dynamic_;
     39        bool dyn_left  = match_left  & (left.ad_type_ == local::dyn_ad_type);
     40        bool dyn_right = match_right & (right.ad_type_ == local::dyn_ad_type);
    4141
    4242        // check if left and right are variables
    43         bool var_left  = match_left  & (! left.dynamic_);
    44         bool var_right = match_right & (! right.dynamic_);
     43        bool var_left  = match_left  & (left.ad_type_ != local::dyn_ad_type);
     44        bool var_right = match_right & (right.ad_type_ != local::dyn_ad_type);
    4545
    4646        CPPAD_ASSERT_KNOWN(
     
    6060                        // make result a variable
    6161                        result.tape_id_ = tape_id;
     62                        result.ad_type_ = local::var_ad_type;
    6263                }
    63                 else if( IdenticalOne(right.value_) )
     64                else if( (! dyn_right) & IdenticalOne(right.value_) )
    6465                {       // result = variable / 1
    6566                        result.make_variable(left.tape_id_, left.taddr_);
     
    7980                        // make result a variable
    8081                        result.tape_id_ = tape_id;
     82                        result.ad_type_ = local::var_ad_type;
    8183                }
    8284        }
    8385        else if( var_right )
    84         {       if( IdenticalZero(left.value_) )
     86        {       if( (! dyn_left) & IdenticalZero(left.value_) )
    8587                {       // result = 0 / variable
    8688                }
     
    99101                        // make result a variable
    100102                        result.tape_id_ = tape_id;
     103                        result.ad_type_ = local::var_ad_type;
    101104                }
    102105        }
     
    114117                );
    115118                result.tape_id_ = tape_id;
    116                 result.dynamic_ = true;
     119                result.ad_type_ = local::dyn_ad_type;
    117120        }
    118121        return result;
  • trunk/cppad/core/div_eq.hpp

    r4022 r4023  
    3737
    3838        // check if left and right are dynamic parameters
    39 # ifndef NDEBUG
    40         bool dyn_left  = match_left  & dynamic_;
    41 # endif
    42         bool dyn_right = match_right & right.dynamic_;
     39        bool dyn_left  = match_left  & (ad_type_ == local::dyn_ad_type);
     40        bool dyn_right = match_right & (right.ad_type_ == local::dyn_ad_type);
    4341
    4442        // check if left and right are variables
    45         bool var_left  = match_left  & (! dynamic_);
    46         bool var_right = match_right & (! right.dynamic_);
     43        bool var_left  = match_left  & (ad_type_ != local::dyn_ad_type);
     44        bool var_right = match_right & (right.ad_type_ != local::dyn_ad_type);
    4745
    4846        CPPAD_ASSERT_KNOWN(
     
    6058                        // put operator in the tape
    6159                        taddr_ = tape->Rec_.PutOp(local::DivvvOp);
    62                         // make this a variable
     60                        // check that this is a variable
    6361                        CPPAD_ASSERT_UNKNOWN( tape_id_ == tape_id );
     62                        CPPAD_ASSERT_UNKNOWN( ad_type_ == local::var_ad_type);
    6463                }
    65                 else if( IdenticalOne( right.value_ ) )
     64                else if( (! dyn_right) & IdenticalOne(right.value_) )
    6665                {       // this = variable * 1
    6766                }
     
    7877                        // put operator in the tape
    7978                        taddr_ = tape->Rec_.PutOp(local::DivvpOp);
    80                         // make this a variable
     79                        // check that this is a variable
    8180                        CPPAD_ASSERT_UNKNOWN( tape_id_ == tape_id );
     81                        CPPAD_ASSERT_UNKNOWN( ad_type_ == local::var_ad_type);
    8282                }
    8383        }
    8484        else if( var_right  )
    85         {       if( IdenticalZero(left) )
     85        {       if( (! dyn_left) & IdenticalZero(left) )
    8686                {       // this = 0 / variable
    8787                }
     
    9292
    9393                        // put operand addresses in tape
    94                         CPPAD_ASSERT_KNOWN( ! dyn_left,
    95                                 "binary /=: left operand is a dynamic parameter"
    96                         );
    97                         addr_t p = tape->Rec_.put_con_par(left);
     94                        addr_t p = taddr_;
     95                        if( ! dyn_left )
     96                                p = tape->Rec_.put_con_par(left);
    9897                        tape->Rec_.PutArg(p, right.taddr_);
     98
    9999                        // put operator in the tape
    100100                        taddr_ = tape->Rec_.PutOp(local::DivpvOp);
     101
    101102                        // make this a variable
    102103                        tape_id_ = tape_id;
     104                        ad_type_ = local::var_ad_type;
    103105                }
    104106        }
    105         else
    106         {       CPPAD_ASSERT_KNOWN( ! (dyn_left | dyn_right) ,
    107                 "binary /=: one operand is a dynamic parameter and other not a variable"
     107        else if( dyn_left | dyn_right )
     108        {       addr_t arg0 = taddr_;
     109                addr_t arg1 = right.taddr_;
     110                if( ! dyn_left )
     111                        arg0 = tape->Rec_.put_con_par(left);
     112                if( ! dyn_right )
     113                        arg1 = tape->Rec_.put_con_par(right.value_);
     114                //
     115                // parameters with a dynamic parameter results
     116                taddr_ = tape->Rec_.put_dyn_par(
     117                                value_, local::div_dyn, arg0, arg1
    108118                );
     119                tape_id_ = tape_id;
     120                ad_type_ = local::dyn_ad_type;
    109121        }
    110122        return *this;
  • trunk/cppad/core/hash_code.hpp

    r3845 r4023  
    1 // $Id$
    21# ifndef CPPAD_CORE_HASH_CODE_HPP
    32# define CPPAD_CORE_HASH_CODE_HPP
    43
    54/* --------------------------------------------------------------------------
    6 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
     5CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-18 Bradley M. Bell
    76
    87CppAD is distributed under multiple licenses. This distribution is under
     
    4645{       return local::local_hash_code(value); }
    4746
     47/*!
     48hash code for an AD<Base> object.
     49
     50\tparam Base
     51is the base type for this AD value.
     52
     53\param u
     54the AD value that we are generating a hash code for.
     55
     56\return
     57is a hash code that is between zero and CPPAD_HASH_TABLE_SIZE - 1.
     58*/
     59template <class Base>
     60unsigned short hash_code(const AD<Base>& u)
     61{       size_t code = hash_code(u.value_);
     62        code       += size_t(u.taddr_);
     63        code       += size_t(u.ad_type_ == local::dyn_ad_type);
     64        return (unsigned short)(code % CPPAD_HASH_TABLE_SIZE);
     65}
     66
    4867} // END_CPPAD_NAMESPACE
    4968
  • trunk/cppad/core/independent.hpp

    r4022 r4023  
    7777$head abort_op_index$$
    7878If this argument is present,
    79 it specifies the operator index at which the execution is be aborted
     79it specifies the operator index at which the execution will aborted
    8080by calling the CppAD $cref/error handler/ErrorHandler/$$.
    8181When this error handler leads to an assert, the user
    8282can inspect the call stack to see the source code corresponding to
    8383this operator index; see
    84 $cref/purpose/compare_change/op_index/Purpose/$$.
    85 No abort will occur if $icode abort_op_index$$ is zero,
    86 if $cref/NDEBUG/Faq/Speed/NDEBUG/$$ is defined.
     84$cref/purpose/compare_change/op_index/Purpose/$$ for $icode op_index$$
     85and $cref/NDEBUG/Faq/Speed/NDEBUG/$$.
     86No abort will occur if $icode abort_op_index$$ is zero.
    8787If this argument is not present, the default value zero is used
    8888for $icode abort_index$$.
     
    194194                "AD<Base>::abort_recording() would abort this previous recording."
    195195        );
    196         local::ADTape<Base>* tape = ADBase::tape_manage(tape_manage_new);
     196        local::ADTape<Base>* tape = ADBase::tape_manage(new_tape_manage);
    197197        tape->Independent(x, abort_op_index, record_compare, dynamic);
    198198}
  • trunk/cppad/core/integer.hpp

    r4019 r4023  
    102102        CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION
    103103        int Integer(const AD<Base> &x)
    104         {       CPPAD_ASSERT_KNOWN( ! Dynamic(x),
    105                         "Integer: argument is a dynamic parameter"
    106                 );
    107                 return Integer(x.value_);
    108         }
     104        {       return Integer(x.value_); }
    109105
    110106        template <class Base>
  • trunk/cppad/core/mul.hpp

    r4022 r4023  
    3737
    3838        // check if left and right are dynamic parameters
    39         bool dyn_left  = match_left  & left.dynamic_;
    40         bool dyn_right = match_right & right.dynamic_;
     39        bool dyn_left  = match_left  & (left.ad_type_ == local::dyn_ad_type);
     40        bool dyn_right = match_right & (right.ad_type_ == local::dyn_ad_type);
    4141
    4242        // check if left and right are variables
    43         bool var_left  = match_left  & (! left.dynamic_);
    44         bool var_right = match_right & (! right.dynamic_);
     43        bool var_left  = match_left  & (left.ad_type_ != local::dyn_ad_type);
     44        bool var_right = match_right & (right.ad_type_ != local::dyn_ad_type);
    4545
    4646        CPPAD_ASSERT_KNOWN(
     
    6060                        // make result a variable
    6161                        result.tape_id_ = tape_id;
     62                        result.ad_type_ = local::var_ad_type;
    6263                }
    63                 else if( IdenticalZero(right.value_) )
     64                else if( (! dyn_right) & IdenticalZero(right.value_) )
    6465                {       // result = variable * 0
    6566                }
    66                 else if( IdenticalOne(right.value_) )
     67                else if( (! dyn_right) & IdenticalOne(right.value_) )
    6768                {       // result = variable * 1
    6869                        result.make_variable(left.tape_id_, left.taddr_);
     
    8283                        // make result a variable
    8384                        result.tape_id_ = tape_id;
     85                        result.ad_type_ = local::var_ad_type;
    8486                }
    8587        }
    8688        else if( var_right )
    87         {       if( IdenticalZero(left.value_) )
     89        {       if( (! dyn_left) & IdenticalZero(left.value_) )
    8890                {       // result = 0 * variable
    8991                }
    90                 else if( IdenticalOne(left.value_) )
     92                else if( (! dyn_left) & IdenticalOne(left.value_) )
    9193                {       // result = 1 * variable
    9294                        result.make_variable(right.tape_id_, right.taddr_);
     
    106108                        // make result a variable
    107109                        result.tape_id_ = tape_id;
     110                        result.ad_type_ = local::var_ad_type;
    108111                }
    109112        }
     
    121124                );
    122125                result.tape_id_ = tape_id;
    123                 result.dynamic_ = true;
     126                result.ad_type_ = local::dyn_ad_type;
    124127        }
    125128        return result;
  • trunk/cppad/core/mul_eq.hpp

    r4022 r4023  
    3737
    3838        // check if left and right are dynamic parameters
    39 # ifndef NDEBUG
    40         bool dyn_left  = match_left  & dynamic_;
    41 # endif
    42         bool dyn_right = match_right & right.dynamic_;
     39        bool dyn_left  = match_left  & (ad_type_ == local::dyn_ad_type);
     40        bool dyn_right = match_right & (right.ad_type_ == local::dyn_ad_type);
    4341
    4442        // check if left and right are variables
    45         bool var_left  = match_left  & (! dynamic_);
    46         bool var_right = match_right & (! right.dynamic_);
     43        bool var_left  = match_left  & (ad_type_ != local::dyn_ad_type);
     44        bool var_right = match_right & (right.ad_type_ != local::dyn_ad_type);
    4745
    4846        CPPAD_ASSERT_KNOWN(
     
    6058                        // put operator in the tape
    6159                        taddr_ = tape->Rec_.PutOp(local::MulvvOp);
    62                         // make this a variable
     60                        // check that this is a variable
    6361                        CPPAD_ASSERT_UNKNOWN( tape_id_ == tape_id );
     62                        CPPAD_ASSERT_UNKNOWN( ad_type_ == local::var_ad_type);
    6463                }
    65                 else if( IdenticalOne( right.value_ ) )
     64                else if( (! dyn_right) & IdenticalOne(right.value_) )
    6665                {       // this = variable * 1
    6766                }
    68                 else if( IdenticalZero( right.value_ ) )
     67                else if( (! dyn_right) & IdenticalZero(right.value_) )
    6968                {       // this = variable * 0
    70                         make_parameter();
     69                        tape_id_ = 0; // not in current tape
    7170                }
    7271                else
     
    8382                        // put operator in the tape
    8483                        taddr_ = tape->Rec_.PutOp(local::MulpvOp);
    85                         // make this a variable
     84                        // check that this is a variable
    8685                        CPPAD_ASSERT_UNKNOWN( tape_id_ == tape_id );
     86                        CPPAD_ASSERT_UNKNOWN( ad_type_ == local::var_ad_type);
    8787                }
    8888        }
    8989        else if( var_right  )
    90         {       if( IdenticalZero(left) )
     90        {       if( (! dyn_left) & IdenticalZero(left) )
    9191                {       // this = 0 * right
    9292                }
    93                 else if( IdenticalOne(left) )
     93                else if( (! dyn_left) & IdenticalOne(left) )
    9494                {       // this = 1 * right
    9595                        make_variable(right.tape_id_, right.taddr_);
     
    101101
    102102                        // put operand addresses in tape
    103                         CPPAD_ASSERT_KNOWN( ! dyn_left,
    104                                 "binary *=: left operand is a dynamic parameter"
    105                         );
    106                         addr_t p = tape->Rec_.put_con_par(left);
     103                        addr_t p = taddr_;
     104                        if( ! dyn_left )
     105                                p = tape->Rec_.put_con_par(left);
    107106                        tape->Rec_.PutArg(p, right.taddr_);
     107
    108108                        // put operator in the tape
    109109                        taddr_ = tape->Rec_.PutOp(local::MulpvOp);
     110
    110111                        // make this a variable
    111112                        tape_id_ = tape_id;
     113                        ad_type_ = local::var_ad_type;
    112114                }
    113115        }
    114         else
    115         {       CPPAD_ASSERT_KNOWN( ! (dyn_left | dyn_right) ,
    116                 "binary *=: one operand is a dynamic parameter and other not a variable"
     116        else if( dyn_left | dyn_right )
     117        {       addr_t arg0 = taddr_;
     118                addr_t arg1 = right.taddr_;
     119                if( ! dyn_left )
     120                        arg0 = tape->Rec_.put_con_par(left);
     121                if( ! dyn_right )
     122                        arg1 = tape->Rec_.put_con_par(right.value_);
     123                //
     124                // parameters with a dynamic parameter results
     125                taddr_ = tape->Rec_.put_dyn_par(
     126                                value_, local::mul_dyn, arg0, arg1
    117127                );
     128                tape_id_ = tape_id;
     129                ad_type_ = local::dyn_ad_type;
    118130        }
    119131        return *this;
  • trunk/cppad/core/new_dynamic.hpp

    r4022 r4023  
    103103void ADFun<Base>::new_dynamic(const VectorBase& dynamic)
    104104{       using local::pod_vector;
    105         // num_dynamic_ind
    106         size_t num_dynamic_ind = play_.num_dynamic_ind();
    107         CPPAD_ASSERT_UNKNOWN( size_t( dynamic.size() ) == num_dynamic_ind );
    108         CPPAD_ASSERT_UNKNOWN( num_dynamic_ind <= play_.num_par_rec() );
    109 
     105        CPPAD_ASSERT_KNOWN(
     106                size_t( dynamic.size() ) == play_.num_dynamic_ind() ,
     107                "f.new_dynamic: dynamic.size() different from corresponding "
     108                "call to Independent"
     109        );
    110110        // check VectorBase is Simple Vector class with Base elements
    111111        CheckSimpleVector<Base, VectorBase>();
     
    118118        const pod_vector<addr_t>&     dyn_ind2par_ind ( play_.dyn_ind2par_ind() );
    119119
    120         // set the independent dynamic parameters
    121         for(size_t j = 0; j < num_dynamic_ind; ++j)
    122         {       CPPAD_ASSERT_UNKNOWN( dyn_par_is[j] );
    123                 CPPAD_ASSERT_UNKNOWN(
    124                         local::op_code_dyn( dyn_par_op[j] ) == local::ind_dyn
    125                 );
    126                 all_par_vec[j] = dynamic[j];
    127         }
    128 
    129120        // set the dependent dynamic parameters
    130121        local::sweep::dynamic(
    131                 num_dynamic_ind ,
    132122                all_par_vec     ,
     123                dynamic         ,
    133124                dyn_par_is      ,
    134125                dyn_ind2par_ind ,
  • trunk/cppad/core/optimize.hpp

    r4019 r4023  
    313313# ifndef NDEBUG
    314314        if( check_zero_order )
    315         {
     315        {       std::stringstream s;
     316                //
    316317                // zero order forward calculation using new operation sequence
    317                 check = Forward(0, x);
     318                check = Forward(0, x, s);
    318319
    319320                // check results
  • trunk/cppad/core/pow.hpp

    r4022 r4023  
    116116
    117117        // check if x and y are dynamic parameters
    118         bool dyn_x  = match_x  & x.dynamic_;
    119         bool dyn_y  = match_y  & y.dynamic_;
     118        bool dyn_x  = match_x  & (x.ad_type_ == local::dyn_ad_type);
     119        bool dyn_y  = match_y  & (y.ad_type_ == local::dyn_ad_type);
    120120
    121121        // check if x and y are variables
    122         bool var_x  = match_x  & (! x.dynamic_);
    123         bool var_y  = match_y  & (! y.dynamic_);
     122        bool var_x  = match_x  & (x.ad_type_ != local::dyn_ad_type);
     123        bool var_y  = match_y  & (y.ad_type_ != local::dyn_ad_type);
    124124
    125125        CPPAD_ASSERT_KNOWN(
     
    141141                        // make result a variable
    142142                        result.tape_id_ = tape_id;
     143                        result.ad_type_ = local::var_ad_type;
    143144                }
    144145                else if( IdenticalZero( y.value_ ) )
     
    161162                        // make result a variable
    162163                        result.tape_id_ = tape_id;
     164                        result.ad_type_ = local::var_ad_type;
    163165                }
    164166        }
     
    183185                        // make result a variable
    184186                        result.tape_id_ = tape_id;
     187                        result.ad_type_ = local::var_ad_type;
    185188                }
    186189        }
     
    198201                );
    199202                result.tape_id_ = tape_id;
    200                 result.dynamic_ = true;
     203                result.ad_type_ = local::dyn_ad_type;
    201204        }
    202205        else
  • trunk/cppad/core/print_for.hpp

    r4022 r4023  
    3131$icode%f%.Forward(0, %x%)
    3232%$$
    33 $codei%PrintFor(%before%, %var%)
    34 %$$
    35 $codei%PrintFor(%pos%, %before%, %var%, %after%)
     33$codei%PrintFor(%before%, %value%)
     34%$$
     35$codei%PrintFor(%pos%, %before%, %value%, %after%)
    3636%$$
    3737
     
    7272This text is written to $code std::cout$$ before $icode var$$.
    7373
    74 $head var$$
    75 The argument $icode var$$ has one of the following prototypes
     74$head value$$
     75The argument $icode value$$ has one of the following prototypes
    7676$codei%
    7777        const AD<%Base%>&               %var%
    7878        const VecAD<%Base%>::reference& %var%
    7979%$$
    80 The value of $icode var$$, that corresponds to $icode x$$,
     80The value of $icode value$$, that corresponds to $icode x$$,
    8181is written to $code std::cout$$ during the execution of
    8282$codei%
    8383        %f%.Forward(0, %x%)
    8484%$$
    85 Note that $icode var$$ may be a
     85Note that $icode value$$ may be a
    8686$cref/variable/glossary/Variable/$$ or
    8787$cref/parameter/glossary/Parameter/$$.
    88 (A parameters value does not depend on the value of
    89 the independent variable vector $icode x$$.)
     88If a parameter is
     89$cref/dynamic/glossary/Parameter/Dynamic/$$ its value
     90will depend on the previous call to $cref new_dynamic$$.
    9091
    9192$head after$$
  • trunk/cppad/core/sign.hpp

    r4022 r4023  
    8080                return result;
    8181
    82         // check if operand is a constant paramerer
     82        // check if operand is a constant parameter
    8383        if( tape_id_ != tape->id_ )
    8484                return result;
    8585
    86         if( dynamic_ )
     86        if(ad_type_ == local::dyn_ad_type)
    8787        {       // dynamic paramter argument
    8888                result.taddr_   = tape->Rec_.put_dyn_par(
     
    9090                );
    9191                result.tape_id_  = tape_id_;
    92                 result.dynamic_  = true;
     92                result.ad_type_  = local::dyn_ad_type;
    9393        }
    9494        else
     
    105105                // make result a variable
    106106                result.tape_id_ = tape->id_;
    107                 result.dynamic_ = false;
     107                result.ad_type_ = local::var_ad_type;
    108108        }
    109109        return result;
  • trunk/cppad/core/std_math_98.hpp

    r4022 r4023  
    509509            return result;                                        \
    510510                                                                  \
    511         if( dynamic_ )                                            \
     511        if(ad_type_ == local::dyn_ad_type)                        \
    512512        {   result.taddr_ = tape->Rec_.put_dyn_par(               \
    513513                result.value_, local::Name##_dyn, taddr_          \
    514514            );                                                    \
    515515            result.tape_id_ = tape_id_;                           \
    516             result.dynamic_ = true;                               \
     516            result.ad_type_ = local::dyn_ad_type;                 \
    517517        }                                                         \
    518518        else                                                      \
     
    521521            result.taddr_    = tape->Rec_.PutOp(Op);              \
    522522            result.tape_id_  = tape->id_;                         \
    523                         result.dynamic_  = false;                             \
     523            result.ad_type_  = local::var_ad_type;                \
    524524        }                                                         \
    525525        return result;                                            \
     
    572572                        return result;
    573573
    574                 // check if operand is a constant paramerer
     574                // check if operand is a constant parameter
    575575                if( tape_id_ != tape->id_ )
    576576                        return result;
    577577
    578                 if( dynamic_ )
     578                if(ad_type_ == local::dyn_ad_type)
    579579                {       // dynamic paramter argument
    580580                        result.taddr_   = tape->Rec_.put_dyn_par(
     
    582582                        );
    583583                        result.tape_id_  = tape_id_;
    584                         result.dynamic_  = true;
     584                        result.ad_type_  = local::dyn_ad_type;
    585585                }
    586586                else
     
    603603                        result.taddr_   = tape->Rec_.PutOp(local::ErfOp);
    604604                        result.tape_id_ = tape->id_;
    605                         result.dynamic_ = false;
     605                        result.ad_type_ = local::var_ad_type;
    606606                }
    607607                return result;
  • trunk/cppad/core/sub.hpp

    r4022 r4023  
    3737
    3838        // check if left and right are dynamic parameters
    39         bool dyn_left  = match_left  & left.dynamic_;
    40         bool dyn_right = match_right & right.dynamic_;
     39        bool dyn_left  = match_left  & (left.ad_type_ == local::dyn_ad_type);
     40        bool dyn_right = match_right & (right.ad_type_ == local::dyn_ad_type);
    4141
    4242        // check if left and right are variables
    43         bool var_left  = match_left  & (! left.dynamic_);
    44         bool var_right = match_right & (! right.dynamic_);
     43        bool var_left  = match_left  & (left.ad_type_ != local::dyn_ad_type);
     44        bool var_right = match_right & (right.ad_type_ != local::dyn_ad_type);
    4545
    4646
     
    6161                        // make result a variable
    6262                        result.tape_id_ = tape_id;
     63                        result.ad_type_ = local::var_ad_type;
    6364                }
    64                 else if( IdenticalZero(right.value_) )
     65                else if( (! dyn_right) & IdenticalZero(right.value_) )
    6566                {       // result = variable - 0
    6667                        result.make_variable(left.tape_id_, left.taddr_);
     
    8081                        // make result a variable
    8182                        result.tape_id_ = tape_id;
     83                        result.ad_type_ = local::var_ad_type;
    8284                }
    8385        }
     
    9698                // make result a variable
    9799                result.tape_id_ = tape_id;
     100                result.ad_type_ = local::var_ad_type;
    98101        }
    99102        else if( dyn_left | dyn_right )
     
    110113                );
    111114                result.tape_id_ = tape_id;
    112                 result.dynamic_ = true;
     115                result.ad_type_ = local::dyn_ad_type;
    113116        }
    114117        return result;
  • trunk/cppad/core/sub_eq.hpp

    r4022 r4023  
    3737
    3838        // check if left and right are dynamic parameters
    39 # ifndef NDEBUG
    40         bool dyn_left  = match_left  & dynamic_;
    41 # endif
    42         bool dyn_right = match_right & right.dynamic_;
     39        bool dyn_left  = match_left  & (ad_type_ == local::dyn_ad_type);
     40        bool dyn_right = match_right & (right.ad_type_ == local::dyn_ad_type);
    4341
    4442        // check if left and right are variables
    45         bool var_left  = match_left  & (! dynamic_);
    46         bool var_right = match_right & (! right.dynamic_);
     43        bool var_left  = match_left  & (ad_type_ != local::dyn_ad_type);
     44        bool var_right = match_right & (right.ad_type_ != local::dyn_ad_type);
    4745
    4846        CPPAD_ASSERT_KNOWN(
     
    6058                        // put operator in the tape
    6159                        taddr_ = tape->Rec_.PutOp(local::SubvvOp);
    62                         // make this a variable
     60                        // check that this is a variable
    6361                        CPPAD_ASSERT_UNKNOWN( tape_id_ == tape_id );
     62                        CPPAD_ASSERT_UNKNOWN( ad_type_ == local::var_ad_type);
    6463                }
    65                 else if( IdenticalZero( right.value_ ) )
     64                else if( (! dyn_right) & IdenticalZero(right.value_) )
    6665                {       // this = variable - 0
    6766                }
     
    7877                        // put operator in the tape
    7978                        taddr_ = tape->Rec_.PutOp(local::SubvpOp);
    80                         // make this a variable
     79                        // check that this is a variable
    8180                        CPPAD_ASSERT_UNKNOWN( tape_id_ == tape_id );
     81                        CPPAD_ASSERT_UNKNOWN( ad_type_ == local::var_ad_type);
    8282                }
    8383        }
     
    8888
    8989                // put operand addresses in tape
    90                 CPPAD_ASSERT_KNOWN( ! dyn_left,
    91                         "binary -=: left operand is a dynamic parameter"
    92                 );
    93                 addr_t p = tape->Rec_.put_con_par(left);
     90                addr_t p = taddr_;
     91                if( ! dyn_left )
     92                        p = tape->Rec_.put_con_par(left);
    9493                tape->Rec_.PutArg(p, right.taddr_);
     94
    9595                // put operator in the tape
    9696                taddr_ = tape->Rec_.PutOp(local::SubpvOp);
     97
    9798                // make this a variable
    9899                tape_id_ = tape_id;
     100                ad_type_ = local::var_ad_type;
    99101        }
    100         else
    101         {       CPPAD_ASSERT_KNOWN( ! (dyn_left | dyn_right) ,
    102                 "binary -=: one operand is a dynamic parameter and other not a variable"
     102        else if( dyn_left | dyn_right )
     103        {       addr_t arg0 = taddr_;
     104                addr_t arg1 = right.taddr_;
     105                if( ! dyn_left )
     106                        arg0 = tape->Rec_.put_con_par(left);
     107                if( ! dyn_right )
     108                        arg1 = tape->Rec_.put_con_par(right.value_);
     109                //
     110                // parameters with a dynamic parameter results
     111                taddr_ = tape->Rec_.put_dyn_par(
     112                                value_, local::sub_dyn, arg0, arg1
    103113                );
     114                tape_id_ = tape_id;
     115                ad_type_ = local::dyn_ad_type;
    104116        }
    105117        return *this;
  • trunk/cppad/core/subgraph_reverse.hpp

    r4016 r4023  
    434434        dw.resize(n * q);
    435435        for(size_t c = 0; c < col_size; ++c)
    436         {       size_t i_op = subgraph[c + 1];
     436        {       size_t i_op = size_t( subgraph[c + 1] );
    437437                CPPAD_ASSERT_UNKNOWN( play_.GetOp(i_op) == local::InvOp );
    438438                //
  • trunk/cppad/core/tape_link.hpp

    r4019 r4023  
    158158old one.
    159159
    160 - \c tape_manage_new :
     160- \c new_tape_manage :
    161161Creates and a new tape.
    162162It is assumed that there is no tape recording AD<Base> operations
    163163for this thread when \c tape_manage is called.
    164164
    165 - \c tape_manage_delete :
     165- \c delete_tape_manage :
    166166It is assumed that there is a tape recording AD<Base> operations
    167167for this thread when \c tape_manage is called.
     
    171171
    172172\return
    173 - <tt>job == tape_manage_new</tt>: a pointer to the new tape is returned.
    174 - <tt>job == tape_manage_delete</tt>: the value \c CPPAD_NULL is returned.
    175 */
    176 template <class Base>
    177 local::ADTape<Base>*  AD<Base>::tape_manage(tape_manage_job job)
     173- <tt>job == new_tape_manage</tt>: a pointer to the new tape is returned.
     174- <tt>job == delete_tape_manage</tt>: the value \c CPPAD_NULL is returned.
     175*/
     176template <class Base>
     177local::ADTape<Base>*  AD<Base>::tape_manage(tape_manage_enum job)
    178178{
    179179        CPPAD_ASSERT_UNKNOWN(
    180                 job == tape_manage_new || job == tape_manage_delete
     180                job == new_tape_manage || job == delete_tape_manage
    181181        );
    182182        // thread, tape_id, and tape for this call
     
    187187
    188188        // -----------------------------------------------------------------------
    189         // tape_manage_new
    190         if( job == tape_manage_new )
     189        // new_tape_manage
     190        if( job == new_tape_manage )
    191191        {
    192192                // tape for this thread must be null at the start
     
    214214        }
    215215        // -----------------------------------------------------------------------
    216         // tape_manage_delete
    217         if( job == tape_manage_delete )
     216        // delete_tape_manage
     217        if( job == delete_tape_manage )
    218218        {       // delete this tape
    219219                CPPAD_ASSERT_UNKNOWN( *tape_h  != CPPAD_NULL );
  • trunk/cppad/core/testvector.hpp

    r3941 r4023  
    1 // $Id$
    21# ifndef CPPAD_CORE_TESTVECTOR_HPP
    32# define CPPAD_CORE_TESTVECTOR_HPP
    43
    54/* --------------------------------------------------------------------------
    6 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-17 Bradley M. Bell
     5CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-18 Bradley M. Bell
    76
    87CppAD is distributed under multiple licenses. This distribution is under
     
    3635$codei%CPPAD_TESTVECTOR(%Scalar%)
    3736%$$
    38 
    39 $head Purpose$$
    40 Many of the CppAD $cref/examples/example/$$ and tests use
    41 the $code CPPAD_TESTVECTOR$$ template class to pass information to CppAD.
    42 This is not a true template class because it's syntax uses
    43 $codei%(%Scalar%)%$$ instead of $codei%<%Scalar%>%$$.
    44 This enables us to use
    45 $codei%
    46         Eigen::Matrix<%Scalar%, Eigen::Dynamic, 1>
    47 %$$
    48 as one of the possible cases for this 'template class'.
    4937
    5038$head Choice$$
     
    10795many of its examples and tests.
    10896
    109 $head Eigen Vectors$$
     97$head eigen_vector$$
    11098If in the cmake command
    11199you specify $icode cppad_testvector$$ to be $code eigen$$,
     
    116104# if CPPAD_EIGENVECTOR
    117105# include <cppad/example/cppad_eigen.hpp>
    118 # define CPPAD_TESTVECTOR(Scalar) Eigen::Matrix< Scalar , Eigen::Dynamic, 1>
     106# define CPPAD_TESTVECTOR(Scalar) eigen_vector< Scalar >
    119107# endif
    120108/* %$$
     109see $cref/eigen_vector/cppad_eigen.hpp/eigen_vector/$$.
    121110In this case CppAD will use the Eigen vector
    122111for many of its examples and tests.
  • trunk/cppad/core/unary_minus.hpp

    r4019 r4023  
    8585{       // 2DO: make a more efficient by adding unary minus to op_code.h (some day)
    8686        //
    87         CPPAD_ASSERT_KNOWN( ! Dynamic(*this),
    88                 "unary - cannot operate on a dynamic parameter"
    89         );
    90         //
    9187        AD<Base> result(0);
    9288        result  -= *this;
  • trunk/cppad/example/cppad_eigen.hpp

    r3972 r4023  
    22# define CPPAD_EXAMPLE_CPPAD_EIGEN_HPP
    33/* --------------------------------------------------------------------------
    4 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-17 Bradley M. Bell
     4CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-18 Bradley M. Bell
    55
    66CppAD is distributed under multiple licenses. This distribution is under
     
    1111Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
    1212-------------------------------------------------------------------------- */
     13// cppad.hpp gets included at the end
     14# define EIGEN_MATRIXBASE_PLUGIN <cppad/example/eigen_plugin.hpp>
     15# include <Eigen/Core>
     16
    1317/*
    1418$begin cppad_eigen.hpp$$
     
    4246
    4347$head Syntax$$
    44 $codei%# include <cppad/example/cppad_eigen.hpp>%$$
     48$codei%# include <cppad/example/cppad_eigen.hpp>
     49%$$
    4550$children%
    4651        cppad/example/eigen_plugin.hpp%
     
    6368
    6469$head Include Files$$
    65 The file $code cppad_eigen.hpp$$ includes both
    66 $code <cppad/cppad.hpp>$$ and $code <Eigen/Core>$$.
    67 The file $cref eigen_plugin.hpp$$ defines $code value_type$$
    68 in the Eigen matrix class so its vectors are
    69 $cref/simple vectors/SimpleVector/$$
    70 (not necessary for eigen-3.3.3 and later).
     70The file $code <Eigen/Core>$$ is included before
     71these definitions and $code <cppad/cppad.hpp>$$ is included after.
     72
     73$head CppAD Declarations$$
     74First declare some items that are defined by cppad.hpp:
    7175$srccode%cpp% */
    72 # define EIGEN_MATRIXBASE_PLUGIN <cppad/example/eigen_plugin.hpp>
    73 # include <Eigen/Core>
    74 # include <cppad/cppad.hpp>
     76namespace CppAD {
     77        // AD<Base>
     78        template <class Base> class AD;
     79        // numeric_limits<Float>
     80        template <class Float>  class numeric_limits;
     81}
    7582/* %$$
    7683$head Eigen NumTraits$$
     
    149156
    150157/* %$$
     158$head eigen_vector$$
     159The class $code eigen_vector$$ is a wrapper for Eigen column vectors
     160so that they are $cref/simple vectors/SimpleVector/$$.
     161To be specific, it converts $code Eigen::Index$$ arguments and
     162return values to $code size_t$$.
     163$srccode%cpp% */
     164template <class Scalar>
     165class eigen_vector : public Eigen::Matrix<Scalar, Eigen::Dynamic, 1> {
     166private:
     167        // base_class
     168        typedef Eigen::Matrix<Scalar, Eigen::Dynamic, 1> base_class;
     169public:
     170        // constructor
     171        eigen_vector(size_t n) : base_class( Eigen::Index(n) )
     172        { }
     173        eigen_vector(void) : base_class()
     174        { }
     175        // operator[]
     176        Scalar& operator[](size_t i)
     177        {       return base_class::operator[]( Eigen::Index(i) ); }
     178        const Scalar& operator[](size_t i) const
     179        {       return base_class::operator[]( Eigen::Index(i) ); }
     180        // size
     181        size_t size(void) const
     182        {       return size_t( base_class::size() ); }
     183        // resize
     184        void resize(size_t n)
     185        {       base_class::resize( Eigen::Index(n) ); }
     186};
     187//
     188# include <cppad/cppad.hpp>
     189/* %$$
    151190$end
    152191*/
  • trunk/cppad/example/eigen_cholesky.hpp

    r3941 r4023  
    1 // $Id$
    21# ifndef CPPAD_EXAMPLE_EIGEN_CHOLESKY_HPP
    32# define CPPAD_EXAMPLE_EIGEN_CHOLESKY_HPP
    43
    54/* --------------------------------------------------------------------------
    6 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-17 Bradley M. Bell
     5CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-18 Bradley M. Bell
    76
    87CppAD is distributed under multiple licenses. This distribution is under
     
    8887                for(size_t i = 0; i < nr; i++)
    8988                {       for(size_t j = 0; j <= i; j++)
    90                                 packed_arg[index++] = arg(i, j);
     89                                packed_arg[index++] = arg( long(i), long(j) );
    9190                }
    9291                assert( index == nx );
     
    9998                // -------------------------------------------------------------------
    10099                // unpack result matrix L
    101                 ad_matrix result = ad_matrix::Zero(nr, nr);
     100                ad_matrix result = ad_matrix::Zero( long(nr), long(nr) );
    102101                index = 0;
    103102                for(size_t i = 0; i < nr; i++)
    104103                {       for(size_t j = 0; j <= i; j++)
    105                                 result(i, j) = packed_result[index++];
     104                                result( long(i), long(j) ) = packed_result[index++];
    106105                }
    107106                return result;
     
    156155                        //
    157156                        for(size_t k = 0; k < n_order; k++)
    158                         {       f_arg_[k].resize(nr, nr);
    159                                 f_result_[k].resize(nr, nr);
     157                        {       f_arg_[k].resize( long(nr), long(nr) );
     158                                f_result_[k].resize( long(nr), long(nr) );
    160159                        }
    161160                }
     
    165164                {       size_t index = 1;
    166165                        // unpack arg values for this order
    167                         for(size_t i = 0; i < nr; i++)
    168                         {       for(size_t j = 0; j <= i; j++)
     166                        for(long i = 0; i < long(nr); i++)
     167                        {       for(long j = 0; j <= i; j++)
    169168                                {       f_arg_[k](i, j) = tx[ index * n_order + k ];
    170169                                        f_arg_[k](j, i) = f_arg_[k](i, j);
     
    190189                        temp   = L_0.transpose().template solve<Eigen::OnTheRight>(temp);
    191190                        // divide the diagonal by 2
    192                         for(size_t i = 0; i < nr; i++)
     191                        for(long i = 0; i < long(nr); i++)
    193192                                temp(i, i) /= scalar(2.0);
    194193                        // L_k = L_0 * low[ L_0^{-1} * (A_k - B_k) * L_0^{-T} ]
     
    200199                for(size_t k = 0; k < n_order; k++)
    201200                {       size_t index = 0;
    202                         for(size_t i = 0; i < nr; i++)
    203                         {       for(size_t j = 0; j <= i; j++)
     201                        for(long i = 0; i < long(nr); i++)
     202                        {       for(long j = 0; j <= i; j++)
    204203                                {       ty[ index * n_order + k ] = f_result_[k](i, j);
    205204                                        index++;
     
    262261                        //
    263262                        for(size_t k = 0; k < n_order; k++)
    264                         {       r_arg_[k].resize(nr, nr);
    265                                 r_result_[k].resize(nr, nr);
     263                        {       r_arg_[k].resize( long(nr), long(nr) );
     264                                r_result_[k].resize( long(nr), long(nr) );
    266265                        }
    267266                }
     
    271270                {       size_t index = 1;
    272271                        // unpack arg values for this order
    273                         for(size_t i = 0; i < nr; i++)
    274                         {       for(size_t j = 0; j <= i; j++)
     272                        for(long i = 0; i < long(nr); i++)
     273                        {       for(long j = 0; j <= i; j++)
    275274                                {       f_arg_[k](i, j) = tx[ index * n_order + k ];
    276275                                        f_arg_[k](j, i) = f_arg_[k](i, j);
     
    282281                // unpack py into r_result_
    283282                for(size_t k = 0; k < n_order; k++)
    284                 {       r_result_[k] = matrix::Zero(nr, nr);
     283                {       r_result_[k] = matrix::Zero( long(nr), long(nr) );
    285284                        size_t index = 0;
    286                         for(size_t i = 0; i < nr; i++)
    287                         {       for(size_t j = 0; j <= i; j++)
     285                        for(long i = 0; i < long(nr); i++)
     286                        {       for(long j = 0; j <= i; j++)
    288287                                {       r_result_[k](i, j) = py[ index * n_order + k ];
    289288                                        index++;
     
    294293                // initialize r_arg_ as zero
    295294                for(size_t k = 0; k < n_order; k++)
    296                         r_arg_[k]   = matrix::Zero(nr, nr);
     295                        r_arg_[k]   = matrix::Zero( long(nr), long(nr) );
    297296                // -------------------------------------------------------------------
    298297                // matrix reverse mode calculation
     
    306305                        //
    307306                        //low[ L_0^T * bar{L}_k ]
    308                         for(size_t i = 0; i < nr; i++)
     307                        for(long i = 0; i < long(nr); i++)
    309308                                tmp1(i, i) /= scalar(2.0);
    310309                        matrix tmp2 = tmp1.template triangularView<Eigen::Lower>();
     
    338337                // M_0 = L_0^{-T} * low[ L_0^T * bar{L}_0 ]^{T} L_0^{-1}
    339338                matrix M_0 = L_0.transpose() * r_result_[0];
    340                 for(size_t i = 0; i < nr; i++)
     339                for(long i = 0; i < long(nr); i++)
    341340                        M_0(i, i) /= scalar(2.0);
    342341                M_0 = M_0.template triangularView<Eigen::Lower>();
     
    352351                        px[ index * n_order + k ] = 0.0;
    353352                        index++;
    354                         for(size_t i = 0; i < nr; i++)
    355                         {       for(size_t j = 0; j < i; j++)
     353                        for(long i = 0; i < long(nr); i++)
     354                        {       for(long j = 0; j < i; j++)
    356355                                {       px[ index * n_order + k ] = 2.0 * r_arg_[k](i, j);
    357356                                        index++;
  • trunk/cppad/example/eigen_mat_inv.hpp

    r3941 r4023  
    1 // $Id$
    21# ifndef CPPAD_EXAMPLE_EIGEN_MAT_INV_HPP
    32# define CPPAD_EXAMPLE_EIGEN_MAT_INV_HPP
    43
    54/* --------------------------------------------------------------------------
    6 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-17 Bradley M. Bell
     5CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-18 Bradley M. Bell
    76
    87CppAD is distributed under multiple licenses. This distribution is under
     
    247246                        //
    248247                        for(size_t k = 0; k < n_order; k++)
    249                         {       f_arg_[k].resize(nr, nr);
    250                                 f_result_[k].resize(nr, nr);
     248                        {       f_arg_[k].resize( long(nr), long(nr) );
     249                                f_result_[k].resize( long(nr), long(nr) );
    251250                        }
    252251                }
     
    265264                for(size_t k = 1; k < n_order; k++)
    266265                {       // initialize sum
    267                         matrix f_sum = matrix::Zero(nr, nr);
     266                        matrix f_sum = matrix::Zero( long(nr), long(nr) );
    268267                        // compute sum
    269268                        for(size_t ell = 1; ell <= k; ell++)
     
    332331                        //
    333332                        for(size_t k = 0; k < n_order; k++)
    334                         {       r_arg_[k].resize(nr, nr);
    335                                 r_result_[k].resize(nr, nr);
     333                        {       r_arg_[k].resize( long(nr), long(nr) );
     334                                r_result_[k].resize( long(nr), long(nr) );
    336335                        }
    337336                }
     
    352351                // initialize r_arg_ as zero
    353352                for(size_t k = 0; k < n_order; k++)
    354                         r_arg_[k]   = matrix::Zero(nr, nr);
     353                        r_arg_[k]   = matrix::Zero( long(nr), long(nr) );
    355354                // -------------------------------------------------------------------
    356355                // matrix reverse mode calculation
  • trunk/cppad/example/eigen_mat_mul.hpp

    r3970 r4023  
    33
    44/* --------------------------------------------------------------------------
    5 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-17 Bradley M. Bell
     5CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-18 Bradley M. Bell
    66
    77CppAD is distributed under multiple licenses. This distribution is under
     
    245245                        //
    246246                        for(size_t k = 0; k < n_order; k++)
    247                         {       f_left_[k].resize(nr_left, n_middle);
    248                                 f_right_[k].resize(n_middle, nc_right);
    249                                 f_result_[k].resize(nr_left, nc_right);
     247                        {       f_left_[k].resize( long(nr_left), long(n_middle) );
     248                                f_right_[k].resize( long(n_middle), long(nc_right) );
     249                                f_result_[k].resize( long(nr_left), long(nc_right) );
    250250                        }
    251251                }
     
    266266                for(size_t k = 0; k < n_order; k++)
    267267                {       // result[k] = sum_ell left[ell] * right[k-ell]
    268                         f_result_[k] = matrix::Zero(nr_left, nc_right);
     268                        f_result_[k] = matrix::Zero( long(nr_left), long(nc_right) );
    269269                        for(size_t ell = 0; ell <= k; ell++)
    270270                                f_result_[k] += f_left_[ell] * f_right_[k-ell];
     
    292292                                        size_t index   = 3 + i * n_middle + ell;
    293293                                        bool var_left  = vx[index];
    294                                         bool nz_left   = var_left | (f_left_[0](i, ell) != zero);
     294                                        bool nz_left   = var_left |
     295                                                 (f_left_[0]( long(i), long(ell) ) != zero);
    295296                                        // right information
    296297                                        index          = 3 + n_left + ell * nc_right + j;
    297298                                        bool var_right = vx[index];
    298                                         bool nz_right  = var_right | (f_right_[0](ell, j) != zero);
     299                                        bool nz_right  = var_right |
     300                                                 (f_right_[0]( long(ell), long(j) ) != zero);
    299301                                        // effect of result
    300302                                        var |= var_left & nz_right;
     
    358360                        //
    359361                        for(size_t k = 0; k < n_order; k++)
    360                         {       r_left_[k].resize(nr_left, n_middle);
    361                                 r_right_[k].resize(n_middle, nc_right);
    362                                 r_result_[k].resize(nr_left, nc_right);
     362                        {       r_left_[k].resize( long(nr_left), long(n_middle) );
     363                                r_right_[k].resize( long(n_middle), long(nc_right) );
     364                                r_result_[k].resize( long(nr_left), long(nc_right) );
    363365                        }
    364366                }
     
    383385                // initialize r_left_ and r_right_ as zero
    384386                for(size_t k = 0; k < n_order; k++)
    385                 {       r_left_[k]   = matrix::Zero(nr_left, n_middle);
    386                         r_right_[k]  = matrix::Zero(n_middle, nc_right);
     387                {       r_left_[k]   = matrix::Zero( long(nr_left), long(n_middle) );
     388                        r_right_[k]  = matrix::Zero( long(n_middle), long(nc_right) );
    387389                }
    388390                // -------------------------------------------------------------------
  • trunk/cppad/local/ad_tape.hpp

    r4022 r4023  
    202202size_t ADTape<Base>::AddVec(size_t length, const pod_vector_maybe<Base>& data)
    203203{       CPPAD_ASSERT_UNKNOWN( length > 0 );
    204         size_t i;
    205         size_t value_index;
    206204
    207205        // store the length in VecInd
    208         size_t start = Rec_.PutVecInd(length);
     206        addr_t start = Rec_.PutVecInd( addr_t(length) );
    209207
    210208        // store indices of the values in VecInd
    211         for(i = 0; i < length; i++)
     209        for(size_t i = 0; i < length; i++)
    212210        {
    213                 value_index = Rec_.put_con_par( data[i] );
     211                addr_t value_index = Rec_.put_con_par( data[i] );
    214212                Rec_.PutVecInd( value_index );
    215213        }
    216214
    217215        // return the taddr of the length (where the vector starts)
    218         return start;
     216        return size_t(start);
    219217}
    220218
  • trunk/cppad/local/add_op.hpp

    r3865 r4023  
    1 // $Id$
    21# ifndef CPPAD_LOCAL_ADD_OP_HPP
    32# define CPPAD_LOCAL_ADD_OP_HPP
    43
    54/* --------------------------------------------------------------------------
    6 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-17 Bradley M. Bell
     5CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-18 Bradley M. Bell
    76
    87CppAD is distributed under multiple licenses. This distribution is under
     
    5251
    5352        // Taylor coefficients corresponding to arguments and result
    54         Base* x = taylor + arg[0] * cap_order;
    55         Base* y = taylor + arg[1] * cap_order;
     53        Base* x = taylor + size_t(arg[0]) * cap_order;
     54        Base* y = taylor + size_t(arg[1]) * cap_order;
    5655        Base* z = taylor + i_z    * cap_order;
    5756
     
    9190        // Taylor coefficients corresponding to arguments and result
    9291        size_t num_taylor_per_var = (cap_order-1) * r + 1;
    93         Base* x = taylor + arg[0] * num_taylor_per_var;
    94         Base* y = taylor + arg[1] * num_taylor_per_var;
     92        Base* x = taylor + size_t(arg[0]) * num_taylor_per_var;
     93        Base* y = taylor + size_t(arg[1]) * num_taylor_per_var;
    9594        Base* z = taylor +    i_z * num_taylor_per_var;
    9695
     
    127126
    128127        // Taylor coefficients corresponding to arguments and result
    129         Base* x = taylor + arg[0] * cap_order;
    130         Base* y = taylor + arg[1] * cap_order;
     128        Base* x = taylor + size_t(arg[0]) * cap_order;
     129        Base* y = taylor + size_t(arg[1]) * cap_order;
    131130        Base* z = taylor + i_z    * cap_order;
    132131
     
    166165
    167166        // Partial derivatives corresponding to arguments and result
    168         Base* px = partial + arg[0] * nc_partial;
    169         Base* py = partial + arg[1] * nc_partial;
     167        Base* px = partial + size_t(arg[0]) * nc_partial;
     168        Base* py = partial + size_t(arg[1]) * nc_partial;
    170169        Base* pz = partial + i_z    * nc_partial;
    171170
     
    209208
    210209        // Taylor coefficients corresponding to arguments and result
    211         Base* y = taylor + arg[1] * cap_order;
     210        Base* y = taylor + size_t(arg[1]) * cap_order;
    212211        Base* z = taylor + i_z    * cap_order;
    213212
     
    252251        size_t num_taylor_per_var = (cap_order-1) * r + 1;
    253252        size_t m                  = (q-1) * r + 1;
    254         Base* y = taylor + arg[1] * num_taylor_per_var + m;
     253        Base* y = taylor + size_t(arg[1]) * num_taylor_per_var + m;
    255254        Base* z = taylor + i_z    * num_taylor_per_var + m;
    256255
     
    287286
    288287        // Taylor coefficients corresponding to arguments and result
    289         Base* y = taylor + arg[1] * cap_order;
     288        Base* y = taylor + size_t(arg[1]) * cap_order;
    290289        Base* z = taylor + i_z    * cap_order;
    291290
     
    324323
    325324        // Partial derivatives corresponding to arguments and result
    326         Base* py = partial + arg[1] * nc_partial;
     325        Base* py = partial + size_t(arg[1]) * nc_partial;
    327326        Base* pz = partial + i_z    * nc_partial;
    328327
  • trunk/cppad/local/comp_op.hpp

    r4022 r4023  
    4848        Base y = parameter[ arg[1] ];
    4949
    50         count += GreaterThanZero(x - y);
     50        count += size_t( GreaterThanZero(x - y) );
    5151}
    5252/*!
     
    5858\param arg
    5959parameter[ arg[0] ] is the left operand and
    60 taylor[ arg[1] * cap_order + 0 ] is the zero order Taylor coefficient
     60taylor[ size_t(arg[1]) * cap_order + 0 ] is the zero order Taylor coefficient
    6161for the right operand.
    6262
     
    8484        // Taylor coefficients corresponding to arguments and result
    8585        Base  x = parameter[ arg[0] ];
    86         Base* y = taylor + arg[1] * cap_order;
     86        Base* y = taylor + size_t(arg[1]) * cap_order;
    8787
    8888        count += GreaterThanZero(x - y[0]);
     
    9595
    9696\param arg
    97 taylor[ arg[0] * cap_order + 0 ] is the zero order Taylor coefficient
     97taylor[ size_t(arg[0]) * cap_order + 0 ] is the zero order Taylor coefficient
    9898for the left operand and  parameter[ arg[1] ] is the right operand
    9999
     
    120120
    121121        // Taylor coefficients corresponding to arguments and result
    122         Base* x = taylor + arg[0] * cap_order;
     122        Base* x = taylor + size_t(arg[0]) * cap_order;
    123123        Base  y = parameter[ arg[1] ];
    124124
     
    132132
    133133\param arg
    134 taylor[ arg[0] * cap_order + 0 ] is the zero order Taylor coefficient
     134taylor[ size_t(arg[0]) * cap_order + 0 ] is the zero order Taylor coefficient
    135135for the left operand and
    136 taylor[ arg[1] * cap_order + 0 ] is the zero order Taylor coefficient
     136taylor[ size_t(arg[1]) * cap_order + 0 ] is the zero order Taylor coefficient
    137137for the right operand.
    138138
     
    159159
    160160        // Taylor coefficients corresponding to arguments and result
    161         Base* x = taylor + arg[0] * cap_order;
    162         Base* y = taylor + arg[1] * cap_order;
     161        Base* x = taylor + size_t(arg[0]) * cap_order;
     162        Base* y = taylor + size_t(arg[1]) * cap_order;
    163163
    164164        count += GreaterThanZero(x[0] - y[0]);
     
    213213        // Taylor coefficients corresponding to arguments and result
    214214        Base  x = parameter[ arg[0] ];
    215         Base* y = taylor + arg[1] * cap_order;
     215        Base* y = taylor + size_t(arg[1]) * cap_order;
    216216
    217217        count += GreaterThanOrZero(x - y[0]);
     
    235235
    236236        // Taylor coefficients corresponding to arguments and result
    237         Base* x = taylor + arg[0] * cap_order;
     237        Base* x = taylor + size_t(arg[0]) * cap_order;
    238238        Base  y = parameter[ arg[1] ];
    239239
     
    258258
    259259        // Taylor coefficients corresponding to arguments and result
    260         Base* x = taylor + arg[0] * cap_order;
    261         Base* y = taylor + arg[1] * cap_order;
     260        Base* x = taylor + size_t(arg[0]) * cap_order;
     261        Base* y = taylor + size_t(arg[1]) * cap_order;
    262262
    263263        count += GreaterThanOrZero(x[0] - y[0]);
     
    291291        Base y = parameter[ arg[1] ];
    292292
    293         count += (x != y);
     293        count += size_t(x != y);
    294294}
    295295/*!
     
    312312        // Taylor coefficients corresponding to arguments and result
    313313        Base  x = parameter[ arg[0] ];
    314         Base* y = taylor + arg[1] * cap_order;
    315 
    316         count += (x != y[0]);
     314        Base* y = taylor + size_t(arg[1]) * cap_order;
     315
     316        count += size_t(x != y[0]);
    317317}
    318318/*!
     
    334334
    335335        // Taylor coefficients corresponding to arguments and result
    336         Base* x = taylor + arg[0] * cap_order;
    337         Base* y = taylor + arg[1] * cap_order;
    338 
    339         count += (x[0] != y[0]);
     336        Base* x = taylor + size_t(arg[0]) * cap_order;
     337        Base* y = taylor + size_t(arg[1]) * cap_order;
     338
     339        count += size_t(x[0] != y[0]);
    340340}
    341341// -------------------------------- != -----------------------------------
     
    367367        Base y = parameter[ arg[1] ];
    368368
    369         count += (x == y);
     369        count += size_t(x == y);
    370370}
    371371/*!
     
    388388        // Taylor coefficients corresponding to arguments and result
    389389        Base  x = parameter[ arg[0] ];
    390         Base* y = taylor + arg[1] * cap_order;
    391 
    392         count += (x == y[0]);
     390        Base* y = taylor + size_t(arg[1]) * cap_order;
     391
     392        count += size_t(x == y[0]);
    393393}
    394394/*!
     
    410410
    411411        // Taylor coefficients corresponding to arguments and result
    412         Base* x = taylor + arg[0] * cap_order;
    413         Base* y = taylor + arg[1] * cap_order;
    414 
    415         count += (x[0] == y[0]);
     412        Base* x = taylor + size_t(arg[0]) * cap_order;
     413        Base* y = taylor + size_t(arg[1]) * cap_order;
     414
     415        count += size_t(x[0] == y[0]);
    416416}
    417417
  • trunk/cppad/local/cond_op.hpp

    r3845 r4023  
    1 // $Id$
    21# ifndef CPPAD_LOCAL_COND_OP_HPP
    32# define CPPAD_LOCAL_COND_OP_HPP
    43/* --------------------------------------------------------------------------
    5 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
     4CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-18 Bradley M. Bell
    65
    76CppAD is distributed under multiple licenses. This distribution is under
     
    308307        if( arg[1] & 1 )
    309308        {
    310                 y_0 = taylor[ arg[2] * cap_order + 0 ];
     309                y_0 = taylor[ size_t(arg[2]) * cap_order + 0 ];
    311310        }
    312311        else
     
    316315        if( arg[1] & 2 )
    317316        {
    318                 y_1 = taylor[ arg[3] * cap_order + 0 ];
     317                y_1 = taylor[ size_t(arg[3]) * cap_order + 0 ];
    319318        }
    320319        else
     
    325324        {       if( arg[1] & 4 )
    326325                {
    327                         y_2 = taylor[ arg[4] * cap_order + 0 ];
     326                        y_2 = taylor[ size_t(arg[4]) * cap_order + 0 ];
    328327                }
    329328                else
     
    333332                if( arg[1] & 8 )
    334333                {
    335                         y_3 = taylor[ arg[5] * cap_order + 0 ];
     334                        y_3 = taylor[ size_t(arg[5]) * cap_order + 0 ];
    336335                }
    337336                else
     
    351350        {       if( arg[1] & 4 )
    352351                {
    353                         y_2 = taylor[ arg[4] * cap_order + d];
     352                        y_2 = taylor[ size_t(arg[4]) * cap_order + d];
    354353                }
    355354                else    y_2 = zero;
    356355                if( arg[1] & 8 )
    357356                {
    358                         y_3 = taylor[ arg[5] * cap_order + d];
     357                        y_3 = taylor[ size_t(arg[5]) * cap_order + d];
    359358                }
    360359                else    y_3 = zero;
     
    503502        if( arg[1] & 1 )
    504503        {
    505                 y_0 = taylor[ arg[2] * num_taylor_per_var + 0 ];
     504                y_0 = taylor[ size_t(arg[2]) * num_taylor_per_var + 0 ];
    506505        }
    507506        else
     
    511510        if( arg[1] & 2 )
    512511        {
    513                 y_1 = taylor[ arg[3] * num_taylor_per_var + 0 ];
     512                y_1 = taylor[ size_t(arg[3]) * num_taylor_per_var + 0 ];
    514513        }
    515514        else
     
    521520        {       if( arg[1] & 4 )
    522521                {
    523                         y_2 = taylor[ arg[4] * num_taylor_per_var + m + ell];
     522                        y_2 = taylor[ size_t(arg[4]) * num_taylor_per_var + m + ell];
    524523                }
    525524                else    y_2 = zero;
    526525                if( arg[1] & 8 )
    527526                {
    528                         y_3 = taylor[ arg[5] * num_taylor_per_var + m + ell];
     527                        y_3 = taylor[ size_t(arg[5]) * num_taylor_per_var + m + ell];
    529528                }
    530529                else    y_3 = zero;
     
    646645        if( arg[1] & 1 )
    647646        {
    648                 y_0 = taylor[ arg[2] * cap_order + 0 ];
     647                y_0 = taylor[ size_t(arg[2]) * cap_order + 0 ];
    649648        }
    650649        else
     
    654653        if( arg[1] & 2 )
    655654        {
    656                 y_1 = taylor[ arg[3] * cap_order + 0 ];
     655                y_1 = taylor[ size_t(arg[3]) * cap_order + 0 ];
    657656        }
    658657        else
     
    662661        if( arg[1] & 4 )
    663662        {
    664                 y_2 = taylor[ arg[4] * cap_order + 0 ];
     663                y_2 = taylor[ size_t(arg[4]) * cap_order + 0 ];
    665664        }
    666665        else
     
    670669        if( arg[1] & 8 )
    671670        {
    672                 y_3 = taylor[ arg[5] * cap_order + 0 ];
     671                y_3 = taylor[ size_t(arg[5]) * cap_order + 0 ];
    673672        }
    674673        else
     
    836835        if( arg[1] & 1 )
    837836        {
    838                 y_0 = taylor[ arg[2] * cap_order + 0 ];
     837                y_0 = taylor[ size_t(arg[2]) * cap_order + 0 ];
    839838        }
    840839        else
     
    844843        if( arg[1] & 2 )
    845844        {
    846                 y_1 = taylor[ arg[3] * cap_order + 0 ];
     845                y_1 = taylor[ size_t(arg[3]) * cap_order + 0 ];
    847846        }
    848847        else
     
    852851        if( arg[1] & 4 )
    853852        {
    854                 py_2 = partial + arg[4] * nc_partial;
     853                py_2 = partial + size_t(arg[4]) * nc_partial;
    855854                size_t j = d + 1;
    856855                while(j--)
     
    866865        if( arg[1] & 8 )
    867866        {
    868                 py_3 = partial + arg[5] * nc_partial;
     867                py_3 = partial + size_t(arg[5]) * nc_partial;
    869868                size_t j = d + 1;
    870869                while(j--)
     
    991990        CPPAD_ASSERT_UNKNOWN( arg[1] != 0 );
    992991# ifndef NDEBUG
    993         size_t k = 1;
     992        addr_t k = 1;
    994993        for( size_t j = 0; j < 4; j++)
    995994        {       if( ! ( arg[1] & k ) )
     
    10011000        if( dependency )
    10021001        {       if( arg[1] & 1 )
    1003                         sparsity.binary_union(i_z, i_z, arg[2], sparsity);
     1002                        sparsity.binary_union(i_z, i_z, size_t(arg[2]), sparsity);
    10041003                if( arg[1] & 2 )
    1005                         sparsity.binary_union(i_z, i_z, arg[3], sparsity);
     1004                        sparsity.binary_union(i_z, i_z, size_t(arg[3]), sparsity);
    10061005        }
    10071006        if( arg[1] & 4 )
    1008                 sparsity.binary_union(i_z, i_z, arg[4], sparsity);
     1007                sparsity.binary_union(i_z, i_z, size_t(arg[4]), sparsity);
    10091008        if( arg[1] & 8 )
    1010                 sparsity.binary_union(i_z, i_z, arg[5], sparsity);
     1009                sparsity.binary_union(i_z, i_z, size_t(arg[5]), sparsity);
    10111010        return;
    10121011}
     
    11321131        CPPAD_ASSERT_UNKNOWN( arg[1] != 0 );
    11331132# ifndef NDEBUG
    1134         size_t k = 1;
     1133        addr_t k = 1;
    11351134        for( size_t j = 0; j < 4; j++)
    11361135        {       if( ! ( arg[1] & k ) )
     
    11411140        if( dependency )
    11421141        {       if( arg[1] & 1 )
    1143                         sparsity.binary_union(arg[2], arg[2], i_z, sparsity);
     1142                        sparsity.binary_union( size_t(arg[2]), size_t(arg[2]), i_z, sparsity);
    11441143                if( arg[1] & 2 )
    1145                         sparsity.binary_union(arg[3], arg[3], i_z, sparsity);
     1144                        sparsity.binary_union( size_t(arg[3]), size_t(arg[3]), i_z, sparsity);
    11461145        }
    11471146        // --------------------------------------------------------------------
    11481147        if( arg[1] & 4 )
    1149                 sparsity.binary_union(arg[4], arg[4], i_z, sparsity);
     1148                sparsity.binary_union( size_t(arg[4]), size_t(arg[4]), i_z, sparsity);
    11501149        if( arg[1] & 8 )
    1151                 sparsity.binary_union(arg[5], arg[5], i_z, sparsity);
     1150                sparsity.binary_union( size_t(arg[5]), size_t(arg[5]), i_z, sparsity);
    11521151        return;
    11531152}
     
    12901289        CPPAD_ASSERT_UNKNOWN( arg[1] != 0 );
    12911290# ifndef NDEBUG
    1292         size_t k = 1;
     1291        addr_t k = 1;
    12931292        for( size_t j = 0; j < 4; j++)
    12941293        {       if( ! ( arg[1] & k ) )
     
    12991298        if( arg[1] & 4 )
    13001299        {
    1301                 hes_sparsity.binary_union(arg[4], arg[4], i_z, hes_sparsity);
     1300                hes_sparsity.binary_union( size_t(arg[4]), size_t(arg[4]), i_z, hes_sparsity);
    13021301                jac_reverse[ arg[4] ] |= jac_reverse[i_z];
    13031302        }
    13041303        if( arg[1] & 8 )
    13051304        {
    1306                 hes_sparsity.binary_union(arg[5], arg[5], i_z, hes_sparsity);
     1305                hes_sparsity.binary_union( size_t(arg[5]), size_t(arg[5]), i_z, hes_sparsity);
    13071306                jac_reverse[ arg[5] ] |= jac_reverse[i_z];
    13081307        }
  • trunk/cppad/local/cskip_op.hpp

    r4022 r4023  
    105105\param taylor [in]
    106106If left is an AD<Base> variable,
    107 <code>taylor [ arg[2] * cap_order + 0 ]</code>
     107<code>taylor [ size_t(arg[2]) * cap_order + 0 ]</code>
    108108is the zeroth order Taylor coefficient corresponding to left.
    109109If right is an AD<Base> variable,
    110 <code>taylor [ arg[3] * cap_order + 0 ]</code>
     110<code>taylor [ size_t(arg[3]) * cap_order + 0 ]</code>
    111111is the zeroth order Taylor coefficient corresponding to right.
    112112
     
    134134                // but it will be skipped for higher orders.
    135135                CPPAD_ASSERT_UNKNOWN( size_t(arg[2]) <= i_z );
    136                 left = taylor[ arg[2] * cap_order + 0 ];
     136                left = taylor[ size_t(arg[2]) * cap_order + 0 ];
    137137        }
    138138        else
     
    144144                // but it will be skipped for higher orders.
    145145                CPPAD_ASSERT_UNKNOWN( size_t(arg[3]) <= i_z );
    146                 right = taylor[ arg[3] * cap_order + 0 ];
     146                right = taylor[ size_t(arg[3]) * cap_order + 0 ];
    147147        }
    148148        else
     
    187187        }
    188188        if( true_case )
    189         {       for(size_t i = 0; i < size_t(arg[4]); i++)
     189        {       for(addr_t i = 0; i < arg[4]; i++)
    190190                        cskip_op[ arg[6+i] ] = true;
    191191        }
    192192        else
    193         {       for(size_t i = 0; i < size_t(arg[5]); i++)
     193        {       for(addr_t i = 0; i < arg[5]; i++)
    194194                        cskip_op[ arg[6+arg[4]+i] ] = true;
    195195        }
  • trunk/cppad/local/csum_op.hpp

    r4020 r4023  
    126126        for(size_t i = 5; i < size_t(arg[1]); ++i)
    127127        {       CPPAD_ASSERT_UNKNOWN( size_t(arg[i]) < i_z );
    128                 x     = taylor + arg[i] * cap_order;
     128                x     = taylor + size_t(arg[i]) * cap_order;
    129129                for(size_t k = p; k <= q; k++)
    130130                        z[k] += x[k];
     
    132132        for(size_t i = size_t(arg[1]); i < size_t(arg[2]); ++i)
    133133        {       CPPAD_ASSERT_UNKNOWN( size_t(arg[i]) < i_z );
    134                 x     = taylor + arg[i] * cap_order;
     134                x     = taylor + size_t(arg[i]) * cap_order;
    135135                for(size_t k = p; k <= q; k++)
    136136                        z[k] -= x[k];
     
    241241        for(size_t i = 5; i < size_t(arg[1]); ++i)
    242242        {       CPPAD_ASSERT_UNKNOWN( size_t(arg[i]) < i_z );
    243                 x = taylor + arg[i] * num_taylor_per_var + m;
     243                x = taylor + size_t(arg[i]) * num_taylor_per_var + m;
    244244                for(size_t ell = 0; ell < r; ell++)
    245245                        z[ell] += x[ell];
     
    247247        for(size_t i = size_t(arg[1]); i < size_t(arg[2]); ++i)
    248248        {       CPPAD_ASSERT_UNKNOWN( size_t(arg[i]) < i_z );
    249                 x = taylor + arg[i] * num_taylor_per_var + m;
     249                x = taylor + size_t(arg[i]) * num_taylor_per_var + m;
    250250                for(size_t ell = 0; ell < r; ell++)
    251251                        z[ell] -= x[ell];
     
    346346        for(size_t i = 5; i < size_t(arg[1]); ++i)
    347347        {       CPPAD_ASSERT_UNKNOWN( size_t(arg[i]) < i_z );
    348                 px    = partial + arg[i] * nc_partial;
     348                px    = partial + size_t(arg[i]) * nc_partial;
    349349                size_t k = d1;
    350350                while(k--)
     
    353353        for(size_t i = size_t(arg[1]); i < size_t(arg[2]); ++i)
    354354        {       CPPAD_ASSERT_UNKNOWN( size_t(arg[i]) < i_z );
    355                 px    = partial + arg[i] * nc_partial;
     355                px    = partial + size_t(arg[i]) * nc_partial;
    356356                size_t k = d1;
    357357                while(k--)
     
    429429                        i_z        , // index in sparsity for result
    430430                        i_z        , // index in sparsity for left operand
    431                         arg[i]   , // index for right operand
     431                        size_t(arg[i]), // index for right operand
    432432                        sparsity     // sparsity vector for right operand
    433433                );
     
    501501                CPPAD_ASSERT_UNKNOWN( size_t(arg[i]) < i_z );
    502502                sparsity.binary_union(
    503                         arg[i]     , // index in sparsity for result
    504                         arg[i]     , // index in sparsity for left operand
     503                        size_t(arg[i]), // index in sparsity for result
     504                        size_t(arg[i]), // index in sparsity for left operand
    505505                        i_z        , // index for right operand
    506506                        sparsity     // sparsity vector for right operand
     
    597597                CPPAD_ASSERT_UNKNOWN( size_t(arg[i]) < i_z );
    598598                rev_hes_sparsity.binary_union(
    599                 arg[i]             , // index in sparsity for result
    600                 arg[i]             , // index in sparsity for left operand
     599                size_t(arg[i]), // index in sparsity for result
     600                size_t(arg[i]), // index in sparsity for left operand
    601601                i_z                , // index for right operand
    602602                rev_hes_sparsity     // sparsity vector for right operand
  • trunk/cppad/local/declare_ad.hpp

    r4022 r4023  
    9191        template <class Base> AD<Base> sqrt          (const AD<Base> &u);
    9292        template <class Base> AD<Base> tan           (const AD<Base> &u);
     93        //
     94        template <class Base> unsigned short hash_code(const AD<Base>& u);
    9395
    9496        // arithematic operators
  • trunk/cppad/local/discrete_op.hpp

    r3970 r4023  
    33
    44/* --------------------------------------------------------------------------
    5 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-17 Bradley M. Bell
     5CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-18 Bradley M. Bell
    66
    77CppAD is distributed under multiple licenses. This distribution is under
     
    105105        // Taylor coefficients corresponding to argument and result
    106106        size_t num_taylor_per_var = (cap_order-1) * r + 1;
    107         Base* x = taylor + arg[1] * num_taylor_per_var;
     107        Base* x = taylor + size_t(arg[1]) * num_taylor_per_var;
    108108        Base* z = taylor +    i_z * num_taylor_per_var;
    109109
    110110        if( p == 0 )
    111         {       z[0]  = discrete<Base>::eval(arg[0], x[0]);
     111        {       z[0]  = discrete<Base>::eval(size_t(arg[0]), x[0]);
    112112                p++;
    113113        }
  • trunk/cppad/local/div_op.hpp

    r3970 r4023  
    33
    44/* --------------------------------------------------------------------------
    5 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-17 Bradley M. Bell
     5CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-18 Bradley M. Bell
    66
    77CppAD is distributed under multiple licenses. This distribution is under
     
    5151
    5252        // Taylor coefficients corresponding to arguments and result
    53         Base* x = taylor + arg[0] * cap_order;
    54         Base* y = taylor + arg[1] * cap_order;
     53        Base* x = taylor + size_t(arg[0]) * cap_order;
     54        Base* y = taylor + size_t(arg[1]) * cap_order;
    5555        Base* z = taylor + i_z    * cap_order;
    5656
     
    9898        // Taylor coefficients corresponding to arguments and result
    9999        size_t num_taylor_per_var = (cap_order-1) * r + 1;
    100         Base* x = taylor + arg[0] * num_taylor_per_var;
    101         Base* y = taylor + arg[1] * num_taylor_per_var;
     100        Base* x = taylor + size_t(arg[0]) * num_taylor_per_var;
     101        Base* y = taylor + size_t(arg[1]) * num_taylor_per_var;
    102102        Base* z = taylor + i_z    * num_taylor_per_var;
    103103
     
    142142
    143143        // Taylor coefficients corresponding to arguments and result
    144         Base* x = taylor + arg[0] * cap_order;
    145         Base* y = taylor + arg[1] * cap_order;
     144        Base* x = taylor + size_t(arg[0]) * cap_order;
     145        Base* y = taylor + size_t(arg[1]) * cap_order;
    146146        Base* z = taylor + i_z    * cap_order;
    147147
     
    181181
    182182        // Arguments
    183         const Base* y  = taylor + arg[1] * cap_order;
     183        const Base* y  = taylor + size_t(arg[1]) * cap_order;
    184184        const Base* z  = taylor + i_z    * cap_order;
    185185
    186186        // Partial derivatives corresponding to arguments and result
    187         Base* px = partial + arg[0] * nc_partial;
    188         Base* py = partial + arg[1] * nc_partial;
     187        Base* px = partial + size_t(arg[0]) * nc_partial;
     188        Base* py = partial + size_t(arg[1]) * nc_partial;
    189189        Base* pz = partial + i_z    * nc_partial;
    190190
     
    241241
    242242        // Taylor coefficients corresponding to arguments and result
    243         Base* y = taylor + arg[1] * cap_order;
     243        Base* y = taylor + size_t(arg[1]) * cap_order;
    244244        Base* z = taylor + i_z    * cap_order;
    245245
     
    292292        // Taylor coefficients corresponding to arguments and result
    293293        size_t num_taylor_per_var = (cap_order-1) * r + 1;
    294         Base* y = taylor + arg[1] * num_taylor_per_var;
     294        Base* y = taylor + size_t(arg[1]) * num_taylor_per_var;
    295295        Base* z = taylor + i_z    * num_taylor_per_var;
    296296
     
    335335
    336336        // Taylor coefficients corresponding to arguments and result
    337         Base* y = taylor + arg[1] * cap_order;
     337        Base* y = taylor + size_t(arg[1]) * cap_order;
    338338        Base* z = taylor + i_z    * cap_order;
    339339
     
    372372
    373373        // Arguments
    374         const Base* y = taylor + arg[1] * cap_order;
     374        const Base* y = taylor + size_t(arg[1]) * cap_order;
    375375        const Base* z = taylor + i_z    * cap_order;
    376376
    377377        // Partial derivatives corresponding to arguments and result
    378         Base* py = partial + arg[1] * nc_partial;
     378        Base* py = partial + size_t(arg[1]) * nc_partial;
    379379        Base* pz = partial + i_z    * nc_partial;
    380380
     
    431431
    432432        // Taylor coefficients corresponding to arguments and result
    433         Base* x = taylor + arg[0] * cap_order;
     433        Base* x = taylor + size_t(arg[0]) * cap_order;
    434434        Base* z = taylor + i_z    * cap_order;
    435435
     
    473473        // Taylor coefficients corresponding to arguments and result
    474474        size_t num_taylor_per_var = (cap_order-1) * r + 1;
    475         Base* x = taylor + arg[0] * num_taylor_per_var;
     475        Base* x = taylor + size_t(arg[0]) * num_taylor_per_var;
    476476        Base* z = taylor +    i_z * num_taylor_per_var;
    477477
     
    516516
    517517        // Taylor coefficients corresponding to arguments and result
    518         Base* x = taylor + arg[0] * cap_order;
     518        Base* x = taylor + size_t(arg[0]) * cap_order;
    519519        Base* z = taylor + i_z    * cap_order;
    520520
     
    556556
    557557        // Partial derivatives corresponding to arguments and result
    558         Base* px = partial + arg[0] * nc_partial;
     558        Base* px = partial + size_t(arg[0]) * nc_partial;
    559559        Base* pz = partial + i_z    * nc_partial;
    560560
  • trunk/cppad/local/erf_op.hpp

    r4010 r4023  
    6565\param taylor
    6666\b Input:
    67 taylor [ arg[0] * cap_order + k ]
     67taylor [ size_t(arg[0]) * cap_order + k ]
    6868for k = 0 , ... , q,
    6969is the k-th order Taylor coefficient corresponding to x.
     
    137137
    138138        // pointers to taylor coefficients for x , z_3, and z_4
    139         Base* x    = taylor + arg[0] * cap_order;
     139        Base* x    = taylor + size_t(arg[0]) * cap_order;
    140140        Base* z_3  = taylor + (i_z+3) * cap_order;
    141141        Base* z_4  = taylor + (i_z+4) * cap_order;
     
    192192\param taylor
    193193\b Input:
    194 taylor [ arg[0] * cap_order + 0 ]
     194taylor [ size_t(arg[0]) * cap_order + 0 ]
    195195is the zero order Taylor coefficient corresponding to x.
    196196\n
     
    252252
    253253        // zero order Taylor coefficient for z_4
    254         Base* x    = taylor + arg[0] * cap_order;
     254        Base* x    = taylor + size_t(arg[0]) * cap_order;
    255255        Base* z_4  = taylor + (i_z + 4) * cap_order;
    256256        z_4[0] = erf(x[0]);
     
    378378        // pointers to taylor coefficients for x , z_3, and z_4
    379379        size_t num_taylor_per_var = (cap_order - 1) * r + 1;
    380         Base* x    = taylor + arg[0] * num_taylor_per_var;
     380        Base* x    = taylor + size_t(arg[0]) * num_taylor_per_var;
    381381        Base* z_3  = taylor + (i_z+3) * num_taylor_per_var;
    382382        Base* z_4  = taylor + (i_z+4) * num_taylor_per_var;
     
    437437\param taylor
    438438\b Input:
    439 taylor [ arg[0] * cap_order + k ]
     439taylor [ size_t(arg[0]) * cap_order + k ]
    440440for k = 0 , ... , d,
    441441is the k-th order Taylor coefficient corresponding to x.
     
    452452\param partial
    453453\b Input:
    454 partial [ arg[0] * nc_partial + k ]
     454partial [ size_t(arg[0]) * nc_partial + k ]
    455455for k = 0 , ... , d,
    456456is the partial derivative of G( z , x , w , u , ... ) with respect to
     
    465465\n
    466466\b Output:
    467 partial [ arg[0] * nc_partial + k ]
     467partial [ size_t(arg[0]) * nc_partial + k ]
    468468for k = 0 , ... , d,
    469469is the partial derivative of H( x , w , u , ... ) with respect to
     
    517517
    518518        // Taylor coefficients and partials corresponding to x
    519         const Base* x  = taylor  + arg[0] * cap_order;
    520         Base* px       = partial + arg[0] * nc_partial;
     519        const Base* x  = taylor  + size_t(arg[0]) * cap_order;
     520        Base* px       = partial + size_t(arg[0]) * nc_partial;
    521521
    522522        // Taylor coefficients and partials corresponding to z_3
  • trunk/cppad/local/hash_code.hpp

    r3969 r4023  
    33
    44/* --------------------------------------------------------------------------
    5 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-17 Bradley M. Bell
     5CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-18 Bradley M. Bell
    66
    77CppAD is distributed under multiple licenses. This distribution is under
     
    123123        OpCode        op      ,
    124124        const addr_t* arg     ,
    125         size_t npar           ,
    126         const Base* par       )
     125        size_t        npar    ,
     126        const Base*   par     )
    127127{       CPPAD_ASSERT_UNKNOWN(
    128128                std::numeric_limits<unsigned short>::max()
     
    141141        // number of shorts per addr_t value
    142142        size_t short_addr_t   = sizeof(addr_t) / 2;
    143 
    144         // number of shorts per Base value
    145         size_t short_base     = sizeof(Base) /  2;
    146143
    147144        // initialize with value that separates operators as much as possible
     
    167164                case ZmulpvOp:
    168165                CPPAD_ASSERT_UNKNOWN( NumArg(op) == 2 );
    169                 v = reinterpret_cast<const unsigned short*>(par + arg[0]);
    170                 i = short_base;
    171                 while(i--)
    172                         code += v[i];
     166                code += hash_code( par[arg[0]] );
     167                //
    173168                v = reinterpret_cast<const unsigned short*>(arg + 1);
    174169                i = short_addr_t;
     
    205200                while(i--)
    206201                        code += v[i];
    207                 v = reinterpret_cast<const unsigned short*>(par + arg[1]);
    208                 i = short_base;
    209                 while(i--)
    210                         code += v[i];
     202                code += hash_code( par[arg[1]] );
    211203                break;
    212204
  • trunk/cppad/local/independent.hpp

    r4022 r4023  
    7777                x[j].taddr_     = Rec_.PutOp(InvOp);
    7878                x[j].tape_id_   = id_;
    79                 x[j].dynamic_   = false;
     79                x[j].ad_type_   = var_ad_type;
    8080                CPPAD_ASSERT_UNKNOWN( size_t(x[j].taddr_) == j+1 );
    8181                CPPAD_ASSERT_UNKNOWN( Variable(x[j] ) );
     
    9292                // dynamic parameters are placed at the end, so i == j
    9393# ifndef NDEBUG
    94                 size_t i = Rec_.put_dyn_par(dynamic[j].value_ , ind_dyn);
    95                 CPPAD_ASSERT_UNKNOWN(i == j );
     94                addr_t i = Rec_.put_dyn_par(dynamic[j].value_ , ind_dyn);
     95                CPPAD_ASSERT_UNKNOWN( size_t(i) == j );
    9696# else
    9797                Rec_.put_dyn_par(dynamic[j].value_ , ind_dyn);
     
    101101                dynamic[j].taddr_   = static_cast<addr_t>(j);
    102102                dynamic[j].tape_id_ = id_;
    103                 dynamic[j].dynamic_ = true;
     103                dynamic[j].ad_type_ = dyn_ad_type;
    104104                CPPAD_ASSERT_UNKNOWN( Dynamic( dynamic[j] ) );
    105105        }
  • trunk/cppad/local/load_op.hpp

    r4016 r4023  
    8282i_vec is defined by
    8383\verbatim
    84         i_vec = floor( taylor[ arg[1] * cap_order + 0 ] )
     84        i_vec = floor( taylor[ size_t(arg[1]) * cap_order + 0 ] )
    8585\endverbatim
    8686where floor(c) is the greatest integer less that or equal c.
     
    102102Input
    103103\n
    104 In LdvOp case, <code>taylor[ arg[1] * cap_order + 0 ]</code>
     104In LdvOp case, <code>taylor[ size_t(arg[1]) * cap_order + 0 ]</code>
    105105is used to compute the index in the definition of i_vec above.
    106106If v[x] is a variable, <code>taylor[ i_v_x * cap_order + 0 ]</code>
     
    265265        // Because the index is a parameter, this indexing error should have been
    266266        // caught and reported to the user when the tape is recording.
    267         size_t i_vec = arg[1];
    268         CPPAD_ASSERT_UNKNOWN( i_vec < index_by_ind[ arg[0] - 1 ] );
    269         CPPAD_ASSERT_UNKNOWN( arg[0] + i_vec < play->num_vec_ind_rec() );
     267        addr_t i_vec = arg[1];
     268        CPPAD_ASSERT_UNKNOWN( size_t(i_vec) < index_by_ind[ arg[0] - 1 ] );
     269        CPPAD_ASSERT_UNKNOWN( size_t(arg[0] + i_vec) < play->num_vec_ind_rec() );
    270270
    271271        size_t i_v_x  = index_by_ind[ arg[0] + i_vec ];
     
    309309        );
    310310
    311         size_t i_vec = Integer( taylor[ arg[1] * cap_order + 0 ] );
     311        addr_t i_vec = addr_t(Integer(taylor[ size_t(arg[1]) * cap_order + 0 ] ));
    312312        CPPAD_ASSERT_KNOWN(
    313                 i_vec < index_by_ind[ arg[0] - 1 ] ,
     313                size_t(i_vec) < index_by_ind[ arg[0] - 1 ] ,
    314314                "VecAD: index during zero order forward sweep is out of range"
    315315        );
    316         CPPAD_ASSERT_UNKNOWN( arg[0] + i_vec < play->num_vec_ind_rec() );
     316        CPPAD_ASSERT_UNKNOWN( size_t(arg[0] + i_vec) < play->num_vec_ind_rec() );
    317317
    318318        size_t i_v_x  = index_by_ind[ arg[0] + i_vec ];
     
    605605        var_sparsity.assignment(i_z, i_v, vecad_sparsity);
    606606        if( dependency & (op == LdvOp) )
    607                 var_sparsity.binary_union(i_z, i_z, arg[1], var_sparsity);
     607                var_sparsity.binary_union(i_z, i_z, size_t(arg[1]), var_sparsity);
    608608
    609609        return;
     
    639639        vecad_sparsity.binary_union(i_v, i_v, i_z, var_sparsity);
    640640        if( dependency & (op == LdvOp) )
    641                 var_sparsity.binary_union(arg[1], arg[1], i_z, var_sparsity);
     641                var_sparsity.binary_union( size_t(arg[1]), size_t(arg[1]), i_z, var_sparsity);
    642642
    643643        return;
  • trunk/cppad/local/mul_op.hpp

    r3970 r4023  
    33
    44/* --------------------------------------------------------------------------
    5 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-17 Bradley M. Bell
     5CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-18 Bradley M. Bell
    66
    77CppAD is distributed under multiple licenses. This distribution is under
     
    5151
    5252        // Taylor coefficients corresponding to arguments and result
    53         Base* x = taylor + arg[0] * cap_order;
    54         Base* y = taylor + arg[1] * cap_order;
     53        Base* x = taylor + size_t(arg[0]) * cap_order;
     54        Base* y = taylor + size_t(arg[1]) * cap_order;
    5555        Base* z = taylor + i_z    * cap_order;
    5656
     
    9494        // Taylor coefficients corresponding to arguments and result
    9595        size_t num_taylor_per_var = (cap_order-1) * r + 1;
    96         Base* x = taylor + arg[0] * num_taylor_per_var;
    97         Base* y = taylor + arg[1] * num_taylor_per_var;
     96        Base* x = taylor + size_t(arg[0]) * num_taylor_per_var;
     97        Base* y = taylor + size_t(arg[1]) * num_taylor_per_var;
    9898        Base* z = taylor +    i_z * num_taylor_per_var;
    9999
     
    134134
    135135        // Taylor coefficients corresponding to arguments and result
    136         Base* x = taylor + arg[0] * cap_order;
    137         Base* y = taylor + arg[1] * cap_order;
     136        Base* x = taylor + size_t(arg[0]) * cap_order;
     137        Base* y = taylor + size_t(arg[1]) * cap_order;
    138138        Base* z = taylor + i_z    * cap_order;
    139139
     
    173173
    174174        // Arguments
    175         const Base* x  = taylor + arg[0] * cap_order;
    176         const Base* y  = taylor + arg[1] * cap_order;
     175        const Base* x  = taylor + size_t(arg[0]) * cap_order;
     176        const Base* y  = taylor + size_t(arg[1]) * cap_order;
    177177
    178178        // Partial derivatives corresponding to arguments and result
    179         Base* px = partial + arg[0] * nc_partial;
    180         Base* py = partial + arg[1] * nc_partial;
     179        Base* px = partial + size_t(arg[0]) * nc_partial;
     180        Base* py = partial + size_t(arg[1]) * nc_partial;
    181181        Base* pz = partial + i_z    * nc_partial;
    182182
     
    225225
    226226        // Taylor coefficients corresponding to arguments and result
    227         Base* y = taylor + arg[1] * cap_order;
     227        Base* y = taylor + size_t(arg[1]) * cap_order;
    228228        Base* z = taylor + i_z    * cap_order;
    229229
     
    266266        size_t num_taylor_per_var = (cap_order-1) * r + 1;
    267267        size_t m                  = (q-1) * r + 1;
    268         Base* y = taylor + arg[1] * num_taylor_per_var + m;
     268        Base* y = taylor + size_t(arg[1]) * num_taylor_per_var + m;
    269269        Base* z = taylor + i_z    * num_taylor_per_var + m;
    270270
     
    304304
    305305        // Taylor coefficients corresponding to arguments and result
    306         Base* y = taylor + arg[1] * cap_order;
     306        Base* y = taylor + size_t(arg[1]) * cap_order;
    307307        Base* z = taylor + i_z    * cap_order;
    308308
     
    344344
    345345        // Partial derivatives corresponding to arguments and result
    346         Base* py = partial + arg[1] * nc_partial;
     346        Base* py = partial + size_t(arg[1]) * nc_partial;
    347347        Base* pz = partial + i_z    * nc_partial;
    348348
  • trunk/cppad/local/op_code.hpp

    r4022 r4023  
    128128        PowvpOp,  // pow(variable,    parameter)
    129129        PowvvOp,  // pow(variable,    variable)
    130         PriOp,    // PrintFor(text, parameter or variable, parameter or variable)
     130        PriOp,    // PrintFor(pos, before, value, after)
     131        // arg[0] & 1 = is pos a variable
     132        // arg[0] & 2 = is value a varialbe
     133        // arg[1]     = index corresponding to pos
     134        // arg[2]     = index corresponding to before
     135        // arg[3]     = index corresponding to value
     136        // arg[4]     = index corresponding to after
    131137        SignOp,   // sign(variable)
    132138        SinOp,    // sin(variable)
     
    522528        size_t len = str.size();
    523529        if( len > width )
    524         {       size_t i;
    525                 for(i = 0; i < width-1; i++)
     530        {
     531                for(size_t i = 0; i < width-1; i++)
    526532                        os << str[i];
    527533                os << "*";
     
    578584        OpCode                 op     ,
    579585        const addr_t*          ind    )
    580 {       size_t i;
     586{
    581587        CPPAD_ASSERT_KNOWN(
    582588                ! thread_alloc::in_parallel() ,
     
    623629                else    printOpField(os, " pr=", play->GetPar(ind[3]), ncol);
    624630                if( size_t(ind[4]) < 3 )
    625                 {       for(i = 0; i < size_t(ind[4]); i++)
     631                {       for(addr_t i = 0; i < ind[4]; i++)
    626632                                printOpField(os, " ot=", ind[6+i], ncol);
    627633                }
    628634                else
    629635                {       printOpField(os, "\n\tot=", ind[6+0], ncol);
    630                         for(i = 1; i < size_t(ind[4]); i++)
     636                        for(addr_t i = 1; i < ind[4]; i++)
    631637                                printOpField(os, " ot=", ind[6+i], ncol);
    632638                }
    633639                if( size_t(ind[5]) < 3 )
    634                 {       for(i = 0; i < size_t(ind[5]); i++)
     640                {       for(addr_t i = 0; i < ind[5]; i++)
    635641                                printOpField(os, " of=", ind[6+ind[4]+i], ncol);
    636642                }
    637643                else
    638644                {       printOpField(os, "\n\tof=", ind[6+ind[4]+0], ncol);
    639                         {       for(i = 1; i < size_t(ind[5]); i++)
     645                        {       for(addr_t i = 1; i < ind[5]; i++)
    640646                                        printOpField(os, " of=", ind[6+ind[4]+i], ncol);
    641647                        }
     
    658664                CPPAD_ASSERT_UNKNOWN( ind[ind[4]] == ind[4] );
    659665                printOpField(os, " pr=", play->GetPar(ind[0]), ncol);
    660                 for(i = 5; i < size_t(ind[1]); i++)
     666                for(addr_t i = 5; i < ind[1]; i++)
    661667                         printOpField(os, " +v=", ind[i], ncol);
    662                 for(i = size_t(ind[1]); i < size_t(ind[2]); i++)
     668                for(addr_t i = ind[1]; i < ind[2]; i++)
    663669                         printOpField(os, " -v=", ind[i], ncol);
    664                 for(i = size_t(ind[2]); i < size_t(ind[3]); i++)
     670                for(addr_t i = ind[2]; i < ind[3]; i++)
    665671                         printOpField(os, " +d=", play->GetPar(ind[i]), ncol);
    666                 for(i = size_t(ind[3]); i < size_t(ind[4]); i++)
     672                for(addr_t i = ind[3]; i < ind[4]; i++)
    667673                         printOpField(os, " -d=", play->GetPar(ind[i]), ncol);
    668674                break;
     
    11241130                //
    11251131                // true number of arguments
    1126                 num_arg = 7 + arg[4] + arg[5];
     1132                num_arg = size_t(7 + arg[4] + arg[5]);
    11271133                is_variable.resize(num_arg);
    11281134                is_variable[0] = false;
     
    11401146                //
    11411147                // true number of arguments
    1142                 num_arg = arg[4];
     1148                num_arg = size_t(arg[4]);
    11431149                //
    11441150                is_variable.resize( num_arg );
  • trunk/cppad/local/op_code_dyn.hpp

    r4022 r4023  
    3434        cos_dyn,       // cos(parameter)
    3535        cosh_dyn,      // cosh(parameter)
     36        dis_dyn,       // discrete function (index, parameter)
    3637        div_dyn,       // parameter / parameter
    3738        erf_dyn,       // erf(parameter)
     
    7475                1, // cos_dyn
    7576                1, // cosh_dyn
     77                2, // dis_dyn
    7678                2, // div_dyn
    7779                1, // erf_dyn
     
    120122                "cos",
    121123                "cosh",
     124                "dis",
    122125                "div",
    123126                "erf",
  • trunk/cppad/local/optimize/cexp_info.hpp

    r4019 r4023  
    2727struct struct_cexp_info {
    2828        /// The operator index for this conditional expression operation
    29         size_t i_op;
    30 
    31         /// (flag & 1) is true if and only if left is a variable
    32         /// (flag & 2) is true if and only if right is a variable
    33         size_t flag;
     29        addr_t i_op;
    3430
    3531        /// variable or parameter index for left comparison operand
    36         size_t left;
     32        addr_t left;
    3733
    3834        /// variable or parameter index for right comparison operand
    39         size_t right;
     35        addr_t right;
    4036
    4137        /// maximum variable index between left and right (ignoring parameters).
    42         size_t max_left_right;
     38        addr_t max_left_right;
    4339
    4440        /// set of operator that are not used when comparison result is true
     
    5450        /// comparision operator for this conditional expression
    5551        CompareOp cop;
     52
     53        /// (flag & 1) is true if and only if left is a variable
     54        /// (flag & 2) is true if and only if right is a variable
     55        unsigned char flag;
    5656};
    5757
  • trunk/cppad/local/optimize/get_cexp_info.hpp

    r4019 r4023  
    133133        //
    134134        for(size_t i = 0; i < num_cexp_op; i++)
    135         {       size_t i_op  = cexp2op[i];
     135        {       size_t i_op = size_t( cexp2op[i] );
    136136                CPPAD_ASSERT_UNKNOWN(
    137137                        op_previous[i_op] == 0 || op_usage[i_op] == usage_t(yes_usage)
     
    144144                //
    145145                struct_cexp_info info;
    146                 info.i_op       = i_op;
     146                info.i_op       = addr_t(i_op);
    147147                info.cop        = CompareOp( arg[0] );
    148                 info.flag       = arg[1];
     148                info.flag       = static_cast<unsigned char>(arg[1]);
    149149                info.left       = arg[2];
    150150                info.right      = arg[3];
    151151                //
    152152                // max_left_right
    153                 size_t index    = 0;
     153                addr_t index    = 0;
    154154                if( arg[1] & 1 )
    155155                        index = std::max(index, info.left);
  • trunk/cppad/local/optimize/get_op_usage.hpp

    r4022 r4023  
    364364                        CPPAD_ASSERT_UNKNOWN( NumRes(op) > 0 );
    365365                        if( use_result != usage_t(no_usage) )
    366                         {       size_t j_op = random_itr.var2op(arg[0]);
     366                        {       size_t j_op = random_itr.var2op(size_t(arg[0]));
    367367                                op_inc_arg_usage(
    368368                                        play, sum_op, i_op, j_op, op_usage, cexp_set
     
    383383                        CPPAD_ASSERT_UNKNOWN( NumRes(op) > 0 );
    384384                        if( use_result != usage_t(no_usage) )
    385                         {       size_t j_op = random_itr.var2op(arg[1]);
     385                        {       size_t j_op = random_itr.var2op(size_t(arg[1]));
    386386                                op_inc_arg_usage(
    387387                                        play, sum_op, i_op, j_op, op_usage, cexp_set
     
    402402                        if( use_result != usage_t(no_usage) )
    403403                        {       for(size_t i = 0; i < 2; i++)
    404                                 {       size_t j_op = random_itr.var2op(arg[i]);
     404                                {       size_t j_op = random_itr.var2op(size_t(arg[i]));
    405405                                        op_inc_arg_usage(
    406406                                                play, sum_op, i_op, j_op, op_usage, cexp_set
     
    422422                                // propgate from result to left argument
    423423                                if( arg[1] & 1 )
    424                                 {       size_t j_op = random_itr.var2op(arg[2]);
     424                                {       size_t j_op = random_itr.var2op(size_t(arg[2]));
    425425                                        op_inc_arg_usage(
    426426                                                play, sum_op, i_op, j_op, op_usage, cexp_set
     
    429429                                // propgate from result to right argument
    430430                                if( arg[1] & 2 )
    431                                 {       size_t j_op = random_itr.var2op(arg[3]);
     431                                {       size_t j_op = random_itr.var2op(size_t(arg[3]));
    432432                                        op_inc_arg_usage(
    433433                                                        play, sum_op, i_op, j_op, op_usage, cexp_set
     
    440440                                // if_true
    441441                                if( arg[1] & 4 )
    442                                 {       size_t j_op = random_itr.var2op(arg[4]);
     442                                {       size_t j_op = random_itr.var2op(size_t(arg[4]));
    443443                                        bool can_skip = conditional_skip & (! same_variable);
    444444                                        can_skip     &= op_usage[j_op] == usage_t(no_usage);
     
    459459                                // if_false
    460460                                if( arg[1] & 8 )
    461                                 {       size_t j_op = random_itr.var2op(arg[5]);
     461                                {       size_t j_op = random_itr.var2op(size_t(arg[5]));
    462462                                        bool can_skip = conditional_skip & (! same_variable);
    463463                                        can_skip     &= op_usage[j_op] == usage_t(no_usage);
     
    498498                                if( arg[0] & 1 )
    499499                                {       // arg[1] is a variable
    500                                         size_t j_op = random_itr.var2op(arg[1]);
     500                                        size_t j_op = random_itr.var2op(size_t(arg[1]));
    501501                                        op_inc_arg_usage(
    502502                                                play, sum_op, i_op, j_op, op_usage, cexp_set
     
    505505                                if( arg[0] & 2 )
    506506                                {       // arg[3] is a variable
    507                                         size_t j_op = random_itr.var2op(arg[3]);
     507                                        size_t j_op = random_itr.var2op(size_t(arg[3]));
    508508                                        op_inc_arg_usage(
    509509                                                play, sum_op, i_op, j_op, op_usage, cexp_set
     
    526526                        {       op_usage[i_op] = usage_t(yes_usage);
    527527                                //
    528                                 size_t j_op = random_itr.var2op(arg[1]);
     528                                size_t j_op = random_itr.var2op(size_t(arg[1]));
    529529                                op_inc_arg_usage(
    530530                                        play, sum_op, i_op, j_op, op_usage, cexp_set
     
    540540                        {       op_usage[i_op] = usage_t(yes_usage);
    541541                                //
    542                                 size_t j_op = random_itr.var2op(arg[0]);
     542                                size_t j_op = random_itr.var2op(size_t(arg[0]));
    543543                                op_inc_arg_usage(
    544544                                        play, sum_op, i_op, j_op, op_usage, cexp_set
     
    557557                                //
    558558                                for(size_t i = 0; i < 2; i++)
    559                                 {       size_t j_op = random_itr.var2op(arg[i]);
     559                                {       size_t j_op = random_itr.var2op(size_t(arg[i]));
    560560                                        op_inc_arg_usage(
    561561                                                play, sum_op, i_op, j_op, op_usage, cexp_set
     
    585585                                vecad_used[i_vec] = true;
    586586                                //
    587                                 size_t j_op = random_itr.var2op(arg[1]);
     587                                size_t j_op = random_itr.var2op(size_t(arg[1]));
    588588                                op_usage[j_op] = usage_t(yes_usage);
    589589                        }
     
    596596                        {       op_usage[i_op] = usage_t(yes_usage);
    597597                                //
    598                                 size_t j_op = random_itr.var2op(arg[2]);
     598                                size_t j_op = random_itr.var2op(size_t(arg[2]));
    599599                                op_usage[j_op] = usage_t(yes_usage);
    600600                        }
     
    607607                        {       op_usage[i_op] = usage_t(yes_usage);
    608608                                //
    609                                 size_t j_op = random_itr.var2op(arg[1]);
     609                                size_t j_op = random_itr.var2op(size_t(arg[1]));
    610610                                op_usage[j_op] = usage_t(yes_usage);
    611                                 size_t k_op = random_itr.var2op(arg[2]);
     611                                size_t k_op = random_itr.var2op(size_t(arg[2]));
    612612                                op_usage[k_op] = usage_t(yes_usage);
    613613                        }
     
    621621                        {
    622622                                for(size_t i = 5; i < size_t(arg[2]); i++)
    623                                 {       size_t j_op = random_itr.var2op( arg[i] );
     623                                {       size_t j_op = random_itr.var2op(size_t(arg[i]));
    624624                                        op_inc_arg_usage(
    625625                                                play, sum_op, i_op, j_op, op_usage, cexp_set
     
    635635                        if( user_state == end_user )
    636636                        {       // revese_user using random_itr instead of play
    637                                 size_t user_index = arg[0];
    638                                 user_old          = arg[1];
    639                                 user_n            = arg[2];
    640                                 user_m            = arg[3];
     637                                size_t user_index = size_t(arg[0]);
     638                                user_old          = size_t(arg[1]);
     639                                user_n            = size_t(arg[2]);
     640                                user_m            = size_t(arg[3]);
    641641                                user_j            = user_n;
    642642                                user_i            = user_m;
     
    808808                                user_state = start_user;
    809809                        // -------------------------------------------------------------
    810                         user_ix[user_j] = arg[0];
     810                        user_ix[user_j] = size_t(arg[0]);
    811811                        //
    812812                        // variable arguments as parameters
  • trunk/cppad/local/optimize/get_par_usage.hpp

    r4022 r4023  
    130130                if( op_usage[i_op] != no_usage ) switch( op )
    131131                {
    132                         // add or subtrace with left a parameter and right a variable
     132                        // add or subtract with left a parameter and right a variable
    133133                        case AddpvOp:
    134134                        case SubpvOp:
     
    139139                                 if( ! (op_usage[i_op] == csum_usage) )
    140140                                {       // determine operator corresponding to variable
    141                                         size_t j_op = random_itr.var2op( arg[1] );
     141                                        size_t j_op = random_itr.var2op(size_t(arg[1]));
    142142                                        CPPAD_ASSERT_UNKNOWN( op_usage[j_op] != no_usage );
    143143                                        if( op_usage[j_op] != csum_usage )
     
    155155                                 if( ! (op_usage[i_op] == csum_usage) )
    156156                                {       // determine operator corresponding to variable
    157                                         size_t j_op = random_itr.var2op( arg[0] );
     157                                        size_t j_op = random_itr.var2op(size_t(arg[0]));
    158158                                        CPPAD_ASSERT_UNKNOWN( op_usage[j_op] != no_usage );
    159159                                        if( op_usage[j_op] != csum_usage )
     
    278278                                par_usage[arg[1]] = true;
    279279                        if( (arg[0] & 2) == 0 )
    280                                 par_usage[arg[2]] = true;
     280                                par_usage[arg[3]] = true;
    281281                        CPPAD_ASSERT_UNKNOWN( 5 == NumArg(op) )
    282282                        break;
     
    295295                //
    296296                // corresponding parameter index
    297                 size_t i_par = dyn_ind2par_ind[i_dyn];
     297                size_t i_par = size_t( dyn_ind2par_ind[i_dyn] );
    298298                CPPAD_ASSERT_UNKNOWN( dyn_par_is[i_par] );
    299299                //
  • trunk/cppad/local/optimize/hash_code.hpp

    r4016 r4023  
    2828
    2929\param num_arg
    30 number of elements of arg to include in the hash code
    31 (num_arg <= 3).
     30number of elements of arg to include in the hash code.
    3231
    3332\param arg
     
    4039
    4140inline size_t optimize_hash_code(
    42         OpCode        op      ,
     41        opcode_t      op      ,
    4342        size_t        num_arg ,
    4443        const addr_t* arg     )
    4544{
    46         // there is only one case where num_arg == 3
    47         CPPAD_ASSERT_UNKNOWN( op == ErfOp || num_arg <= 2 );
    48         CPPAD_ASSERT_UNKNOWN( num_arg <= 3 );
    4945        size_t sum = size_t(op);
    5046        for(size_t i = 0; i < num_arg; i++)
  • trunk/cppad/local/optimize/match_op.hpp

    r4019 r4023  
    3535the output value of op_previous[current] is set to the
    3636matching operator index, otherwise it is left as is.
    37 Note that op_previous[current] < current.
     37Note that op_previous[current] < current and
     38op_previous[ op_previous[current] ] = 0.
    3839
    3940\param current
     
    138139        }
    139140        //
    140         size_t code = optimize_hash_code(op, num_arg, arg_match);
     141        size_t code = optimize_hash_code(opcode_t(op), num_arg, arg_match);
    141142        //
    142143        // iterator for the set with this hash code
     
    184185                std::swap( arg_match[0], arg_match[1] );
    185186                //
    186                 code      = optimize_hash_code(op, num_arg, arg_match);
     187                code      = optimize_hash_code(opcode_t(op), num_arg, arg_match);
    187188                sparse_list_const_iterator itr_swap(hash_table_op, code);
    188189                while( *itr_swap != num_op )
  • trunk/cppad/local/optimize/optimize_run.hpp

    r4022 r4023  
    1717# include <cppad/local/optimize/get_op_usage.hpp>
    1818# include <cppad/local/optimize/get_par_usage.hpp>
    19 # include <cppad/local/optimize/get_previous.hpp>
     19# include <cppad/local/optimize/get_dyn_previous.hpp>
     20# include <cppad/local/optimize/get_op_previous.hpp>
    2021# include <cppad/local/optimize/get_cexp_info.hpp>
    2122# include <cppad/local/optimize/size_pair.hpp>
     
    146147
    147148        // number of dynamic parameters
     149        size_t num_dynamic_par = play->num_dynamic_par();
     150
     151        // mapping from dynamic parameter index to paramemter index
     152        const pod_vector<addr_t>& dyn_ind2par_ind( play->dyn_ind2par_ind() );
     153
     154        // number of dynamic parameters
    148155        CPPAD_ASSERT_UNKNOWN( num_dynamic_ind <= play->num_dynamic_par () );
    149156
     
    167174        );
    168175        pod_vector<addr_t>        op_previous;
    169         get_previous(
     176        get_op_previous(
    170177                play,
    171178                random_itr,
     
    205212                par_usage
    206213        );
     214        pod_vector<addr_t> dyn_previous;
     215        get_dyn_previous(
     216                play                ,
     217                random_itr          ,
     218                par_usage           ,
     219                dyn_previous
     220        );
    207221        // -----------------------------------------------------------------------
    208222
     
    223237        {       vector<size_t> keys(num_cexp);
    224238                for(size_t i = 0; i < num_cexp; i++)
    225                         keys[i] = cexp_info[i].max_left_right;
     239                        keys[i] = size_t( cexp_info[i].max_left_right );
    226240                CppAD::index_sort(keys, cskip_order);
    227241        }
     
    255269        const pod_vector<addr_t>&   dyn_par_arg( play->dyn_par_arg() );
    256270        //
    257         // independent dynamic parameters are always incldued and must go at front
    258         //
     271        // -----------------------------------------------------------------------
    259272        // set new_par
    260273        pod_vector<addr_t> new_par( num_par );
     
    283296                //
    284297                if( par_usage[i_par] )
    285                 {       // value of this parameter
    286                         Base par       = play->GetPar(i_par);
    287                         //
    288                         if( op == cond_exp_dyn )
    289                         {       // cond_exp_dyn
    290                                 CPPAD_ASSERT_UNKNOWN( num_dynamic_ind <= i_par );
    291                                 CPPAD_ASSERT_UNKNOWN( n_arg = 5 );
    292                                 new_par[i_par] = rec->put_dyn_cond_exp(
    293                                         par                                ,   // par
    294                                         CompareOp( dyn_par_arg[i_arg + 0] ),   // cop
    295                                         new_par[ dyn_par_arg[i_arg + 1] ]  ,   // left
    296                                         new_par[ dyn_par_arg[i_arg + 2] ]  ,   // right
    297                                         new_par[ dyn_par_arg[i_arg + 3] ]  ,   // if_true
    298                                         new_par[ dyn_par_arg[i_arg + 4] ]      // if_false
    299                                 );
    300                         }
    301                         else if( n_arg == 1 )
    302                         {       // cases with one argument
    303                                 CPPAD_ASSERT_UNKNOWN( num_dynamic_ind <= i_par );
    304                                 new_par[i_par] = rec->put_dyn_par( par, op,
    305                                         new_par[ dyn_par_arg[i_arg + 0] ]
    306                                 );
    307                         }
    308                         else if( n_arg == 2 )
    309                         {       // cases with two arguments
    310                                 CPPAD_ASSERT_UNKNOWN( num_dynamic_ind <= i_par );
    311                                 new_par[i_par] = rec->put_dyn_par( par, op,
    312                                         new_par[ dyn_par_arg[i_arg + 0] ],
    313                                         new_par[ dyn_par_arg[i_arg + 1] ]
    314                                 );
     298                {       size_t j_dyn = size_t( dyn_previous[i_dyn] );
     299                        if( j_dyn != num_dynamic_par )
     300                        {       size_t j_par = size_t( dyn_ind2par_ind[j_dyn] );
     301                                CPPAD_ASSERT_UNKNOWN( j_par < i_par );
     302                                new_par[i_par] = new_par[j_par];
    315303                        }
    316304                        else
    317                         {       // independent dynamic parmaeter case
    318                                 CPPAD_ASSERT_UNKNOWN( op == ind_dyn )
    319                                 CPPAD_ASSERT_UNKNOWN( i_par < num_dynamic_ind );
    320                                 CPPAD_ASSERT_UNKNOWN( n_arg == 0 );
    321                                 new_par[i_par] = rec->put_dyn_par( par, op);
     305                        {
     306                                // value of this parameter
     307                                Base par       = play->GetPar(i_par);
     308                                //
     309                                if( op == cond_exp_dyn )
     310                                {       // cond_exp_dyn
     311                                        CPPAD_ASSERT_UNKNOWN( num_dynamic_ind <= i_par );
     312                                        CPPAD_ASSERT_UNKNOWN( n_arg = 5 );
     313                                        new_par[i_par] = rec->put_dyn_cond_exp(
     314                                                par                                ,   // par
     315                                                CompareOp( dyn_par_arg[i_arg + 0] ),   // cop
     316                                                new_par[ dyn_par_arg[i_arg + 1] ]  ,   // left
     317                                                new_par[ dyn_par_arg[i_arg + 2] ]  ,   // right
     318                                                new_par[ dyn_par_arg[i_arg + 3] ]  ,   // if_true
     319                                                new_par[ dyn_par_arg[i_arg + 4] ]      // if_false
     320                                        );
     321                                }
     322                                else if(  op == dis_dyn )
     323                                {       // dis_dyn
     324                                        CPPAD_ASSERT_UNKNOWN( n_arg = 2 );
     325                                        new_par[i_par] = rec->put_dyn_par(
     326                                                par                               ,  // par
     327                                                op                                ,  // op
     328                                                dyn_par_arg[i_arg + 0]            ,  // index
     329                                                new_par[ dyn_par_arg[i_arg + 1] ]    // parameter
     330                                        );
     331                                }
     332                                else if( n_arg == 1 )
     333                                {       // cases with one argument
     334                                        CPPAD_ASSERT_UNKNOWN( num_dynamic_ind <= i_par );
     335                                        new_par[i_par] = rec->put_dyn_par( par, op,
     336                                                new_par[ dyn_par_arg[i_arg + 0] ]
     337                                        );
     338                                }
     339                                else if( n_arg == 2 )
     340                                {       // cases with two arguments
     341                                        CPPAD_ASSERT_UNKNOWN( num_dynamic_ind <= i_par );
     342                                        new_par[i_par] = rec->put_dyn_par( par, op,
     343                                                new_par[ dyn_par_arg[i_arg + 0] ],
     344                                                new_par[ dyn_par_arg[i_arg + 1] ]
     345                                        );
     346                                }
     347                                else
     348                                {       // independent dynamic parmaeter case
     349                                        CPPAD_ASSERT_UNKNOWN( op == ind_dyn )
     350                                        CPPAD_ASSERT_UNKNOWN( i_par < num_dynamic_ind );
     351                                        CPPAD_ASSERT_UNKNOWN( n_arg == 0 );
     352                                        new_par[i_par] = rec->put_dyn_par( par, op);
     353                                }
    322354                        }
    323355                }
     
    325357                i_arg += n_arg;
    326358        }
     359        // -----------------------------------------------------------------------
     360        // There is an additional constant parameter for each cumulative summation
     361        // (that does not have a corresponding old parameter index).
    327362        // ------------------------------------------------------------------------
    328363        // initialize mapping from old VecAD index to new VecAD index
     
    341376                        {       // Put this VecAD vector in new recording
    342377                                CPPAD_ASSERT_UNKNOWN(length < num_vecad_ind);
    343                                 new_vecad_ind[j] = rec->PutVecInd(length);
     378                                new_vecad_ind[j] = rec->PutVecInd( addr_t(length) );
    344379                                for(size_t k = 1; k <= length; k++) new_vecad_ind[j+k] =
    345380                                        rec->PutVecInd(
     
    385420        {       // if non-zero, use previous result in place of this operator.
    386421                // Must get this information before writing new_op[i_op].
    387                 size_t previous = op_previous[i_op];
     422                size_t previous = size_t( op_previous[i_op] );
    388423                //
    389424                // zero is invalid except for new_op[0].
     
    415450                        {       size_t j = cskip_order[cskip_order_next];
    416451                                if( NumRes(op) > 0 )
    417                                         skip &= cexp_info[j].max_left_right < i_var;
     452                                        skip &= size_t( cexp_info[j].max_left_right ) < i_var;
    418453                                else
    419                                         skip &= cexp_info[j].max_left_right <= i_var;
     454                                        skip &= size_t( cexp_info[j].max_left_right ) <= i_var;
    420455                        }
    421456                        if( skip )
     
    427462                                if( skip )
    428463                                {       CPPAD_ASSERT_UNKNOWN( NumRes(CSkipOp) == 0 );
    429                                         size_t n_arg   = 7 + n_true + n_false;
     464                                        size_t n_arg   = 7 + size_t(n_true) + size_t(n_false);
    430465                                        // reserve space for the arguments to this operator but
    431466                                        // delay setting them until we have all the new addresses
     
    492527                        if( previous == 0 )
    493528                        {       //
    494                                 new_arg[0]   = new_var[ random_itr.var2op(arg[0]) ];
     529                                new_arg[0]   = new_var[ random_itr.var2op(size_t(arg[0])) ];
    495530                                rec->PutArg( new_arg[0] );
    496531                                //
     
    523558                        case SubvpOp:
    524559                        // check if this is the top of a csum connection
    525                         if( op_usage[ random_itr.var2op(arg[0]) ] == usage_t(csum_usage) )
     560                        if( op_usage[ random_itr.var2op(size_t(arg[0])) ] == usage_t(csum_usage) )
    526561                        {       CPPAD_ASSERT_UNKNOWN( previous == 0 );
    527562                                //
     
    566601                        {       //
    567602                                new_arg[0] = arg[0];
    568                                 new_arg[1] = new_var[ random_itr.var2op(arg[1]) ];
     603                                new_arg[1] = new_var[ random_itr.var2op(size_t(arg[1])) ];
    569604                                rec->PutArg( new_arg[0], new_arg[1] );
    570605                                //
     
    582617                        case AddpvOp:
    583618                        // check if this is the top of a csum connection
    584                         if( op_usage[ random_itr.var2op(arg[1]) ] == usage_t(csum_usage) )
     619                        if( op_usage[ random_itr.var2op(size_t(arg[1])) ] == usage_t(csum_usage) )
    585620                        {       CPPAD_ASSERT_UNKNOWN( previous == 0 );
    586621                                //
     
    625660                        // check if this is the top of a csum connection
    626661                        if(
    627                                 op_usage[ random_itr.var2op(arg[0]) ] == usage_t(csum_usage)
     662                                op_usage[ random_itr.var2op(size_t(arg[0])) ] == usage_t(csum_usage)
    628663                                ||
    629                                 op_usage[ random_itr.var2op(arg[1]) ] == usage_t(csum_usage)
     664                                op_usage[ random_itr.var2op(size_t(arg[1])) ] == usage_t(csum_usage)
    630665                        )
    631666                        {       CPPAD_ASSERT_UNKNOWN( previous == 0 );
     
    674709                        for(size_t i = 2; i < 6; i++)
    675710                        {       if( arg[1] & mask )
    676                                 {       new_arg[i] = new_var[ random_itr.var2op(arg[i]) ];
     711                                {       new_arg[i] = new_var[ random_itr.var2op(size_t(arg[i])) ];
    677712                                        CPPAD_ASSERT_UNKNOWN(
    678713                                                size_t(new_arg[i]) < num_var
     
    698733                        if( conditional_skip )
    699734                        {       CPPAD_ASSERT_UNKNOWN( cexp_next < num_cexp );
    700                                 CPPAD_ASSERT_UNKNOWN( cexp_info[cexp_next].i_op == i_op );
    701                                 cskip_new[ cexp_next ].left  = new_arg[2];
    702                                 cskip_new[ cexp_next ].right = new_arg[3];
     735                                CPPAD_ASSERT_UNKNOWN(
     736                                        size_t( cexp_info[cexp_next].i_op ) == i_op
     737                                );
     738                                cskip_new[ cexp_next ].left  = size_t( new_arg[2] );
     739                                cskip_new[ cexp_next ].right = size_t( new_arg[3] );
    703740                                ++cexp_next;
    704741