Changeset 3324


Ignore:
Timestamp:
Sep 12, 2014 8:14:53 AM (6 years ago)
Author:
bradbell
Message:

merge trunk changes into cache

Location:
branches/cache
Files:
42 edited

Legend:

Unmodified
Added
Removed
  • branches/cache

  • branches/cache/CMakeLists.txt

    r3309 r3324  
    172172# cppad_cxx_flags_skip_eigen
    173173STRING(REGEX REPLACE
    174         "(.*)-Wshadow(.*)"         "\\1 \\2"
     174        "(.*)-Wshadow(.*)"         "\\1-Wno-shadow\\2"
    175175        cppad_cxx_flags_eigen "${cppad_cxx_flags}"
    176176)
     
    179179# cppad_cxx_flags_skip_fadbad
    180180STRING(REGEX REPLACE
    181         "(.*)-Wshadow(.*)"         "\\1 \\2"
     181        "(.*)-Wshadow(.*)"         "\\1-Wno-shadow\\2"
    182182        cppad_cxx_flags_fadbad "${cppad_cxx_flags}"
    183183)
  • branches/cache/bin/check_svn_id.sh

    r3308 r3324  
    2525        -e '/cppad\/local\/config.h.in$/d' \
    2626        -e '/^makefile.in$/d' \
     27        -e '/^svn_commit.sh$/d' \
    2728        -e '/\/makefile.in$/d' `
    2829#
  • branches/cache/bin/gpl_license.sh

    r3092 r3324  
    131131                > /dev/null
    132132        then
    133                 if [ "$name" != 'config.h.in' ] && [ "$name" != 'colpack.sh' ]
     133                if \
     134                [ "$name" != 'config.h.in' ] && \
     135                [ "$name" != 'colpack.sh' ]  && \
     136                [ "$name" != 'svn_commit.sh' ]
    134137                then
    135138                        echo "Cannot change EPL to GPL for $archive_name/$file"
  • branches/cache/cmake/add_cppad_cxx_flags.cmake

    r2859 r3324  
    3030                IF( ${target_name} MATCHES ".*_${package}$" )
    3131                        SET(flags "${cppad_cxx_flags_${package}}")
     32                        MESSAGE(STATUS
     33                                "${target_name} cxx_flags = ${cppad_cxx_flags_${package}}"
     34                        )
    3235                ENDIF( ${target_name} MATCHES ".*_${package}$" )
     36                IF( ${target_name} MATCHES ".*_${package}_lib$" )
     37                        SET(flags "${cppad_cxx_flags_${package}}")
     38                        MESSAGE(STATUS
     39                                "${target_name} cxx_flags = ${cppad_cxx_flags_${package}}"
     40                        )
     41                ENDIF( ${target_name} MATCHES ".*_${package}_lib$" )
    3342        ENDFOREACH(package)
    3443        IF( flags )
  • branches/cache/cppad/local/abs_op.hpp

    r3301 r3324  
    4343        CPPAD_ASSERT_UNKNOWN( NumArg(AbsOp) == 1 );
    4444        CPPAD_ASSERT_UNKNOWN( NumRes(AbsOp) == 1 );
    45         CPPAD_ASSERT_UNKNOWN( i_x < i_z );
    4645        CPPAD_ASSERT_UNKNOWN( q < cap_order );
    4746        CPPAD_ASSERT_UNKNOWN( p <= q );
     
    7776        CPPAD_ASSERT_UNKNOWN( NumArg(AbsOp) == 1 );
    7877        CPPAD_ASSERT_UNKNOWN( NumRes(AbsOp) == 1 );
    79         CPPAD_ASSERT_UNKNOWN( i_x < i_z );
    8078        CPPAD_ASSERT_UNKNOWN( 0 < q );
    8179        CPPAD_ASSERT_UNKNOWN( q < cap_order );
     
    112110        CPPAD_ASSERT_UNKNOWN( NumArg(AbsOp) == 1 );
    113111        CPPAD_ASSERT_UNKNOWN( NumRes(AbsOp) == 1 );
    114         CPPAD_ASSERT_UNKNOWN( i_x < i_z );
    115112        CPPAD_ASSERT_UNKNOWN( 0 < cap_order );
    116113
     
    146143        CPPAD_ASSERT_UNKNOWN( NumArg(AbsOp) == 1 );
    147144        CPPAD_ASSERT_UNKNOWN( NumRes(AbsOp) == 1 );
    148         CPPAD_ASSERT_UNKNOWN( i_x < i_z );
    149145        CPPAD_ASSERT_UNKNOWN( d < cap_order );
    150146        CPPAD_ASSERT_UNKNOWN( d < nc_partial );
  • branches/cache/cppad/local/acos_op.hpp

    r3301 r3324  
    5050        CPPAD_ASSERT_UNKNOWN( NumArg(AcosOp) == 1 );
    5151        CPPAD_ASSERT_UNKNOWN( NumRes(AcosOp) == 2 );
    52         CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
    5352        CPPAD_ASSERT_UNKNOWN( q < cap_order );
    5453        CPPAD_ASSERT_UNKNOWN( p <= q );
     
    115114        CPPAD_ASSERT_UNKNOWN( NumArg(AcosOp) == 1 );
    116115        CPPAD_ASSERT_UNKNOWN( NumRes(AcosOp) == 2 );
    117         CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
    118116        CPPAD_ASSERT_UNKNOWN( 0 < q );
    119117        CPPAD_ASSERT_UNKNOWN( q < cap_order );
     
    167165        CPPAD_ASSERT_UNKNOWN( NumArg(AcosOp) == 1 );
    168166        CPPAD_ASSERT_UNKNOWN( NumRes(AcosOp) == 2 );
    169         CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
    170167        CPPAD_ASSERT_UNKNOWN( 0 < cap_order );
    171168
     
    207204        CPPAD_ASSERT_UNKNOWN( NumArg(AcosOp) == 1 );
    208205        CPPAD_ASSERT_UNKNOWN( NumRes(AcosOp) == 2 );
    209         CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
    210206        CPPAD_ASSERT_UNKNOWN( d < cap_order );
    211207        CPPAD_ASSERT_UNKNOWN( d < nc_partial );
  • branches/cache/cppad/local/add_op.hpp

    r3301 r3324  
    4848        CPPAD_ASSERT_UNKNOWN( NumArg(AddvvOp) == 2 );
    4949        CPPAD_ASSERT_UNKNOWN( NumRes(AddvvOp) == 1 );
    50         CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < i_z );
    51         CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
    5250        CPPAD_ASSERT_UNKNOWN( q < cap_order );
    5351        CPPAD_ASSERT_UNKNOWN( p <= q  );
     
    8886        CPPAD_ASSERT_UNKNOWN( NumArg(AddvvOp) == 2 );
    8987        CPPAD_ASSERT_UNKNOWN( NumRes(AddvvOp) == 1 );
    90         CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < i_z );
    91         CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
    9288        CPPAD_ASSERT_UNKNOWN( q < cap_order );
    9389        CPPAD_ASSERT_UNKNOWN( 0 < q  );
     
    129125        CPPAD_ASSERT_UNKNOWN( NumArg(AddvvOp) == 2 );
    130126        CPPAD_ASSERT_UNKNOWN( NumRes(AddvvOp) == 1 );
    131         CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < i_z );
    132         CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
    133127
    134128        // Taylor coefficients corresponding to arguments and result
     
    168162        CPPAD_ASSERT_UNKNOWN( NumArg(AddvvOp) == 2 );
    169163        CPPAD_ASSERT_UNKNOWN( NumRes(AddvvOp) == 1 );
    170         CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < i_z );
    171         CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
    172164        CPPAD_ASSERT_UNKNOWN( d < cap_order );
    173165        CPPAD_ASSERT_UNKNOWN( d < nc_partial );
     
    213205        CPPAD_ASSERT_UNKNOWN( NumArg(AddpvOp) == 2 );
    214206        CPPAD_ASSERT_UNKNOWN( NumRes(AddpvOp) == 1 );
    215         CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
    216207        CPPAD_ASSERT_UNKNOWN( q < cap_order );
    217208        CPPAD_ASSERT_UNKNOWN( p <= q );
     
    255246        CPPAD_ASSERT_UNKNOWN( NumArg(AddpvOp) == 2 );
    256247        CPPAD_ASSERT_UNKNOWN( NumRes(AddpvOp) == 1 );
    257         CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
    258248        CPPAD_ASSERT_UNKNOWN( 0 < q );
    259249        CPPAD_ASSERT_UNKNOWN( q < cap_order );
     
    292282        CPPAD_ASSERT_UNKNOWN( NumArg(AddpvOp) == 2 );
    293283        CPPAD_ASSERT_UNKNOWN( NumRes(AddpvOp) == 1 );
    294         CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
    295284
    296285        // Paraemter value
     
    331320        CPPAD_ASSERT_UNKNOWN( NumArg(AddvvOp) == 2 );
    332321        CPPAD_ASSERT_UNKNOWN( NumRes(AddvvOp) == 1 );
    333         CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
    334322        CPPAD_ASSERT_UNKNOWN( d < cap_order );
    335323        CPPAD_ASSERT_UNKNOWN( d < nc_partial );
  • branches/cache/cppad/local/asin_op.hpp

    r3301 r3324  
    5050        CPPAD_ASSERT_UNKNOWN( NumArg(AsinOp) == 1 );
    5151        CPPAD_ASSERT_UNKNOWN( NumRes(AsinOp) == 2 );
    52         CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
    5352        CPPAD_ASSERT_UNKNOWN( q < cap_order );
    5453        CPPAD_ASSERT_UNKNOWN( p <= q );
     
    115114        CPPAD_ASSERT_UNKNOWN( NumArg(AcosOp) == 1 );
    116115        CPPAD_ASSERT_UNKNOWN( NumRes(AcosOp) == 2 );
    117         CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
    118116        CPPAD_ASSERT_UNKNOWN( 0 < q );
    119117        CPPAD_ASSERT_UNKNOWN( q < cap_order );
     
    167165        CPPAD_ASSERT_UNKNOWN( NumArg(AsinOp) == 1 );
    168166        CPPAD_ASSERT_UNKNOWN( NumRes(AsinOp) == 2 );
    169         CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
    170167        CPPAD_ASSERT_UNKNOWN( 0 < cap_order );
    171168
     
    207204        CPPAD_ASSERT_UNKNOWN( NumArg(AsinOp) == 1 );
    208205        CPPAD_ASSERT_UNKNOWN( NumRes(AsinOp) == 2 );
    209         CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
    210206        CPPAD_ASSERT_UNKNOWN( d < cap_order );
    211207        CPPAD_ASSERT_UNKNOWN( d < nc_partial );
  • branches/cache/cppad/local/atan_op.hpp

    r3301 r3324  
    5050        CPPAD_ASSERT_UNKNOWN( NumArg(AtanOp) == 1 );
    5151        CPPAD_ASSERT_UNKNOWN( NumRes(AtanOp) == 2 );
    52         CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
    5352        CPPAD_ASSERT_UNKNOWN( q < cap_order );
    5453        CPPAD_ASSERT_UNKNOWN( p <= q );
     
    107106        CPPAD_ASSERT_UNKNOWN( NumArg(AtanOp) == 1 );
    108107        CPPAD_ASSERT_UNKNOWN( NumRes(AtanOp) == 2 );
    109         CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
    110108        CPPAD_ASSERT_UNKNOWN( 0 < q );
    111109        CPPAD_ASSERT_UNKNOWN( q < cap_order );
     
    154152        CPPAD_ASSERT_UNKNOWN( NumArg(AtanOp) == 1 );
    155153        CPPAD_ASSERT_UNKNOWN( NumRes(AtanOp) == 2 );
    156         CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
    157154        CPPAD_ASSERT_UNKNOWN( 0 < cap_order );
    158155
     
    194191        CPPAD_ASSERT_UNKNOWN( NumArg(AtanOp) == 1 );
    195192        CPPAD_ASSERT_UNKNOWN( NumRes(AtanOp) == 2 );
    196         CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
    197193        CPPAD_ASSERT_UNKNOWN( d < cap_order );
    198194        CPPAD_ASSERT_UNKNOWN( d < nc_partial );
  • branches/cache/cppad/local/cond_op.hpp

    r3301 r3324  
    9595\li arg[1] != 0; i.e., not all of y_0, y_1, y_2, y_3 are parameters.
    9696\li For j = 0, 1, 2, 3 if y_j is a parameter, arg[2+j] < num_par.
    97 \li For j = 0, 1, 2, 3 if y_j is a variable, arg[2+j] < iz.
    9897<!-- end conditional_exp_op -->
    9998*/
     
    177176\li arg[1] != 0; i.e., not all of y_0, y_1, y_2, y_3 are parameters.
    178177\li For j = 0, 1, 2, 3 if y_j is a parameter, arg[2+j] < num_par.
    179 \li For j = 0, 1, 2, 3 if y_j is a variable, arg[2+j] < iz.
    180178<!-- end sparse_conditional_exp_op -->
    181179*/
     
    265263\li arg[1] != 0; i.e., not all of y_0, y_1, y_2, y_3 are parameters.
    266264\li For j = 0, 1, 2, 3 if y_j is a parameter, arg[2+j] < num_par.
    267 \li For j = 0, 1, 2, 3 if y_j is a variable, arg[2+j] < iz.
    268265<!-- end conditional_exp_op -->
    269266
     
    310307
    311308        if( arg[1] & 1 )
    312         {       CPPAD_ASSERT_UNKNOWN( size_t(arg[2]) < i_z );
     309        {
    313310                y_0 = taylor[ arg[2] * cap_order + 0 ];
    314311        }
     
    318315        }
    319316        if( arg[1] & 2 )
    320         {       CPPAD_ASSERT_UNKNOWN( size_t(arg[3]) < i_z );
     317        {
    321318                y_1 = taylor[ arg[3] * cap_order + 0 ];
    322319        }
     
    327324        if( p == 0 )
    328325        {       if( arg[1] & 4 )
    329                 {       CPPAD_ASSERT_UNKNOWN( size_t(arg[4]) < i_z );
     326                {
    330327                        y_2 = taylor[ arg[4] * cap_order + 0 ];
    331328                }
     
    335332                }
    336333                if( arg[1] & 8 )
    337                 {       CPPAD_ASSERT_UNKNOWN( size_t(arg[5]) < i_z );
     334                {
    338335                        y_3 = taylor[ arg[5] * cap_order + 0 ];
    339336                }
     
    353350        for(size_t d = p; d <= q; d++)
    354351        {       if( arg[1] & 4 )
    355                 {       CPPAD_ASSERT_UNKNOWN( size_t(arg[4]) < i_z );
     352                {
    356353                        y_2 = taylor[ arg[4] * cap_order + d];
    357354                }
    358355                else    y_2 = zero;
    359356                if( arg[1] & 8 )
    360                 {       CPPAD_ASSERT_UNKNOWN( size_t(arg[5]) < i_z );
     357                {
    361358                        y_3 = taylor[ arg[5] * cap_order + d];
    362359                }
     
    449446\li arg[1] != 0; i.e., not all of y_0, y_1, y_2, y_3 are parameters.
    450447\li For j = 0, 1, 2, 3 if y_j is a parameter, arg[2+j] < num_par.
    451 \li For j = 0, 1, 2, 3 if y_j is a variable, arg[2+j] < iz.
    452448<!-- end conditional_exp_op -->
    453449
     
    506502
    507503        if( arg[1] & 1 )
    508         {       CPPAD_ASSERT_UNKNOWN( size_t(arg[2]) < i_z );
     504        {
    509505                y_0 = taylor[ arg[2] * num_taylor_per_var + 0 ];
    510506        }
     
    514510        }
    515511        if( arg[1] & 2 )
    516         {       CPPAD_ASSERT_UNKNOWN( size_t(arg[3]) < i_z );
     512        {
    517513                y_1 = taylor[ arg[3] * num_taylor_per_var + 0 ];
    518514        }
     
    524520        for(size_t ell = 0; ell < r; ell++)
    525521        {       if( arg[1] & 4 )
    526                 {       CPPAD_ASSERT_UNKNOWN( size_t(arg[4]) < i_z );
     522                {
    527523                        y_2 = taylor[ arg[4] * num_taylor_per_var + m + ell];
    528524                }
    529525                else    y_2 = zero;
    530526                if( arg[1] & 8 )
    531                 {       CPPAD_ASSERT_UNKNOWN( size_t(arg[5]) < i_z );
     527                {
    532528                        y_3 = taylor[ arg[5] * num_taylor_per_var + m + ell];
    533529                }
     
    620616\li arg[1] != 0; i.e., not all of y_0, y_1, y_2, y_3 are parameters.
    621617\li For j = 0, 1, 2, 3 if y_j is a parameter, arg[2+j] < num_par.
    622 \li For j = 0, 1, 2, 3 if y_j is a variable, arg[2+j] < iz.
    623618<!-- end conditional_exp_op -->
    624619
     
    650645
    651646        if( arg[1] & 1 )
    652         {       CPPAD_ASSERT_UNKNOWN( size_t(arg[2]) < i_z );
     647        {
    653648                y_0 = taylor[ arg[2] * cap_order + 0 ];
    654649        }
     
    658653        }
    659654        if( arg[1] & 2 )
    660         {       CPPAD_ASSERT_UNKNOWN( size_t(arg[3]) < i_z );
     655        {
    661656                y_1 = taylor[ arg[3] * cap_order + 0 ];
    662657        }
     
    666661        }
    667662        if( arg[1] & 4 )
    668         {       CPPAD_ASSERT_UNKNOWN( size_t(arg[4]) < i_z );
     663        {
    669664                y_2 = taylor[ arg[4] * cap_order + 0 ];
    670665        }
     
    674669        }
    675670        if( arg[1] & 8 )
    676         {       CPPAD_ASSERT_UNKNOWN( size_t(arg[5]) < i_z );
     671        {
    677672                y_3 = taylor[ arg[5] * cap_order + 0 ];
    678673        }
     
    776771\li arg[1] != 0; i.e., not all of y_0, y_1, y_2, y_3 are parameters.
    777772\li For j = 0, 1, 2, 3 if y_j is a parameter, arg[2+j] < num_par.
    778 \li For j = 0, 1, 2, 3 if y_j is a variable, arg[2+j] < iz.
    779773<!-- end conditional_exp_op -->
    780774
     
    841835        pz = partial + i_z * nc_partial + 0;
    842836        if( arg[1] & 1 )
    843         {       CPPAD_ASSERT_UNKNOWN( size_t(arg[2]) < i_z );
     837        {
    844838                y_0 = taylor[ arg[2] * cap_order + 0 ];
    845839        }
     
    849843        }
    850844        if( arg[1] & 2 )
    851         {       CPPAD_ASSERT_UNKNOWN( size_t(arg[3]) < i_z );
     845        {
    852846                y_1 = taylor[ arg[3] * cap_order + 0 ];
    853847        }
     
    857851        }
    858852        if( arg[1] & 4 )
    859         {       CPPAD_ASSERT_UNKNOWN( size_t(arg[4]) < i_z );
     853        {
    860854                py_2 = partial + arg[4] * nc_partial;
    861855                size_t j = d + 1;
     
    871865        }
    872866        if( arg[1] & 8 )
    873         {       CPPAD_ASSERT_UNKNOWN( size_t(arg[5]) < i_z );
     867        {
    874868                py_3 = partial + arg[5] * nc_partial;
    875869                size_t j = d + 1;
     
    955949\li arg[1] != 0; i.e., not all of y_0, y_1, y_2, y_3 are parameters.
    956950\li For j = 0, 1, 2, 3 if y_j is a parameter, arg[2+j] < num_par.
    957 \li For j = 0, 1, 2, 3 if y_j is a variable, arg[2+j] < iz.
    958951<!-- end sparse_conditional_exp_op -->
    959952
     
    991984# ifndef NDEBUG
    992985        if( arg[1] & 1 )
    993         {       CPPAD_ASSERT_UNKNOWN( size_t(arg[2]) < i_z );
     986        {
    994987        }
    995988        else
     
    997990        }
    998991        if( arg[1] & 2 )
    999         {       CPPAD_ASSERT_UNKNOWN( size_t(arg[3]) < i_z );
     992        {
    1000993        }
    1001994        else
     
    1004997# endif
    1005998        if( arg[1] & 4 )
    1006         {       CPPAD_ASSERT_UNKNOWN( size_t(arg[4]) < i_z );
     999        {
    10071000                if( arg[1] & 8 )
    1008                 {       CPPAD_ASSERT_UNKNOWN( size_t(arg[5]) < i_z );
     1001                {
    10091002                        sparsity.binary_union(i_z, arg[4], arg[5], sparsity);
    10101003                }
     
    10171010        {       CPPAD_ASSERT_UNKNOWN( size_t(arg[4]) < num_par );
    10181011                if( arg[1] & 8 )
    1019                 {       CPPAD_ASSERT_UNKNOWN( size_t(arg[5]) < i_z );
     1012                {
    10201013                        sparsity.assignment(i_z, arg[5], sparsity);
    10211014                }
     
    11041097\li arg[1] != 0; i.e., not all of y_0, y_1, y_2, y_3 are parameters.
    11051098\li For j = 0, 1, 2, 3 if y_j is a parameter, arg[2+j] < num_par.
    1106 \li For j = 0, 1, 2, 3 if y_j is a variable, arg[2+j] < iz.
    11071099<!-- end sparse_conditional_exp_op -->
    11081100
     
    11511143# ifndef NDEBUG
    11521144        if( arg[1] & 1 )
    1153         {       CPPAD_ASSERT_UNKNOWN( size_t(arg[2]) < i_z );
     1145        {
    11541146        }
    11551147        else
     
    11571149        }
    11581150        if( arg[1] & 2 )
    1159         {       CPPAD_ASSERT_UNKNOWN( size_t(arg[3]) < i_z );
     1151        {
    11601152        }
    11611153        else
     
    11711163        if( nz_compare )
    11721164        {       if( arg[1] & 1 )
    1173                 {       CPPAD_ASSERT_UNKNOWN( size_t(arg[2]) < i_z );
     1165                {
    11741166                        sparsity.binary_union(arg[2], arg[2], i_z, sparsity);
    11751167                }
    11761168                if( arg[1] & 2 )
    1177                 {       CPPAD_ASSERT_UNKNOWN( size_t(arg[3]) < i_z );
     1169                {
    11781170                        sparsity.binary_union(arg[3], arg[3], i_z, sparsity);
    11791171                }
     
    11811173        // --------------------------------------------------------------------
    11821174        if( arg[1] & 4 )
    1183         {       CPPAD_ASSERT_UNKNOWN( size_t(arg[4]) < i_z );
     1175        {
    11841176                sparsity.binary_union(arg[4], arg[4], i_z, sparsity);
    11851177        }
    11861178        if( arg[1] & 8 )
    1187         {       CPPAD_ASSERT_UNKNOWN( size_t(arg[5]) < i_z );
     1179        {
    11881180                sparsity.binary_union(arg[5], arg[5], i_z, sparsity);
    11891181        }
     
    12671259\li arg[1] != 0; i.e., not all of y_0, y_1, y_2, y_3 are parameters.
    12681260\li For j = 0, 1, 2, 3 if y_j is a parameter, arg[2+j] < num_par.
    1269 \li For j = 0, 1, 2, 3 if y_j is a variable, arg[2+j] < iz.
    12701261<!-- end sparse_conditional_exp_op -->
    12711262
     
    13311322# ifndef NDEBUG
    13321323        if( arg[1] & 1 )
    1333         {       CPPAD_ASSERT_UNKNOWN( size_t(arg[2]) < i_z );
     1324        {
    13341325        }
    13351326        else
     
    13371328        }
    13381329        if( arg[1] & 2 )
    1339         {       CPPAD_ASSERT_UNKNOWN( size_t(arg[3]) < i_z );
     1330        {
    13401331        }
    13411332        else
     
    13501341# endif
    13511342        if( arg[1] & 4 )
    1352         {       CPPAD_ASSERT_UNKNOWN( size_t(arg[4]) < i_z );
     1343        {
    13531344
    13541345                hes_sparsity.binary_union(arg[4], arg[4], i_z, hes_sparsity);
     
    13561347        }
    13571348        if( arg[1] & 8 )
    1358         {       CPPAD_ASSERT_UNKNOWN( size_t(arg[5]) < i_z );
     1349        {
    13591350
    13601351                hes_sparsity.binary_union(arg[5], arg[5], i_z, hes_sparsity);
  • branches/cache/cppad/local/cos_op.hpp

    r3301 r3324  
    4949        CPPAD_ASSERT_UNKNOWN( NumArg(CosOp) == 1 );
    5050        CPPAD_ASSERT_UNKNOWN( NumRes(CosOp) == 2 );
    51         CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
    5251        CPPAD_ASSERT_UNKNOWN( q < cap_order );
    5352        CPPAD_ASSERT_UNKNOWN( p <= q );
     
    108107        CPPAD_ASSERT_UNKNOWN( NumArg(CosOp) == 1 );
    109108        CPPAD_ASSERT_UNKNOWN( NumRes(CosOp) == 2 );
    110         CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
    111109        CPPAD_ASSERT_UNKNOWN( 0 < q );
    112110        CPPAD_ASSERT_UNKNOWN( q < cap_order );
     
    160158        CPPAD_ASSERT_UNKNOWN( NumArg(CosOp) == 1 );
    161159        CPPAD_ASSERT_UNKNOWN( NumRes(CosOp) == 2 );
    162         CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
    163160        CPPAD_ASSERT_UNKNOWN( 0 < cap_order );
    164161
     
    200197        CPPAD_ASSERT_UNKNOWN( NumArg(CosOp) == 1 );
    201198        CPPAD_ASSERT_UNKNOWN( NumRes(CosOp) == 2 );
    202         CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
    203199        CPPAD_ASSERT_UNKNOWN( d < cap_order );
    204200        CPPAD_ASSERT_UNKNOWN( d < nc_partial );
  • branches/cache/cppad/local/cosh_op.hpp

    r3301 r3324  
    5050        CPPAD_ASSERT_UNKNOWN( NumArg(CoshOp) == 1 );
    5151        CPPAD_ASSERT_UNKNOWN( NumRes(CoshOp) == 2 );
    52         CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
    5352        CPPAD_ASSERT_UNKNOWN( q < cap_order );
    5453        CPPAD_ASSERT_UNKNOWN( p <= q );
     
    108107        CPPAD_ASSERT_UNKNOWN( NumArg(CoshOp) == 1 );
    109108        CPPAD_ASSERT_UNKNOWN( NumRes(CoshOp) == 2 );
    110         CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
    111109        CPPAD_ASSERT_UNKNOWN( 0 < q );
    112110        CPPAD_ASSERT_UNKNOWN( q < cap_order );
     
    160158        CPPAD_ASSERT_UNKNOWN( NumArg(CoshOp) == 1 );
    161159        CPPAD_ASSERT_UNKNOWN( NumRes(CoshOp) == 2 );
    162         CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
    163160        CPPAD_ASSERT_UNKNOWN( 0 < cap_order );
    164161
     
    200197        CPPAD_ASSERT_UNKNOWN( NumArg(CoshOp) == 1 );
    201198        CPPAD_ASSERT_UNKNOWN( NumRes(CoshOp) == 2 );
    202         CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
    203199        CPPAD_ASSERT_UNKNOWN( d < cap_order );
    204200        CPPAD_ASSERT_UNKNOWN( d < nc_partial );
  • branches/cache/cppad/local/cppad_assert.hpp

    r3232 r3324  
    198198# endif
    199199
    200 # endif
     200/*!
     201\def CPPAD_ASSERT_ARG_BEFORE_RESULT
     202Check that operator arguments come before result.
     203
     204If \c NDEBUG is defined, this macro has no effect,
     205otherwise it calls the function assert_arg_before_result.
     206*/
     207# ifdef NDEBUG
     208# define CPPAD_ASSERT_ARG_BEFORE_RESULT(op, arg, result)
     209# else
     210# define CPPAD_ASSERT_ARG_BEFORE_RESULT(op, arg, result) \
     211        assert_arg_before_result(op, arg, result)
     212       
     213# endif
     214
     215# endif
  • branches/cache/cppad/local/discrete_op.hpp

    r3301 r3324  
    8585\li NumArg(op) == 2
    8686\li NumRes(op) == 1
    87 \li arg[1] < i_z
    8887\li q < cap_order
    8988\li 0 < r
     
    102101        CPPAD_ASSERT_UNKNOWN( NumArg(DisOp) == 2 );
    103102        CPPAD_ASSERT_UNKNOWN( NumRes(DisOp) == 1 );
    104         CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
    105103        CPPAD_ASSERT_UNKNOWN( q < cap_order );
    106104        CPPAD_ASSERT_UNKNOWN( 0 < r );
  • branches/cache/cppad/local/div_op.hpp

    r3301 r3324  
    4848        CPPAD_ASSERT_UNKNOWN( NumArg(DivvvOp) == 2 );
    4949        CPPAD_ASSERT_UNKNOWN( NumRes(DivvvOp) == 1 );
    50         CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < i_z );
    51         CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
    5250        CPPAD_ASSERT_UNKNOWN( q < cap_order );
    5351        CPPAD_ASSERT_UNKNOWN( p <= q );
     
    9694        CPPAD_ASSERT_UNKNOWN( NumArg(DivvvOp) == 2 );
    9795        CPPAD_ASSERT_UNKNOWN( NumRes(DivvvOp) == 1 );
    98         CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < i_z );
    99         CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
    10096        CPPAD_ASSERT_UNKNOWN( 0 < q );
    10197        CPPAD_ASSERT_UNKNOWN( q < cap_order );
     
    145141        CPPAD_ASSERT_UNKNOWN( NumArg(DivvvOp) == 2 );
    146142        CPPAD_ASSERT_UNKNOWN( NumRes(DivvvOp) == 1 );
    147         CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < i_z );
    148         CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
    149143
    150144        // Taylor coefficients corresponding to arguments and result
     
    184178        CPPAD_ASSERT_UNKNOWN( NumArg(DivvvOp) == 2 );
    185179        CPPAD_ASSERT_UNKNOWN( NumRes(DivvvOp) == 1 );
    186         CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < i_z );
    187         CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
    188180        CPPAD_ASSERT_UNKNOWN( d < cap_order );
    189181        CPPAD_ASSERT_UNKNOWN( d < nc_partial );
     
    245237        CPPAD_ASSERT_UNKNOWN( NumArg(DivpvOp) == 2 );
    246238        CPPAD_ASSERT_UNKNOWN( NumRes(DivpvOp) == 1 );
    247         CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
    248239        CPPAD_ASSERT_UNKNOWN( q < cap_order );
    249240        CPPAD_ASSERT_UNKNOWN( p <= q );
     
    296287        CPPAD_ASSERT_UNKNOWN( NumArg(DivpvOp) == 2 );
    297288        CPPAD_ASSERT_UNKNOWN( NumRes(DivpvOp) == 1 );
    298         CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
    299289        CPPAD_ASSERT_UNKNOWN( 0 < q );
    300290        CPPAD_ASSERT_UNKNOWN( q < cap_order );
     
    340330        CPPAD_ASSERT_UNKNOWN( NumArg(DivpvOp) == 2 );
    341331        CPPAD_ASSERT_UNKNOWN( NumRes(DivpvOp) == 1 );
    342         CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
    343332
    344333        // Paraemter value
     
    379368        CPPAD_ASSERT_UNKNOWN( NumArg(DivvvOp) == 2 );
    380369        CPPAD_ASSERT_UNKNOWN( NumRes(DivvvOp) == 1 );
    381         CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
    382370        CPPAD_ASSERT_UNKNOWN( d < cap_order );
    383371        CPPAD_ASSERT_UNKNOWN( d < nc_partial );
     
    438426        CPPAD_ASSERT_UNKNOWN( NumArg(DivvpOp) == 2 );
    439427        CPPAD_ASSERT_UNKNOWN( NumRes(DivvpOp) == 1 );
    440         CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < i_z );
    441428        CPPAD_ASSERT_UNKNOWN( q < cap_order );
    442429        CPPAD_ASSERT_UNKNOWN( p <= q );
     
    480467        CPPAD_ASSERT_UNKNOWN( NumArg(DivvpOp) == 2 );
    481468        CPPAD_ASSERT_UNKNOWN( NumRes(DivvpOp) == 1 );
    482         CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < i_z );
    483469        CPPAD_ASSERT_UNKNOWN( q < cap_order );
    484470        CPPAD_ASSERT_UNKNOWN( 0 < q  );
     
    524510        CPPAD_ASSERT_UNKNOWN( NumArg(DivvpOp) == 2 );
    525511        CPPAD_ASSERT_UNKNOWN( NumRes(DivvpOp) == 1 );
    526         CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < i_z );
    527512
    528513        // Parameter value
     
    563548        CPPAD_ASSERT_UNKNOWN( NumArg(DivvpOp) == 2 );
    564549        CPPAD_ASSERT_UNKNOWN( NumRes(DivvpOp) == 1 );
    565         CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < i_z );
    566550        CPPAD_ASSERT_UNKNOWN( d < cap_order );
    567551        CPPAD_ASSERT_UNKNOWN( d < nc_partial );
  • branches/cache/cppad/local/exp_op.hpp

    r3301 r3324  
    4444        CPPAD_ASSERT_UNKNOWN( NumArg(ExpOp) == 1 );
    4545        CPPAD_ASSERT_UNKNOWN( NumRes(ExpOp) == 1 );
    46         CPPAD_ASSERT_UNKNOWN( i_x < i_z );
    4746        CPPAD_ASSERT_UNKNOWN( q < cap_order );
    4847        CPPAD_ASSERT_UNKNOWN( p <= q );
     
    8988        CPPAD_ASSERT_UNKNOWN( NumArg(ExpOp) == 1 );
    9089        CPPAD_ASSERT_UNKNOWN( NumRes(ExpOp) == 1 );
    91         CPPAD_ASSERT_UNKNOWN( i_x < i_z );
    9290        CPPAD_ASSERT_UNKNOWN( q < cap_order );
    9391        CPPAD_ASSERT_UNKNOWN( 0 < q );
     
    127125        CPPAD_ASSERT_UNKNOWN( NumArg(ExpOp) == 1 );
    128126        CPPAD_ASSERT_UNKNOWN( NumRes(ExpOp) == 1 );
    129         CPPAD_ASSERT_UNKNOWN( i_x < i_z );
    130127        CPPAD_ASSERT_UNKNOWN( 0 < cap_order );
    131128
     
    160157        CPPAD_ASSERT_UNKNOWN( NumArg(ExpOp) == 1 );
    161158        CPPAD_ASSERT_UNKNOWN( NumRes(ExpOp) == 1 );
    162         CPPAD_ASSERT_UNKNOWN( i_x < i_z );
    163159        CPPAD_ASSERT_UNKNOWN( d < cap_order );
    164160        CPPAD_ASSERT_UNKNOWN( d < nc_partial );
  • branches/cache/cppad/local/for_jac_sweep.hpp

    r3301 r3324  
    194194                CPPAD_ASSERT_UNKNOWN( (i_op > n)  | (op == InvOp) ); 
    195195                CPPAD_ASSERT_UNKNOWN( (i_op <= n) | (op != InvOp) ); 
     196                CPPAD_ASSERT_ARG_BEFORE_RESULT(op, arg, i_var);
    196197
    197198                // rest of information depends on the case
  • branches/cache/cppad/local/forward0sweep.hpp

    r3301 r3324  
    252252                CPPAD_ASSERT_UNKNOWN( (i_op <= n) | (op != InvOp) ); 
    253253                CPPAD_ASSERT_UNKNOWN( i_op < play->num_op_rec() );
     254                CPPAD_ASSERT_ARG_BEFORE_RESULT(op, arg, i_var);
    254255
    255256                // check if we are skipping this operation
     
    464465                        case PriOp:
    465466                        if( print ) forward_pri_0(s_out,
    466                                 i_var, arg, num_text, text, num_par, parameter, J, taylor
     467                                arg, num_text, text, num_par, parameter, J, taylor
    467468                        );
    468469                        break;
  • branches/cache/cppad/local/forward1sweep.hpp

    r3301 r3324  
    301301                CPPAD_ASSERT_UNKNOWN( (i_op <= n) | (op != InvOp) ); 
    302302                CPPAD_ASSERT_UNKNOWN( i_op < play->num_op_rec() );
     303                CPPAD_ASSERT_ARG_BEFORE_RESULT(op, arg, i_var);
    303304
    304305                // check if we are skipping this operation
     
    574575                        case PriOp:
    575576                        if( (p == 0) & print ) forward_pri_0(s_out,
    576                                 i_var, arg, num_text, text, num_par, parameter, J, taylor
     577                                arg, num_text, text, num_par, parameter, J, taylor
    577578                        );
    578579                        break;
  • branches/cache/cppad/local/forward2sweep.hpp

    r3301 r3324  
    231231                CPPAD_ASSERT_UNKNOWN( (i_op <= n) | (op != InvOp) ); 
    232232                CPPAD_ASSERT_UNKNOWN( i_op < play->num_op_rec() );
     233                CPPAD_ASSERT_ARG_BEFORE_RESULT(op, arg, i_var);
    233234
    234235                // check if we are skipping this operation
  • branches/cache/cppad/local/load_op.hpp

    r3301 r3324  
    277277        CPPAD_ASSERT_UNKNOWN( NumRes(LdvOp) == 1 );
    278278        CPPAD_ASSERT_UNKNOWN( 0 < arg[0] );
    279         CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
    280279        CPPAD_ASSERT_UNKNOWN( arg[2] < play->num_load_op_rec() );
    281280
  • branches/cache/cppad/local/log_op.hpp

    r3301 r3324  
    4444        CPPAD_ASSERT_UNKNOWN( NumArg(LogOp) == 1 );
    4545        CPPAD_ASSERT_UNKNOWN( NumRes(LogOp) == 1 );
    46         CPPAD_ASSERT_UNKNOWN( i_x < i_z );
    4746        CPPAD_ASSERT_UNKNOWN( q < cap_order );
    4847        CPPAD_ASSERT_UNKNOWN( p <= q );
     
    9695        CPPAD_ASSERT_UNKNOWN( NumArg(LogOp) == 1 );
    9796        CPPAD_ASSERT_UNKNOWN( NumRes(LogOp) == 1 );
    98         CPPAD_ASSERT_UNKNOWN( i_x < i_z );
    9997        CPPAD_ASSERT_UNKNOWN( 0 < q );
    10098        CPPAD_ASSERT_UNKNOWN( q < cap_order );
     
    135133        CPPAD_ASSERT_UNKNOWN( NumArg(LogOp) == 1 );
    136134        CPPAD_ASSERT_UNKNOWN( NumRes(LogOp) == 1 );
    137         CPPAD_ASSERT_UNKNOWN( i_x < i_z );
    138135        CPPAD_ASSERT_UNKNOWN( 0 < cap_order );
    139136
     
    170167        CPPAD_ASSERT_UNKNOWN( NumArg(LogOp) == 1 );
    171168        CPPAD_ASSERT_UNKNOWN( NumRes(LogOp) == 1 );
    172         CPPAD_ASSERT_UNKNOWN( i_x < i_z );
    173169        CPPAD_ASSERT_UNKNOWN( d < cap_order );
    174170        CPPAD_ASSERT_UNKNOWN( d < nc_partial );
  • branches/cache/cppad/local/mul_op.hpp

    r3301 r3324  
    4848        CPPAD_ASSERT_UNKNOWN( NumArg(MulvvOp) == 2 );
    4949        CPPAD_ASSERT_UNKNOWN( NumRes(MulvvOp) == 1 );
    50         CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < i_z );
    51         CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
    5250        CPPAD_ASSERT_UNKNOWN( q < cap_order );
    5351        CPPAD_ASSERT_UNKNOWN( p <= q );
     
    9290        CPPAD_ASSERT_UNKNOWN( NumArg(MulvvOp) == 2 );
    9391        CPPAD_ASSERT_UNKNOWN( NumRes(MulvvOp) == 1 );
    94         CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < i_z );
    95         CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
    9692        CPPAD_ASSERT_UNKNOWN( 0 < q );
    9793        CPPAD_ASSERT_UNKNOWN( q < cap_order );
     
    137133        CPPAD_ASSERT_UNKNOWN( NumArg(MulvvOp) == 2 );
    138134        CPPAD_ASSERT_UNKNOWN( NumRes(MulvvOp) == 1 );
    139         CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < i_z );
    140         CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
    141135
    142136        // Taylor coefficients corresponding to arguments and result
     
    176170        CPPAD_ASSERT_UNKNOWN( NumArg(MulvvOp) == 2 );
    177171        CPPAD_ASSERT_UNKNOWN( NumRes(MulvvOp) == 1 );
    178         CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < i_z );
    179         CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
    180172        CPPAD_ASSERT_UNKNOWN( d < cap_order );
    181173        CPPAD_ASSERT_UNKNOWN( d < nc_partial );
     
    230222        CPPAD_ASSERT_UNKNOWN( NumArg(MulpvOp) == 2 );
    231223        CPPAD_ASSERT_UNKNOWN( NumRes(MulpvOp) == 1 );
    232         CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
    233224        CPPAD_ASSERT_UNKNOWN( q < cap_order );
    234225        CPPAD_ASSERT_UNKNOWN( p <= q );
     
    270261        CPPAD_ASSERT_UNKNOWN( NumArg(MulpvOp) == 2 );
    271262        CPPAD_ASSERT_UNKNOWN( NumRes(MulpvOp) == 1 );
    272         CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
    273263        CPPAD_ASSERT_UNKNOWN( 0 < q );
    274264        CPPAD_ASSERT_UNKNOWN( q < cap_order );
     
    310300        CPPAD_ASSERT_UNKNOWN( NumArg(MulpvOp) == 2 );
    311301        CPPAD_ASSERT_UNKNOWN( NumRes(MulpvOp) == 1 );
    312         CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
    313302
    314303        // Paraemter value
     
    349338        CPPAD_ASSERT_UNKNOWN( NumArg(MulvvOp) == 2 );
    350339        CPPAD_ASSERT_UNKNOWN( NumRes(MulvvOp) == 1 );
    351         CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
    352340        CPPAD_ASSERT_UNKNOWN( d < cap_order );
    353341        CPPAD_ASSERT_UNKNOWN( d < nc_partial );
  • branches/cache/cppad/local/op_code.hpp

    r3301 r3324  
    779779}
    780780
     781/*!
     782If NDEBUG is not defined, assert that arguments come before result.
     783
     784\param op
     785Operator for which we are checking order.
     786All the operators are checked except for those of the form UserOp or Usr..Op.
     787
     788\param result
     789is the variable index for the result.
     790
     791\param arg
     792is a vector of lenght NumArg(op) pointing to the arguments
     793for this operation.
     794*/
     795inline void assert_arg_before_result(
     796        OpCode op, const addr_t* arg, size_t result
     797)
     798{
     799        switch( op )
     800        {
     801
     802                // These cases are not included below
     803                case UserOp:
     804                case UsrapOp:
     805                case UsravOp:
     806                case UsrrpOp:
     807                case UsrrvOp:
     808                break;
     809                // ------------------------------------------------------------------
     810
     811                // 0 arguments
     812                case CSkipOp:
     813                case CSumOp:
     814                case EndOp:
     815                case InvOp:
     816                break;
     817                // ------------------------------------------------------------------
     818
     819                // 1 argument, but is not used
     820                case BeginOp:
     821                break;
     822
     823                // 1 argument , 1 result
     824                case AbsOp:
     825                case ExpOp:
     826                case LogOp:
     827                case ParOp:
     828                case SignOp:
     829                case SqrtOp:
     830                CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < result );
     831                break;
     832
     833                // 1 argument, 2 results
     834                case AcosOp:
     835                case AsinOp:
     836                case AtanOp:
     837                case CosOp:
     838                case CoshOp:
     839                case SinOp:
     840                case SinhOp:
     841                case TanOp:
     842                case TanhOp:
     843                CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) + 1 < result );
     844                break;
     845                // ------------------------------------------------------------------
     846
     847                // 2 arguments (both variables), 1 results
     848                case AddvvOp:
     849                case DivvvOp:
     850                case MulvvOp:
     851                case SubvvOp:
     852                CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < result );
     853                CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < result );
     854                break;
     855
     856                // 2 arguments (first variables), 1 results
     857                case DivvpOp:
     858                case SubvpOp:
     859                CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < result );
     860                break;
     861
     862                // 2 arguments (second variables), 1 results
     863                case AddpvOp:
     864                case DisOp:
     865                case DivpvOp:
     866                case MulpvOp:
     867                case SubpvOp:
     868                CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < result );
     869                break;
     870
     871                // 2 arguments (both variables), 3 results
     872                case PowvvOp:
     873                CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) + 2 < result );
     874                CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) + 2 < result );
     875                break;
     876
     877                // 2 arguments (first variable), 3 results
     878                case PowvpOp:
     879                CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) + 2 < result );
     880                break;
     881
     882                // 2 arguments (second variable), 3 results
     883                case PowpvOp:
     884                CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) + 2 < result );
     885                break;
     886                // ------------------------------------------------------------------
     887
     888                // 3 arguments, none variables
     889                case LdpOp:
     890                case StppOp:
     891                break;
     892
     893                // 3 arguments, second variable, 1 result
     894                case LdvOp:
     895                CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < result );
     896                break;
     897               
     898                // 3 arguments, third variable, no result
     899                case StpvOp:
     900                CPPAD_ASSERT_UNKNOWN( size_t(arg[2]) <= result );
     901                break;
     902
     903                // 3 arguments, second variable, no result
     904                case StvpOp:
     905                CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) <= result );
     906                break;
     907
     908                // 3 arguments, second and third variable, no result
     909                case StvvOp:
     910                CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) <= result );
     911                CPPAD_ASSERT_UNKNOWN( size_t(arg[2]) <= result );
     912                break;
     913                // ------------------------------------------------------------------
     914
     915                // 4 arguments, no result
     916                case ComOp:
     917                if( arg[1] & 2 )
     918                {       CPPAD_ASSERT_UNKNOWN( size_t(arg[2]) <= result );
     919                }
     920                if( arg[1] & 4 )
     921                {       CPPAD_ASSERT_UNKNOWN( size_t(arg[3]) <= result );
     922                }
     923                break;
     924                // ------------------------------------------------------------------
     925
     926                // 5 arguments, no result
     927                case PriOp:
     928                if( arg[0] & 1 )
     929                {       CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) <= result );
     930                }
     931                if( arg[0] & 2 )
     932                {       CPPAD_ASSERT_UNKNOWN( size_t(arg[3]) <= result );
     933                }
     934                break;
     935                // ------------------------------------------------------------------
     936
     937                // 6 arguments, 1 result
     938                case CExpOp:
     939                if( arg[1] & 1 )
     940                {       CPPAD_ASSERT_UNKNOWN( size_t(arg[2]) < result );
     941                }
     942                if( arg[1] & 2 )
     943                {       CPPAD_ASSERT_UNKNOWN( size_t(arg[3]) < result );
     944                }
     945                if( arg[1] & 4 )
     946                {       CPPAD_ASSERT_UNKNOWN( size_t(arg[4]) < result );
     947                }
     948                if( arg[1] & 8 )
     949                {       CPPAD_ASSERT_UNKNOWN( size_t(arg[5]) < result );
     950                }
     951                break;
     952                // ------------------------------------------------------------------
     953
     954                default:
     955                CPPAD_ASSERT_UNKNOWN(false);
     956                break;
     957
     958        }
     959        return;
     960}
     961
    781962} // END_CPPAD_NAMESPACE
    782963# endif
  • branches/cache/cppad/local/pow_op.hpp

    r3301 r3324  
    4747        CPPAD_ASSERT_UNKNOWN( NumArg(PowvvOp) == 2 );
    4848        CPPAD_ASSERT_UNKNOWN( NumRes(PowvvOp) == 3 );
    49         CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < i_z );
    50         CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
    5149        CPPAD_ASSERT_UNKNOWN( q < cap_order );
    5250        CPPAD_ASSERT_UNKNOWN( p <= q );
     
    104102        CPPAD_ASSERT_UNKNOWN( NumArg(PowvvOp) == 2 );
    105103        CPPAD_ASSERT_UNKNOWN( NumRes(PowvvOp) == 3 );
    106         CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < i_z );
    107104        CPPAD_ASSERT_UNKNOWN( 0 < q );
    108105        CPPAD_ASSERT_UNKNOWN( q < cap_order );
     
    148145        CPPAD_ASSERT_UNKNOWN( NumArg(PowvvOp) == 2 );
    149146        CPPAD_ASSERT_UNKNOWN( NumRes(PowvvOp) == 3 );
    150         CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < i_z );
    151         CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
    152147
    153148        // Taylor coefficients corresponding to arguments and result
     
    195190        CPPAD_ASSERT_UNKNOWN( NumArg(PowvvOp) == 2 );
    196191        CPPAD_ASSERT_UNKNOWN( NumRes(PowvvOp) == 3 );
    197         CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < i_z );
    198         CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
    199192        CPPAD_ASSERT_UNKNOWN( d < cap_order );
    200193        CPPAD_ASSERT_UNKNOWN( d < nc_partial );
     
    249242        CPPAD_ASSERT_UNKNOWN( NumArg(PowpvOp) == 2 );
    250243        CPPAD_ASSERT_UNKNOWN( NumRes(PowpvOp) == 3 );
    251         CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
    252244        CPPAD_ASSERT_UNKNOWN( q < cap_order );
    253245        CPPAD_ASSERT_UNKNOWN( p <= q );
     
    315307        CPPAD_ASSERT_UNKNOWN( NumArg(PowpvOp) == 2 );
    316308        CPPAD_ASSERT_UNKNOWN( NumRes(PowpvOp) == 3 );
    317         CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
    318309        CPPAD_ASSERT_UNKNOWN( 0 < q );
    319310        CPPAD_ASSERT_UNKNOWN( q < cap_order );
     
    368359        CPPAD_ASSERT_UNKNOWN( NumArg(PowpvOp) == 2 );
    369360        CPPAD_ASSERT_UNKNOWN( NumRes(PowpvOp) == 3 );
    370         CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
    371361
    372362        // Paraemter value
     
    420410        CPPAD_ASSERT_UNKNOWN( NumArg(PowvvOp) == 2 );
    421411        CPPAD_ASSERT_UNKNOWN( NumRes(PowvvOp) == 3 );
    422         CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
    423412        CPPAD_ASSERT_UNKNOWN( d < cap_order );
    424413        CPPAD_ASSERT_UNKNOWN( d < nc_partial );
     
    472461        CPPAD_ASSERT_UNKNOWN( NumArg(PowvpOp) == 2 );
    473462        CPPAD_ASSERT_UNKNOWN( NumRes(PowvpOp) == 3 );
    474         CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < i_z );
    475463        CPPAD_ASSERT_UNKNOWN( q < cap_order );
    476464        CPPAD_ASSERT_UNKNOWN( p <= q );
     
    526514        CPPAD_ASSERT_UNKNOWN( NumArg(PowvpOp) == 2 );
    527515        CPPAD_ASSERT_UNKNOWN( NumRes(PowvpOp) == 3 );
    528         CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < i_z );
    529516        CPPAD_ASSERT_UNKNOWN( 0 < q );
    530517        CPPAD_ASSERT_UNKNOWN( q < cap_order );
     
    570557        CPPAD_ASSERT_UNKNOWN( NumArg(PowvpOp) == 2 );
    571558        CPPAD_ASSERT_UNKNOWN( NumRes(PowvpOp) == 3 );
    572         CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < i_z );
    573559
    574560        // Paraemter value
     
    622608        CPPAD_ASSERT_UNKNOWN( NumArg(PowvpOp) == 2 );
    623609        CPPAD_ASSERT_UNKNOWN( NumRes(PowvpOp) == 3 );
    624         CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < i_z );
    625610        CPPAD_ASSERT_UNKNOWN( d < cap_order );
    626611        CPPAD_ASSERT_UNKNOWN( d < nc_partial );
  • branches/cache/cppad/local/print_op.hpp

    r3301 r3324  
    3535\param s_out
    3636the results are printed on this output stream.
    37 
    38 \param i_z
    39 is the index of the next variable on the tape
    40 (only used for error checking).
    4137
    4238\param arg
     
    10197\li text          !=  CPPAD_NULL
    10298\li arg[1]         <  num_text
    103 \li if \a pos is a variable, arg[1] < i_z, otherwise arg[1] < num_par
    104 \li if \a var is a variable, arg[3] < i_z, otherwise arg[3] < num_par
     99\li if \a pos is a parameter, arg[1] < num_par
     100\li if \a var is a parameter, arg[3] < num_par
    105101*/
    106102template <class Base>
    107103inline void forward_pri_0(
    108104        std::ostream& s_out       ,
    109         size_t        i_z         ,
    110105        const addr_t* arg         ,
    111106        size_t        num_text    ,
     
    122117        // pos
    123118        if( arg[0] & 1 )
    124         {       CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) <= i_z );
    125                 pos = taylor[ arg[1] * cap_order + 0 ];
     119        {       pos = taylor[ arg[1] * cap_order + 0 ];
    126120        }
    127121        else
     
    136130        // var
    137131        if( arg[0] & 2 )
    138         {       CPPAD_ASSERT_UNKNOWN( size_t(arg[3]) <= i_z );
    139                 var = taylor[ arg[3] * cap_order + 0 ];
     132        {       var = taylor[ arg[3] * cap_order + 0 ];
    140133        }
    141134        else
  • branches/cache/cppad/local/prototype_op.hpp

    r3301 r3324  
    6565\li NumArg(op) == 1
    6666\li NumRes(op) == 1
    67 \li i_x < i_z
    6867\li q < cap_order
    6968\li p <= q
     
    640639\li NumArg(op) == 2
    641640\li NumRes(op) == 1
    642 \li If x is a variable, arg[0] < i_z
    643 \li If y is a variable, arg[1] < i_z
    644641\li q <  cap_order
    645642\li p <=  q
     
    737734\li NumArg(op) == 2
    738735\li NumRes(op) == 1
    739 \li If x is a variable, arg[0] < i_z
    740 \li If y is a variable, arg[1] < i_z
    741736\li 0 < q <  cap_order
    742737*/
     
    800795\li NumArg(op) == 2
    801796\li NumRes(op) == 1
    802 \li If x is a variable, \a arg[0] < \a i_z
    803 \li If y is a variable, \a arg[1] < \a i_z
    804797*/
    805798template <class Base>
  • branches/cache/cppad/local/sign_op.hpp

    r3301 r3324  
    4343        CPPAD_ASSERT_UNKNOWN( NumArg(SignOp) == 1 );
    4444        CPPAD_ASSERT_UNKNOWN( NumRes(SignOp) == 1 );
    45         CPPAD_ASSERT_UNKNOWN( i_x < i_z );
    4645        CPPAD_ASSERT_UNKNOWN( q < cap_order );
    4746        CPPAD_ASSERT_UNKNOWN( p <= q );
     
    8079        CPPAD_ASSERT_UNKNOWN( NumArg(SignOp) == 1 );
    8180        CPPAD_ASSERT_UNKNOWN( NumRes(SignOp) == 1 );
    82         CPPAD_ASSERT_UNKNOWN( i_x < i_z );
    8381        CPPAD_ASSERT_UNKNOWN( 0 < q );
    8482        CPPAD_ASSERT_UNKNOWN( q < cap_order );
     
    114112        CPPAD_ASSERT_UNKNOWN( NumArg(SignOp) == 1 );
    115113        CPPAD_ASSERT_UNKNOWN( NumRes(SignOp) == 1 );
    116         CPPAD_ASSERT_UNKNOWN( i_x < i_z );
    117114        CPPAD_ASSERT_UNKNOWN( 0 < cap_order );
    118115
     
    147144        CPPAD_ASSERT_UNKNOWN( NumArg(SignOp) == 1 );
    148145        CPPAD_ASSERT_UNKNOWN( NumRes(SignOp) == 1 );
    149         CPPAD_ASSERT_UNKNOWN( i_x < i_z );
    150146        CPPAD_ASSERT_UNKNOWN( d < cap_order );
    151147        CPPAD_ASSERT_UNKNOWN( d < nc_partial );
  • branches/cache/cppad/local/sin_op.hpp

    r3301 r3324  
    5050        CPPAD_ASSERT_UNKNOWN( NumArg(SinOp) == 1 );
    5151        CPPAD_ASSERT_UNKNOWN( NumRes(SinOp) == 2 );
    52         CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
    5352        CPPAD_ASSERT_UNKNOWN( q < cap_order );
    5453        CPPAD_ASSERT_UNKNOWN( p <= q );
     
    108107        CPPAD_ASSERT_UNKNOWN( NumArg(SinOp) == 1 );
    109108        CPPAD_ASSERT_UNKNOWN( NumRes(SinOp) == 2 );
    110         CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
    111109        CPPAD_ASSERT_UNKNOWN( 0 < q );
    112110        CPPAD_ASSERT_UNKNOWN( q < cap_order );
     
    161159        CPPAD_ASSERT_UNKNOWN( NumArg(SinOp) == 1 );
    162160        CPPAD_ASSERT_UNKNOWN( NumRes(SinOp) == 2 );
    163         CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
    164161        CPPAD_ASSERT_UNKNOWN( 0 < cap_order );
    165162
     
    202199        CPPAD_ASSERT_UNKNOWN( NumArg(SinOp) == 1 );
    203200        CPPAD_ASSERT_UNKNOWN( NumRes(SinOp) == 2 );
    204         CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
    205201        CPPAD_ASSERT_UNKNOWN( d < cap_order );
    206202        CPPAD_ASSERT_UNKNOWN( d < nc_partial );
  • branches/cache/cppad/local/sinh_op.hpp

    r3301 r3324  
    5050        CPPAD_ASSERT_UNKNOWN( NumArg(SinhOp) == 1 );
    5151        CPPAD_ASSERT_UNKNOWN( NumRes(SinhOp) == 2 );
    52         CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
    5352        CPPAD_ASSERT_UNKNOWN( q < cap_order );
    5453        CPPAD_ASSERT_UNKNOWN( p <= q );
     
    109108        CPPAD_ASSERT_UNKNOWN( NumArg(SinhOp) == 1 );
    110109        CPPAD_ASSERT_UNKNOWN( NumRes(SinhOp) == 2 );
    111         CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
    112110        CPPAD_ASSERT_UNKNOWN( 0 < q );
    113111        CPPAD_ASSERT_UNKNOWN( q < cap_order );
     
    161159        CPPAD_ASSERT_UNKNOWN( NumArg(SinhOp) == 1 );
    162160        CPPAD_ASSERT_UNKNOWN( NumRes(SinhOp) == 2 );
    163         CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
    164161        CPPAD_ASSERT_UNKNOWN( 0 < cap_order );
    165162
     
    201198        CPPAD_ASSERT_UNKNOWN( NumArg(SinhOp) == 1 );
    202199        CPPAD_ASSERT_UNKNOWN( NumRes(SinhOp) == 2 );
    203         CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
    204200        CPPAD_ASSERT_UNKNOWN( d < cap_order );
    205201        CPPAD_ASSERT_UNKNOWN( d < nc_partial );
  • branches/cache/cppad/local/sqrt_op.hpp

    r3301 r3324  
    4444        CPPAD_ASSERT_UNKNOWN( NumArg(SqrtOp) == 1 );
    4545        CPPAD_ASSERT_UNKNOWN( NumRes(SqrtOp) == 1 );
    46         CPPAD_ASSERT_UNKNOWN( i_x < i_z );
    4746        CPPAD_ASSERT_UNKNOWN( q < cap_order );
    4847        CPPAD_ASSERT_UNKNOWN( p <= q );
     
    9493        CPPAD_ASSERT_UNKNOWN( NumArg(SqrtOp) == 1 );
    9594        CPPAD_ASSERT_UNKNOWN( NumRes(SqrtOp) == 1 );
    96         CPPAD_ASSERT_UNKNOWN( i_x < i_z );
    9795        CPPAD_ASSERT_UNKNOWN( 0 < q );
    9896        CPPAD_ASSERT_UNKNOWN( q < cap_order );
     
    138136        CPPAD_ASSERT_UNKNOWN( NumArg(SqrtOp) == 1 );
    139137        CPPAD_ASSERT_UNKNOWN( NumRes(SqrtOp) == 1 );
    140         CPPAD_ASSERT_UNKNOWN( i_x < i_z );
    141138        CPPAD_ASSERT_UNKNOWN( 0 < cap_order );
    142139
     
    171168        CPPAD_ASSERT_UNKNOWN( NumArg(SqrtOp) == 1 );
    172169        CPPAD_ASSERT_UNKNOWN( NumRes(SqrtOp) == 1 );
    173         CPPAD_ASSERT_UNKNOWN( i_x < i_z );
    174170        CPPAD_ASSERT_UNKNOWN( d < cap_order );
    175171        CPPAD_ASSERT_UNKNOWN( d < nc_partial );
  • branches/cache/cppad/local/store_op.hpp

    r3301 r3324  
    106106\li 0 <  arg[0]
    107107\li if y is a parameter, arg[2] < num_par
    108 \li if x is a variable, arg[1] <= i_z
    109 \li if y is a variable, arg[2] <= i_z
    110108*/
    111109template <class Base>
     
    260258        CPPAD_ASSERT_UNKNOWN( NumRes(StpvOp) == 0 );
    261259        CPPAD_ASSERT_UNKNOWN( 0 < arg[0] );
    262         CPPAD_ASSERT_UNKNOWN( size_t(arg[2]) <= i_z );
    263260
    264261        isvar_by_ind[ arg[0] + i_vec ]  = true;
     
    281278        size_t*        index_by_ind   )
    282279{       
    283         CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) <= i_z );
    284280        size_t i_vec = Integer( taylor[ arg[1] * cap_order + 0 ] );
    285281        CPPAD_ASSERT_KNOWN(
     
    312308        size_t*        index_by_ind   )
    313309{       
    314         CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) <= i_z );
    315310        size_t i_vec = Integer( taylor[ arg[1] * cap_order + 0 ] );
    316311        CPPAD_ASSERT_KNOWN(
     
    322317        CPPAD_ASSERT_UNKNOWN( NumRes(StvpOp) == 0 );
    323318        CPPAD_ASSERT_UNKNOWN( 0 < arg[0] );
    324         CPPAD_ASSERT_UNKNOWN( size_t(arg[2]) <= i_z );
    325319
    326320        isvar_by_ind[ arg[0] + i_vec ]  = true;
  • branches/cache/cppad/local/sub_op.hpp

    r3301 r3324  
    4848        CPPAD_ASSERT_UNKNOWN( NumArg(SubvvOp) == 2 );
    4949        CPPAD_ASSERT_UNKNOWN( NumRes(SubvvOp) == 1 );
    50         CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < i_z );
    51         CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
    5250        CPPAD_ASSERT_UNKNOWN( q < cap_order );
    5351        CPPAD_ASSERT_UNKNOWN( p <= q );
     
    8886        CPPAD_ASSERT_UNKNOWN( NumArg(SubvvOp) == 2 );
    8987        CPPAD_ASSERT_UNKNOWN( NumRes(SubvvOp) == 1 );
    90         CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < i_z );
    91         CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
    9288        CPPAD_ASSERT_UNKNOWN( 0 < q );
    9389        CPPAD_ASSERT_UNKNOWN( q < cap_order );
     
    129125        CPPAD_ASSERT_UNKNOWN( NumArg(SubvvOp) == 2 );
    130126        CPPAD_ASSERT_UNKNOWN( NumRes(SubvvOp) == 1 );
    131         CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < i_z );
    132         CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
    133127
    134128        // Taylor coefficients corresponding to arguments and result
     
    168162        CPPAD_ASSERT_UNKNOWN( NumArg(SubvvOp) == 2 );
    169163        CPPAD_ASSERT_UNKNOWN( NumRes(SubvvOp) == 1 );
    170         CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < i_z );
    171         CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
    172164        CPPAD_ASSERT_UNKNOWN( d < cap_order );
    173165        CPPAD_ASSERT_UNKNOWN( d < nc_partial );
     
    214206        CPPAD_ASSERT_UNKNOWN( NumArg(SubpvOp) == 2 );
    215207        CPPAD_ASSERT_UNKNOWN( NumRes(SubpvOp) == 1 );
    216         CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
    217208        CPPAD_ASSERT_UNKNOWN( q < cap_order );
    218209        CPPAD_ASSERT_UNKNOWN( p <= q );
     
    257248        CPPAD_ASSERT_UNKNOWN( NumArg(SubpvOp) == 2 );
    258249        CPPAD_ASSERT_UNKNOWN( NumRes(SubpvOp) == 1 );
    259         CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
    260250        CPPAD_ASSERT_UNKNOWN( 0 < q );
    261251        CPPAD_ASSERT_UNKNOWN( q < cap_order );
     
    295285        CPPAD_ASSERT_UNKNOWN( NumArg(SubpvOp) == 2 );
    296286        CPPAD_ASSERT_UNKNOWN( NumRes(SubpvOp) == 1 );
    297         CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
    298287
    299288        // Paraemter value
     
    334323        CPPAD_ASSERT_UNKNOWN( NumArg(SubvvOp) == 2 );
    335324        CPPAD_ASSERT_UNKNOWN( NumRes(SubvvOp) == 1 );
    336         CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
    337325        CPPAD_ASSERT_UNKNOWN( d < cap_order );
    338326        CPPAD_ASSERT_UNKNOWN( d < nc_partial );
     
    377365        CPPAD_ASSERT_UNKNOWN( NumArg(SubvpOp) == 2 );
    378366        CPPAD_ASSERT_UNKNOWN( NumRes(SubvpOp) == 1 );
    379         CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < i_z );
    380367        CPPAD_ASSERT_UNKNOWN( q < cap_order );
    381368        CPPAD_ASSERT_UNKNOWN( p <= q );
     
    420407        CPPAD_ASSERT_UNKNOWN( NumArg(SubvpOp) == 2 );
    421408        CPPAD_ASSERT_UNKNOWN( NumRes(SubvpOp) == 1 );
    422         CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < i_z );
    423409        CPPAD_ASSERT_UNKNOWN( 0 < q );
    424410        CPPAD_ASSERT_UNKNOWN( q < cap_order );
     
    459445        CPPAD_ASSERT_UNKNOWN( NumArg(SubvpOp) == 2 );
    460446        CPPAD_ASSERT_UNKNOWN( NumRes(SubvpOp) == 1 );
    461         CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < i_z );
    462447
    463448        // Parameter value
     
    498483        CPPAD_ASSERT_UNKNOWN( NumArg(SubvpOp) == 2 );
    499484        CPPAD_ASSERT_UNKNOWN( NumRes(SubvpOp) == 1 );
    500         CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < i_z );
    501485        CPPAD_ASSERT_UNKNOWN( d < cap_order );
    502486        CPPAD_ASSERT_UNKNOWN( d < nc_partial );
  • branches/cache/cppad/local/tan_op.hpp

    r3301 r3324  
    5050        CPPAD_ASSERT_UNKNOWN( NumArg(TanOp) == 1 );
    5151        CPPAD_ASSERT_UNKNOWN( NumRes(TanOp) == 2 );
    52         CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
    5352        CPPAD_ASSERT_UNKNOWN( q < cap_order );
    5453        CPPAD_ASSERT_UNKNOWN( p <= q );
     
    106105        CPPAD_ASSERT_UNKNOWN( NumArg(TanOp) == 1 );
    107106        CPPAD_ASSERT_UNKNOWN( NumRes(TanOp) == 2 );
    108         CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
    109107        CPPAD_ASSERT_UNKNOWN( 0 < q );
    110108        CPPAD_ASSERT_UNKNOWN( q < cap_order );
     
    156154        CPPAD_ASSERT_UNKNOWN( NumArg(TanOp) == 1 );
    157155        CPPAD_ASSERT_UNKNOWN( NumRes(TanOp) == 2 );
    158         CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
    159156        CPPAD_ASSERT_UNKNOWN( 0 < cap_order );
    160157
     
    197194        CPPAD_ASSERT_UNKNOWN( NumArg(TanOp) == 1 );
    198195        CPPAD_ASSERT_UNKNOWN( NumRes(TanOp) == 2 );
    199         CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
    200196        CPPAD_ASSERT_UNKNOWN( d < cap_order );
    201197        CPPAD_ASSERT_UNKNOWN( d < nc_partial );
  • branches/cache/cppad/local/tanh_op.hpp

    r3301 r3324  
    5050        CPPAD_ASSERT_UNKNOWN( NumArg(TanOp) == 1 );
    5151        CPPAD_ASSERT_UNKNOWN( NumRes(TanOp) == 2 );
    52         CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
    5352        CPPAD_ASSERT_UNKNOWN( q < cap_order );
    5453        CPPAD_ASSERT_UNKNOWN( p <= q );
     
    106105        CPPAD_ASSERT_UNKNOWN( NumArg(TanOp) == 1 );
    107106        CPPAD_ASSERT_UNKNOWN( NumRes(TanOp) == 2 );
    108         CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
    109107        CPPAD_ASSERT_UNKNOWN( 0 < q );
    110108        CPPAD_ASSERT_UNKNOWN( q < cap_order );
     
    155153        CPPAD_ASSERT_UNKNOWN( NumArg(TanOp) == 1 );
    156154        CPPAD_ASSERT_UNKNOWN( NumRes(TanOp) == 2 );
    157         CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
    158155        CPPAD_ASSERT_UNKNOWN( 0 < cap_order );
    159156
     
    196193        CPPAD_ASSERT_UNKNOWN( NumArg(TanOp) == 1 );
    197194        CPPAD_ASSERT_UNKNOWN( NumRes(TanOp) == 2 );
    198         CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
    199195        CPPAD_ASSERT_UNKNOWN( d < cap_order );
    200196        CPPAD_ASSERT_UNKNOWN( d < nc_partial );
  • branches/cache/cppad/local/undef.hpp

    r3214 r3324  
    5959# undef CPPAD_ASSERT_NARG_NRES
    6060# undef CPPAD_ASSERT_NOT_PARALLEL
     61# undef CPPAD_ASSERT_ARG_BEFORE_RESULT
    6162# undef CPPAD_BOOSTVECTOR
    6263# undef CPPAD_COND_EXP
  • branches/cache/example/atomic/test_one.sh

    r2850 r3324  
    5050        $cxxflags
    5151        -g
    52         -lboost_thread-mt
    5352        -std=c++11
    5453        -I../..
  • branches/cache/example/test_one.sh.in

    r3116 r3324  
    5151        -g
    5252        -fopenmp
    53         -lboost_thread-mt
     53        -lboost_thread
    5454        -lpthread
    5555        -std=c++11 -DCPPAD_ADOLC_EXAMPLES -DCPPAD_EIGEN_EXAMPLES
  • branches/cache/speed/adolc/sparse_jacobian.cpp

    r3138 r3324  
    167167
    168168                // is this a repeat call with the same sparsity pattern
    169                 int same_pattern = 0;
     169                same_pattern = 0;
    170170
    171171                // calculate the jacobian at this x
  • branches/cache/speed/main.cpp

    r3311 r3324  
    706706                );
    707707                cout << AD_PACKAGE << "_sparse_jacobian_n_sweep = ";
    708                 for(size_t i = 0; i < size_sparse_jacobian.size(); i++)
     708                for(i = 0; i < size_sparse_jacobian.size(); i++)
    709709                {       if( i == 0 )
    710710                                cout << "[ ";
  • branches/cache/speed/sacado/CMakeLists.txt

    r3122 r3324  
    4545add_cppad_cxx_flags( speed_sacado )
    4646
     47# Find name used for teuchos library
     48SET(teuchos_lib NOTFOUND)
     49FOREACH(dir ${cmake_install_libdirs})
     50        FILE(GLOB file_list ${sacado_prefix}/${dir}/libteuchoscore.*)
     51        IF(file_list)
     52                SET(teuchos_lib teuchoscore)
     53        ENDIF(file_list)
     54        FILE(GLOB file_list ${sacado_prefix}/${dir}/libteuchos.*)
     55        IF(file_list)
     56                SET(teuchos_lib teuchos)
     57        ENDIF(file_list)
     58ENDFOREACH(dir)
     59
    4760# List of libraries to be linked into the specified target
    48 TARGET_LINK_LIBRARIES(speed_sacado speed_src sacado teuchos)
    49 
     61IF(teuchos_lib)
     62        TARGET_LINK_LIBRARIES(speed_sacado speed_src sacado ${teuchos_lib})
     63ELSE(teuchos_lib)
     64        MESSAGE(FATAT_ERROR
     65"
     66For all dir in cmake_install_libdirs, cannot find either
     67        sacado_prefix/dir/teuchos
     68        sacado_prefix/dir/teuchoscore
     69where
     70        sacado_prefix = ${sacado_prefix}
     71        cmake_install_libdirs = ${cmake_install_libdirs}
     72        teuchos_lib= ${teuchos_lib}
     73"
     74        )
     75ENDIF(teuchos_lib)
     76#
    5077# Add the check_speed_sacado target
    5178ADD_CUSTOM_TARGET(check_speed_sacado
Note: See TracChangeset for help on using the changeset viewer.