Changeset 3604


Ignore:
Timestamp:
Jan 20, 2015 7:29:57 AM (5 years ago)
Author:
bradbell
Message:

merge to branch: branches/compare_op
from repository: https://github.com/coin-or/CppAD
start hash code: 622a13c568c612d9dfe9ccd1a01f4ac5f74ba824
end hash code: 45315907c70e5b383d984fb9498b54a474001af0

commit 45315907c70e5b383d984fb9498b54a474001af0
Author: Brad Bell <bradbell@…>
Date: Tue Jan 20 05:04:37 2015 -0700

Use the new f.compare_change_count(0) option in speed tests.

commit bb6e72befd6d01f1fb62c43b9b19471ffaa7cc2c
Author: Brad Bell <bradbell@…>
Date: Tue Jan 20 04:51:16 2015 -0700

Move CompareChange? -> deprecated and plan -> compare_change.


forward0sweep.hpp: skip comparison operator when count is zero.
forward1sweep.hpp: skip comparison operator when count is zero.
compare_change.cpp: demonstrate count == 0 case.

Location:
branches/compare_op
Files:
1 added
1 deleted
14 edited

Legend:

Unmodified
Added
Removed
  • branches/compare_op/cppad/local/forward0sweep.hpp

    r3603 r3604  
    398398
    399399                        case EqpvOp:
    400                         forward_eqpv_op_0(
    401                                 compare_change_number, arg, parameter, J, taylor
    402                         );
    403400                        if( compare_change_count )
    404                         {       if( compare_change_count == compare_change_number )
    405                                         compare_change_op_index = i_op;
     401                        {       forward_eqpv_op_0(
     402                                        compare_change_number, arg, parameter, J, taylor
     403                                );
     404                                {       if( compare_change_count == compare_change_number )
     405                                                compare_change_op_index = i_op;
     406                                }
    406407                        }
    407408                        break;
     
    409410
    410411                        case EqvvOp:
    411                         forward_eqvv_op_0(
    412                                 compare_change_number, arg, parameter, J, taylor
    413                         );
    414412                        if( compare_change_count )
    415                         {       if( compare_change_count == compare_change_number )
    416                                         compare_change_op_index = i_op;
     413                        {       forward_eqvv_op_0(
     414                                        compare_change_number, arg, parameter, J, taylor
     415                                );
     416                                {       if( compare_change_count == compare_change_number )
     417                                                compare_change_op_index = i_op;
     418                                }
    417419                        }
    418420                        break;
     
    469471
    470472                        case LepvOp:
    471                         forward_lepv_op_0(
    472                                 compare_change_number, arg, parameter, J, taylor
    473                         );
    474473                        if( compare_change_count )
    475                         {       if( compare_change_count == compare_change_number )
    476                                         compare_change_op_index = i_op;
     474                        {       forward_lepv_op_0(
     475                                        compare_change_number, arg, parameter, J, taylor
     476                                );
     477                                {       if( compare_change_count == compare_change_number )
     478                                                compare_change_op_index = i_op;
     479                                }
    477480                        }
    478481                        break;
     
    480483
    481484                        case LevpOp:
    482                         forward_levp_op_0(
    483                                 compare_change_number, arg, parameter, J, taylor
    484                         );
    485485                        if( compare_change_count )
    486                         {       if( compare_change_count == compare_change_number )
    487                                         compare_change_op_index = i_op;
     486                        {       forward_levp_op_0(
     487                                        compare_change_number, arg, parameter, J, taylor
     488                                );
     489                                {       if( compare_change_count == compare_change_number )
     490                                                compare_change_op_index = i_op;
     491                                }
    488492                        }
    489493                        break;
     
    491495
    492496                        case LevvOp:
    493                         forward_levv_op_0(
    494                                 compare_change_number, arg, parameter, J, taylor
    495                         );
    496497                        if( compare_change_count )
    497                         {       if( compare_change_count == compare_change_number )
    498                                         compare_change_op_index = i_op;
     498                        {       forward_levv_op_0(
     499                                        compare_change_number, arg, parameter, J, taylor
     500                                );
     501                                {       if( compare_change_count == compare_change_number )
     502                                                compare_change_op_index = i_op;
     503                                }
    499504                        }
    500505                        break;
     
    507512
    508513                        case LtpvOp:
    509                         forward_ltpv_op_0(
    510                                 compare_change_number, arg, parameter, J, taylor
    511                         );
    512514                        if( compare_change_count )
    513                         {       if( compare_change_count == compare_change_number )
    514                                         compare_change_op_index = i_op;
     515                        {       forward_ltpv_op_0(
     516                                        compare_change_number, arg, parameter, J, taylor
     517                                );
     518                                {       if( compare_change_count == compare_change_number )
     519                                                compare_change_op_index = i_op;
     520                                }
    515521                        }
    516522                        break;
     
    518524
    519525                        case LtvpOp:
    520                         forward_ltvp_op_0(
    521                                 compare_change_number, arg, parameter, J, taylor
    522                         );
    523526                        if( compare_change_count )
    524                         {       if( compare_change_count == compare_change_number )
    525                                         compare_change_op_index = i_op;
     527                        {       forward_ltvp_op_0(
     528                                        compare_change_number, arg, parameter, J, taylor
     529                                );
     530                                {       if( compare_change_count == compare_change_number )
     531                                                compare_change_op_index = i_op;
     532                                }
    526533                        }
    527534                        break;
     
    529536
    530537                        case LtvvOp:
    531                         forward_ltvv_op_0(
    532                                 compare_change_number, arg, parameter, J, taylor
    533                         );
    534538                        if( compare_change_count )
    535                         {       if( compare_change_count == compare_change_number )
    536                                         compare_change_op_index = i_op;
     539                        {       forward_ltvv_op_0(
     540                                        compare_change_number, arg, parameter, J, taylor
     541                                );
     542                                {       if( compare_change_count == compare_change_number )
     543                                                compare_change_op_index = i_op;
     544                                }
    537545                        }
    538546                        break;
     
    551559
    552560                        case NepvOp:
    553                         forward_nepv_op_0(
    554                                 compare_change_number, arg, parameter, J, taylor
    555                         );
    556561                        if( compare_change_count )
    557                         {       if( compare_change_count == compare_change_number )
    558                                         compare_change_op_index = i_op;
     562                        {       forward_nepv_op_0(
     563                                        compare_change_number, arg, parameter, J, taylor
     564                                );
     565                                {       if( compare_change_count == compare_change_number )
     566                                                compare_change_op_index = i_op;
     567                                }
    559568                        }
    560569                        break;
     
    562571
    563572                        case NevvOp:
    564                         forward_nevv_op_0(
    565                                 compare_change_number, arg, parameter, J, taylor
    566                         );
    567573                        if( compare_change_count )
    568                         {       if( compare_change_count == compare_change_number )
    569                                         compare_change_op_index = i_op;
     574                        {       forward_nevv_op_0(
     575                                        compare_change_number, arg, parameter, J, taylor
     576                                );
     577                                {       if( compare_change_count == compare_change_number )
     578                                                compare_change_op_index = i_op;
     579                                }
    570580                        }
    571581                        break;
     
    885895        CPPAD_ASSERT_UNKNOWN( i_var + 1 == play->num_var_rec() );
    886896
    887         if( compare_change_count == 0 )
    888                 compare_change_number = 0;
    889897        return;
    890898}
  • branches/compare_op/cppad/local/forward1sweep.hpp

    r3603 r3604  
    448448
    449449                        case EqpvOp:
    450                         if( p == 0 )
     450                        if( ( p == 0 ) & ( compare_change_count > 0 ) )
    451451                        {       forward_eqpv_op_0(
    452452                                        compare_change_number, arg, parameter, J, taylor
    453453                                );
    454                                 if( compare_change_count )
    455                                 {       if( compare_change_count == compare_change_number )
    456                                                 compare_change_op_index = i_op;
    457                                 }
     454                                if( compare_change_count == compare_change_number )
     455                                        compare_change_op_index = i_op;
    458456                        }
    459457                        break;
     
    461459
    462460                        case EqvvOp:
    463                         if( p == 0 )
     461                        if( ( p == 0 ) & ( compare_change_count > 0 ) )
    464462                        {       forward_eqvv_op_0(
    465463                                        compare_change_number, arg, parameter, J, taylor
    466464                                );
    467                                 if( compare_change_count )
    468                                 {       if( compare_change_count == compare_change_number )
    469                                                 compare_change_op_index = i_op;
    470                                 }
     465                                if( compare_change_count == compare_change_number )
     466                                        compare_change_op_index = i_op;
    471467                        }
    472468                        break;
     
    575571
    576572                        case LepvOp:
    577                         if( p == 0 )
     573                        if( ( p == 0 ) & ( compare_change_count > 0 ) )
    578574                        {       forward_lepv_op_0(
    579575                                        compare_change_number, arg, parameter, J, taylor
    580576                                );
    581                                 if( compare_change_count )
    582                                 {       if( compare_change_count == compare_change_number )
    583                                                 compare_change_op_index = i_op;
    584                                 }
     577                                if( compare_change_count == compare_change_number )
     578                                        compare_change_op_index = i_op;
    585579                        }
    586580                        break;
    587581
    588582                        case LevpOp:
    589                         if( p == 0 )
     583                        if( ( p == 0 ) & ( compare_change_count > 0 ) )
    590584                        {       forward_levp_op_0(
    591585                                        compare_change_number, arg, parameter, J, taylor
    592586                                );
    593                                 if( compare_change_count )
    594                                 {       if( compare_change_count == compare_change_number )
    595                                                 compare_change_op_index = i_op;
    596                                 }
     587                                if( compare_change_count == compare_change_number )
     588                                        compare_change_op_index = i_op;
    597589                        }
    598590                        break;
     
    600592
    601593                        case LevvOp:
    602                         if( p == 0 )
     594                        if( ( p == 0 ) & ( compare_change_count > 0 ) )
    603595                        {       forward_levv_op_0(
    604596                                        compare_change_number, arg, parameter, J, taylor
    605597                                );
    606                                 if( compare_change_count )
    607                                 {       if( compare_change_count == compare_change_number )
    608                                                 compare_change_op_index = i_op;
    609                                 }
     598                                if( compare_change_count == compare_change_number )
     599                                        compare_change_op_index = i_op;
    610600                        }
    611601                        break;
     
    618608
    619609                        case LtpvOp:
    620                         if( p == 0 )
     610                        if( ( p == 0 ) & ( compare_change_count > 0 ) )
    621611                        {       forward_ltpv_op_0(
    622612                                        compare_change_number, arg, parameter, J, taylor
    623613                                );
    624                                 if( compare_change_count )
    625                                 {       if( compare_change_count == compare_change_number )
    626                                                 compare_change_op_index = i_op;
    627                                 }
     614                                if( compare_change_count == compare_change_number )
     615                                        compare_change_op_index = i_op;
    628616                        }
    629617                        break;
    630618
    631619                        case LtvpOp:
    632                         if( p == 0 )
     620                        if( ( p == 0 ) & ( compare_change_count > 0 ) )
    633621                        {       forward_ltvp_op_0(
    634622                                        compare_change_number, arg, parameter, J, taylor
    635623                                );
    636                                 if( compare_change_count )
    637                                 {       if( compare_change_count == compare_change_number )
    638                                                 compare_change_op_index = i_op;
    639                                 }
     624                                if( compare_change_count == compare_change_number )
     625                                        compare_change_op_index = i_op;
    640626                        }
    641627                        break;
     
    643629
    644630                        case LtvvOp:
    645                         if( p == 0 )
     631                        if( ( p == 0 ) & ( compare_change_count > 0 ) )
    646632                        {       forward_ltvv_op_0(
    647633                                        compare_change_number, arg, parameter, J, taylor
    648634                                );
    649                                 if( compare_change_count )
    650                                 {       if( compare_change_count == compare_change_number )
    651                                                 compare_change_op_index = i_op;
    652                                 }
     635                                if( compare_change_count == compare_change_number )
     636                                        compare_change_op_index = i_op;
    653637                        }
    654638                        break;
     
    667651
    668652                        case NepvOp:
    669                         if( p == 0 )
     653                        if( ( p == 0 ) & ( compare_change_count > 0 ) )
    670654                        {       forward_nepv_op_0(
    671655                                        compare_change_number, arg, parameter, J, taylor
    672656                                );
    673                                 if( compare_change_count )
    674                                 {       if( compare_change_count == compare_change_number )
    675                                                 compare_change_op_index = i_op;
    676                                 }
     657                                if( compare_change_count == compare_change_number )
     658                                        compare_change_op_index = i_op;
    677659                        }
    678660                        break;
     
    680662
    681663                        case NevvOp:
    682                         if( p == 0 )
     664                        if( ( p == 0 ) & ( compare_change_count > 0 ) )
    683665                        {       forward_nevv_op_0(
    684666                                        compare_change_number, arg, parameter, J, taylor
    685667                                );
    686                                 if( compare_change_count )
    687                                 {       if( compare_change_count == compare_change_number )
    688                                                 compare_change_op_index = i_op;
    689                                 }
     668                                if( compare_change_count == compare_change_number )
     669                                        compare_change_op_index = i_op;
    690670                        }
    691671                        break;
  • branches/compare_op/cppad/local/independent.hpp

    r3603 r3604  
    9292can inspect the call stack to see the source code corresponding to
    9393this operator index; see
    94 $cref/purpose/compare_change_plan/op_index/Purpose/$$.
     94$cref/purpose/compare_change/op_index/Purpose/$$.
    9595
    9696
  • branches/compare_op/example/compare_change.cpp

    r3603 r3604  
    139139        ok &= caught_error;
    140140
     141
     142        // set count to zero to demonstrate case where comparisons are not checked
     143        f.compare_change_count(0);
     144        y    = f.Forward(0, x);
     145        ok  &= (y[0] == x[0]);
     146        ok  &= (y[0] != Minimum(x[0], x[1]));
     147        ok  &= (f.compare_change_number()   == 0);
     148        ok  &= (f.compare_change_op_index() == 0);
     149
    141150        return ok;
    142151}
  • branches/compare_op/omh/deprecated/deprecated.omh

    r3603 r3604  
    11/* $Id$ */
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    2121        omh/deprecated/include_deprecated.omh%
    2222        omh/deprecated/fun_deprecated.omh%
     23        omh/deprecated/compare_change.omh%
    2324        cppad/local/omp_max_thread.hpp%
    2425        cppad/track_new_del.hpp%
  • branches/compare_op/omh/forward/compare_change.omh

    r3602 r3604  
    1 /* $Id$ */
     1// $Id$
    22/* --------------------------------------------------------------------------
    33CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
    6 the terms of the 
     6the terms of the
    77                    Eclipse Public License Version 1.0.
    88
     
    1010Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
    1111-------------------------------------------------------------------------- */
    12 $begin CompareChange$$
    13 $spell
     12$begin compare_change$$
     13$spell
     14        op
    1415        const
    1516$$
    1617
    17 $section Comparison Changes During Zero Order Forward Mode$$
     18$section Comparison Changes Between Taping and Zero Order Forward$$
    1819
    19 $index ADFun, CompareChange$$
    20 $index CompareChange, ADFun$$
     20$index ADFun, compare_change$$
     21$index compare_change, ADFun$$
    2122$index zero, order forward$$
    2223$index forward, zero order$$
    2324
    2425$head Syntax$$
    25 $icode%c% = %f%.CompareChange()%$$
    26 $pre
    27 $$
     26$icode%f%.compare_change_count(%count%)
     27%$$
     28$icode%number% = %f%.compare_change_number()
     29%$$
     30$icode%op_index% = %f%.compare_change_op_index()
     31
     32%$$
    2833$bold See Also$$
    2934$cref FunCheck$$
     
    3237$head Purpose$$
    3338We use $latex F : B^n \rightarrow B^m$$ to denote the
    34 $cref/AD function/glossary/AD Function/$$ corresponding to $icode f$$.
    35 This function may be not agree with the algorithm that was used
    36 to create the corresponding
    37 AD of $icode Base$$
    38 $cref/operation sequence/glossary/Operation/Sequence/$$
    39 because of changes in AD
    40 $cref/comparison/Compare/$$ results.
    41 The $code CompareChange$$ function can be used to detect these changes.
     39$cref/AD function/glossary/AD Function/$$ corresponding to $icode f$$; i.e,
     40given $latex x \in B^n$$, $latex F(x)$$ is defined by
     41$codei%
     42        %F%(%x%) = %f%.Forward(0, %x%)
     43%$$
     44see $cref forward_zero$$.
     45If $latex x$$ is such that
     46all the algorithm $cref/comparison/Compare/$$ operations
     47have the same result as when the algorithm was taped,
     48The function $latex F(x)$$ and the algorithm will have the same values.
     49(This is a sufficient, but not necessary condition).
     50
     51
     52
     53
    4254
    4355$head f$$
    44 The object $icode f$$ has prototype
     56In the $code compare_change_number$$ and $code compare_change_op_index$$
     57syntax, the object $icode f$$ has prototype
    4558$codei%
    4659        const ADFun<%Base%> %f%
    4760%$$
     61In the $code compare_change_count$$
     62syntax, the object $icode f$$ has prototype
     63$codei%
     64        ADFun<%Base%> %f%
     65%$$
    4866
    49 $head c$$
    50 The result $icode c$$ has prototype
    51 $codei%
    52         size_t %c%
     67$head count$$
     68The argument $icode count$$ has prototype
     69$icode%
     70        size_t %count%
    5371%$$
    54 It is the number of
    55 $codei%AD<%Base%>%$$ $cref/comparison/Compare/$$
    56 operations,
    57 corresponding to the previous call to $cref Forward$$
     72It specifies which comparison change should correspond to the
     73information stored in $icode f$$ during subsequent calls to
     74$cref forward_zero$$; i.e.,
    5875$codei%
    5976        %f%.Forward(0, %x%)
    6077%$$
    61 that have a different result from
    62 when $icode F$$ was created by taping an algorithm.
     78For example, if $icode%count% == 1%$$,
     79the operator index corresponding to the first comparison change
     80will be stored.
     81This is the default value used if $icode count$$ is not specified.
    6382
    64 $head Discussion$$
    65 If $icode c$$ is not zero,
    66 the boolean values resulting from some of the
    67 $cref/comparison operations/Compare/$$ corresponding to $icode x$$
    68 are different from when the
    69 AD of $icode Base$$
    70 $cref/operation sequence/glossary/Operation/Sequence/$$ was created.
    71 In this case, you may want to re-tape the algorithm with the
    72 $cref/independent variables/glossary/Tape/Independent Variable/$$
    73 equal to the values in $icode x$$
    74 (so AD operation sequence properly represents the algorithm
    75 for this value of independent variables).
    76 On the other hand, re-taping the AD operation sequence usually takes
     83$subhead Speed$$
     84The special case where $icode count == 0$$, should be faster because
     85the comparisons are not checked during
     86$codei%
     87        %f%.Forward(0, %x%)
     88%$$
     89
     90$head number$$
     91The return value $icode number$$ has prototype
     92$codei%
     93        size_t %number%
     94%$$
     95If $icode count$$ is non-zero,
     96$icode number$$ is the number of
     97$codei%AD<%Base%>%$$ $cref/comparison/Compare/$$ operations,
     98corresponding to the previous call to
     99$codei%
     100        %f%.Forward(0, %x%)
     101%$$
     102that have a different result for this value of $icode x$$
     103than the value used when $icode f$$ was created by taping an algorithm.
     104If $icode count$$ is zero,
     105or if no calls to $icode%f%.Forward(0, %x%)%$$ follow the previous
     106setting of $icode count$$,
     107$icode number$$ is zero.
     108
     109$subhead Discussion$$
     110If $icode count$$ and $icode number$$ are non-zero,
     111you may want to re-tape the algorithm with the
     112$cref/independent variables/glossary/Tape/Independent Variable/$$
     113equal to the values in $icode x$$,
     114so the AD operation sequence properly represents the algorithm
     115for this value of independent variables.
     116On the other hand, re-taping the AD operation sequence usually takes
    77117significantly more time than evaluation using $cref forward_zero$$.
    78118If the functions values have not changed (see $cref FunCheck$$)
    79 it may not be worth re-taping a new AD operation sequence. 
     119it may not be worth re-taping a new AD operation sequence.
    80120
    81 $head Example$$
     121$head op_index$$
     122The return value $icode op_index$$ has prototype
     123$codei%
     124        size_t %op_index%
     125%$$
     126If $icode count$$ is non-zero,
     127$icode op_index$$ is the operator index corresponding the
     128$icode count$$-th comparison change during the previous call to
     129$codei%
     130        %f%.Forward(0, %x%)
     131%$$
     132If $icode count$$ is greater than the corresponding
     133$icode number$$, there is no such comparison change and $icode op_index$$
     134will also be zero.
     135If $icode count$$ is zero,
     136or if no calls to $icode%f%.Forward(0, %x%)%$$ follow the previous
     137setting of $icode count$$,
     138$icode op_index$$ is zero.
     139
     140$subhead Purpose$$
     141The operator index can be used to generate an error during the taping
     142process so that the corresponding algorithm can be inspected.
     143In some cases, it is possible to re-design this part of the
     144algorithm to avoid the particular comparison operation.
     145For example, using an $cref/conditional expression/CondExp/$$
     146may be appropriate in some cases.
     147See $cref/abort_op_index/Independent/abort_op_index/$$ in the syntax
     148$codei%
     149        Independent(%x%, %op_index%)
     150%$$
     151Note that the operator index $icode op_index$$,
     152must correspond to the original tape,
     153and not an $cref/optimized/optimize/$$ version of the tape.
     154
    82155$children%
    83156        example/compare_change.cpp
    84157%$$
    85 The file
     158$head Example$$
    86159$cref compare_change.cpp$$
    87160contains an example and test of this operation.
  • branches/compare_op/omh/forward/forward.omh

    r3602 r3604  
    11/* $Id$ */
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    2121        omh/forward/forward_dir.omh%
    2222        omh/forward/size_order.omh%
    23         omh/forward/plan.omh%
     23        omh/forward/compare_change.omh%
    2424        cppad/local/capacity_order.hpp%
    2525        cppad/local/num_skip.hpp
  • branches/compare_op/speed/cppad/det_lu.cpp

    r3311 r3604  
    9898                        f.optimize();
    9999
     100                // skip comparison operators
     101                f.compare_change_count(0);
     102
    100103                // evaluate and return gradient using reverse mode
    101104                f.Forward(0, matrix);
  • branches/compare_op/speed/cppad/det_minor.cpp

    r3311 r3604  
    103103                if( global_optimize )
    104104                        f.optimize();
     105
     106                // skip comparison operators
     107                f.compare_change_count(0);
    105108       
    106109                // evaluate the determinant at the new matrix value
     
    128131                if( global_optimize )
    129132                        f.optimize();
     133
     134                // skip comparison operators
     135                f.compare_change_count(0);
    130136       
    131137                // ------------------------------------------------------
  • branches/compare_op/speed/cppad/mat_mul.cpp

    r3311 r3604  
    116116                        f.optimize();
    117117
     118                // skip comparison operators
     119                f.compare_change_count(0);
     120
    118121                // evaluate and return gradient using reverse mode
    119122                z  = f.Forward(0, x);
     
    149152                if( global_optimize )
    150153                        f.optimize();
     154
     155                // skip comparison operators
     156                f.compare_change_count(0);
     157
    151158                while(repeat--)
    152159                {       // get a next matrix
  • branches/compare_op/speed/cppad/ode.cpp

    r3311 r3604  
    9797                        f.optimize();
    9898
     99                // skip comparison operators
     100                f.compare_change_count(0);
     101
    99102                jacobian = f.Jacobian(x);
    100103        }
     
    116119                if( global_optimize )
    117120                        f.optimize();
     121
     122                // skip comparison operators
     123                f.compare_change_count(0);
     124
    118125                while(repeat--)
    119126                {       // get next argument value
  • branches/compare_op/speed/cppad/poly.cpp

    r3311 r3604  
    114114                        f.optimize();
    115115
     116                // skip comparison operators
     117                f.compare_change_count(0);
     118
    116119                // pre-allocate memory for three forward mode calculations
    117120                f.capacity_order(3);
     
    145148                        f.optimize();
    146149
     150                // skip comparison operators
     151                f.compare_change_count(0);
     152
    147153                while(repeat--)
    148154                {       // sufficient memory is allocated by second repetition
  • branches/compare_op/speed/cppad/sparse_hessian.cpp

    r3565 r3604  
    1 /* $Id: sparse_hessian.cpp 3552 2015-01-03 12:41:46Z bradbell $ */
     1/* $Id$ */
    22/* --------------------------------------------------------------------------
    33CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     
    157157                        f.optimize();
    158158
     159                // skip comparison operators
     160                f.compare_change_count(0);
     161
    159162                // calculate the Hessian sparsity pattern for this function
    160163                if( global_boolsparsity )
     
    195198                        f.optimize();
    196199
     200                // skip comparison operators
     201                f.compare_change_count(0);
     202
    197203                // calculate the Hessian sparsity pattern for this function
    198204                if( global_boolsparsity)
  • branches/compare_op/speed/cppad/sparse_jacobian.cpp

    r3581 r3604  
    139139                        f.optimize();
    140140
     141                // skip comparison operators
     142                f.compare_change_count(0);
     143
    141144                // calculate the Jacobian sparsity pattern for this function
    142145                if( global_boolsparsity )
     
    178181                        f.optimize();
    179182
     183                // skip comparison operators
     184                f.compare_change_count(0);
     185
    180186                // calculate the Jacobian sparsity pattern for this function
    181187                if( global_boolsparsity )
Note: See TracChangeset for help on using the changeset viewer.