Changeset 1584


Ignore:
Timestamp:
Nov 21, 2009 12:54:51 PM (11 years ago)
Author:
bradbell
Message:

branches/multiple_result: Convert pow operations to use final result for addressing.

for_sparse_jac.cpp: add new test for pow operator.
rev_sparse_jac.cpp: add new test for pow operator.
optimize.cpp: start pow test cases at 2 instead of 1.
rev_sparse_hes.cpp: improve pow operator test.
player.hpp: convert pow operators to return final as primary result.
prototype.hpp: convert pow operators to use final result for adressing.
pow_op.hpp: change address of primary result in call to operations.
for_jac_sweep.hpp: change address of primary result for pow.
optimize.hpp: no longer necessary to kludge pow operator.
ad_copy.hpp: remove usage of '# if 0' comment block.
forward0sweep.hpp: convert pow to use final as adressing result.
recorder.hpp: convert pow operators to return final as primary result.
forward_sweep.hpp: convert pow to use final as adressing result.
rev_jac_sweep.hpp: change address of primary result for pow, fix trace.
define.hpp: remove kludge pow operator macro.
rev_hes_sweep.hpp: change address of primary result for pow, fix trace.
pow.hpp: remove calls to kludge pow operator macro.
reversed_sweep.hpp: convert pow to use final as adressing result.
det_by_lu.hpp: remove usage of '# if 0' comment block.

Location:
branches/multiple_result
Files:
19 edited

Legend:

Unmodified
Added
Removed
  • branches/multiple_result/cppad/local/ad_copy.hpp

    r1369 r1584  
    44
    55/* --------------------------------------------------------------------------
    6 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-07 Bradley M. Bell
     6CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-09 Bradley M. Bell
    77
    88CppAD is distributed under multiple licenses. This distribution is under
     
    9595namespace CppAD {
    9696
    97 # if 0
     97/*
    9898// use default copy constructor and assignment operator
    9999// because they may be optimized better by the compiler
     
    120120        return *this;
    121121}
    122 # endif
     122*/
    123123
    124124// constructor and assignment from Base type
  • branches/multiple_result/cppad/local/define.hpp

    r1580 r1584  
    1919
    2020*/
    21 
    22 /*!
    23 \def CPPAD_POW_FINAL_RESULT
    24 The pow function is a special case where the final result is the last,
    25 instead of the first, of the multiple variables created.
    26 This macro maps the first result address to the address that corresponds
    27 to the primary pow function result.
    28 This is a kludge so that the log, exp, and mul functions can be used as
    29 operators to create the power function.
    30 The kludge can be fixed by making the final result the primay result
    31 for all operators.
    32 */
    33 # define CPPAD_POW_FINAL_RESULT(address, op)  (address +  2)
    3421
    3522/*!
  • branches/multiple_result/cppad/local/for_jac_sweep.hpp

    r1539 r1584  
    131131# if CPPAD_FOR_JAC_SWEEP_TRACE
    132132        std::cout << std::endl;
    133         CppAD::vector<bool> z_value(limit;
     133        CppAD::vector<bool> z_value(limit);
    134134# endif
    135135
     
    356356
    357357                        case PowvpOp:
    358                         // Pow operator is a special case where final result
    359                         // comes at the end of the three variables
    360358                        CPPAD_ASSERT_NARG_NRES(op, 2, 3);
    361359                        forward_sparse_jacobian_unary_op(
    362                                 i_var + 2, arg[0], var_sparsity
     360                                i_var, arg[0], var_sparsity
    363361                        );
    364362                        break;
     
    366364
    367365                        case PowpvOp:
    368                         // Pow operator is a special case where final result
    369                         // comes at the end of the three variables
    370366                        CPPAD_ASSERT_NARG_NRES(op, 2, 3);
    371367                        forward_sparse_jacobian_unary_op(
    372                                 i_var + 2, arg[1], var_sparsity
     368                                i_var, arg[1], var_sparsity
    373369                        );
    374370                        break;
     
    376372
    377373                        case PowvvOp:
    378                         // Pow operator is a special case where final result
    379                         // comes at the end of the three variables
    380374                        CPPAD_ASSERT_NARG_NRES(op, 2, 3);
    381375                        forward_sparse_jacobian_binary_op(
    382                                 i_var + 2, arg, var_sparsity
     376                                i_var, arg, var_sparsity
    383377                        );
    384378                        break;
     
    489483# if CPPAD_FOR_JAC_SWEEP_TRACE
    490484                // value for this variable
    491                 for(j = 0; j < limit j++)
     485                for(j = 0; j < limit; j++)
    492486                        z_value[j] = false;
    493487                var_sparsity.begin(i_var);
     
    513507        }
    514508# endif
    515         CPPAD_ASSERT_UNKNOWN( (i_var + NumRes(op) ) == play->num_rec_var() );
     509# ifndef NDEBUG
     510        // temporary: remove when all cases with NumRes(op) > 1
     511        // have been converted
     512        size_t check = i_var + NumRes(op);
     513        switch(op)
     514        {       case PowpvOp:
     515                case PowvpOp:
     516                case PowvvOp:
     517                check = i_var + 1;
     518                break;
     519
     520                default:
     521                break;
     522        }
     523        CPPAD_ASSERT_UNKNOWN( check == play->num_rec_var() );
     524# endif
    516525
    517526        if( vecad_ind != CPPAD_NULL )
  • branches/multiple_result/cppad/local/forward0sweep.hpp

    r1497 r1584  
    479479                size_t       i_tmp  = i_var;
    480480                Base*        Z_tmp  = Taylor + i_var * J;
    481                 if( op == PowvpOp || op == PowpvOp || op == PowvvOp )
    482                 {       i_tmp  += 2;
    483                         Z_tmp  += 2 * J;
    484                 }
     481
    485482                printOp(
    486483                        std::cout,
     
    499496        }
    500497# endif
    501         CPPAD_ASSERT_UNKNOWN( (i_var + NumRes(op)) == Rec->num_rec_var() );
     498
     499# ifndef NDEBUG
     500        // temporary: remove when all cases with NumRes(op) > 1
     501        // have been converted
     502        size_t check = i_var + NumRes(op);
     503        switch(op)
     504        {       case PowpvOp:
     505                case PowvpOp:
     506                case PowvvOp:
     507                check = i_var + 1;
     508                break;
     509
     510                default:
     511                break;
     512        }
     513        CPPAD_ASSERT_UNKNOWN( check == Rec->num_rec_var() );
     514# endif
     515
    502516        if( VectorInd != CPPAD_NULL )
    503517                CPPAD_TRACK_DEL_VEC(VectorInd);
  • branches/multiple_result/cppad/local/forward_sweep.hpp

    r1497 r1584  
    531531                size_t       i_tmp  = i_var;
    532532                Base*        Z_tmp  = Taylor + J * i_var;
    533                 if( op == PowvpOp || op == PowpvOp || op == PowvvOp )
    534                 {       i_tmp  += 2;
    535                         Z_tmp  += 2 * J;
    536                 }
    537533                printOp(
    538534                        std::cout,
     
    551547        }
    552548# endif
    553         CPPAD_ASSERT_UNKNOWN( (i_var + NumRes(op) ) == Rec->num_rec_var() );
     549# ifndef NDEBUG
     550        // temporary: remove when all cases with NumRes(op) > 1
     551        // have been converted
     552        size_t check = i_var + NumRes(op);
     553        switch(op)
     554        {       case PowpvOp:
     555                case PowvpOp:
     556                case PowvvOp:
     557                check = i_var + 1;
     558                break;
     559
     560                default:
     561                break;
     562        }
     563        CPPAD_ASSERT_UNKNOWN( check == Rec->num_rec_var() );
     564# endif
    554565        if( VectorInd != CPPAD_NULL )
    555566                CPPAD_TRACK_DEL_VEC(VectorInd);
  • branches/multiple_result/cppad/local/optimize.hpp

    r1580 r1584  
    265265                {
    266266                        // Unary operator where operand is arg[0]
    267                         case PowvpOp:
    268                         i_var = CPPAD_POW_FINAL_RESULT(i_var, op);
    269267                        case AbsOp:
    270268                        case AddvpOp:
     
    279277                        case LogOp:
    280278                        case MulvpOp:
     279                        case PowvpOp:
    281280                        case SinOp:
    282281                        case SinhOp:
     
    287286
    288287                        // Unary operator where operand is arg[1]
    289                         case PowpvOp:
    290                         i_var = CPPAD_POW_FINAL_RESULT(i_var, op);
    291288                        case AddpvOp:
    292289                        case DivpvOp:
    293290                        case MulpvOp:
    294291                        case SubpvOp:
     292                        case PowpvOp:
    295293                        case PrivOp:
    296294                        connected[ arg[1] ] |= connected[ i_var ];
     
    298296
    299297                        // Binary operator where operands are arg[0], arg[1]
    300                         case PowvvOp:
    301                         i_var = CPPAD_POW_FINAL_RESULT(i_var, op);
    302298                        case AddvvOp:
    303299                        case DivvvOp:
    304300                        case MulvvOp:
     301                        case PowvvOp:
    305302                        case SubvvOp:
    306303                        connected[ arg[0] ] |= connected[ i_var ];
     
    442439                        keep = vecad_connected[i];
    443440                        break;
    444 
    445                         case PowpvOp:
    446                         case PowvpOp:
    447                         case PowvvOp:
    448                         i_var = CPPAD_POW_FINAL_RESULT(i_var, op);
    449441
    450442                        default:
     
    500492                        rec->PutArg( new_arg[0], new_arg[1] );
    501493                        new_var[ i_var ] = rec->PutOp(op);
    502                         new_var[ i_var ] =
    503                                 CPPAD_POW_FINAL_RESULT(new_var[ i_var ], op);
    504494                        break;
    505495
     
    527517                        rec->PutArg( new_arg[0], new_arg[1] );
    528518                        new_var[ i_var ] = rec->PutOp(op);
    529                         new_var[ i_var ] =
    530                                 CPPAD_POW_FINAL_RESULT(new_var[ i_var ], op);
    531519                        break;
    532520
     
    555543                        rec->PutArg( new_arg[0], new_arg[1] );
    556544                        new_var[ i_var ] = rec->PutOp(op);
    557                         new_var[ i_var ] =
    558                                 CPPAD_POW_FINAL_RESULT(new_var[ i_var ], op);
    559545                        break;
    560546
  • branches/multiple_result/cppad/local/player.hpp

    r1561 r1584  
    529529                CPPAD_ASSERT_UNKNOWN( op_arg_ + NumArg(op) <= num_rec_op_arg_ );
    530530                CPPAD_ASSERT_UNKNOWN( var_index_ + NumRes(op) <= num_rec_var_ );
     531
     532                // temporary: remove when all cases with NumRes(op) > 1
     533                // have been converted
     534                switch( op )
     535                {       case PowpvOp:
     536                        case PowvpOp:
     537                        case PowvvOp:
     538                        var_index += NumRes(op) - 1;
     539                        break;
     540
     541                        default:
     542                        break;
     543                }
    531544        }
    532545        /*!
     
    605618                var_index   = var_index_;
    606619
     620                // temporary: remove when all cases with NumRes(op) > 1
     621                // have been converted
     622                switch( op )
     623                {       case PowpvOp:
     624                        case PowvpOp:
     625                        case PowvvOp:
     626                        var_index += NumRes(op) - 1;
     627                        break;
     628
     629                        default:
     630                        break;
     631                }
     632
    607633        }
    608634
  • branches/multiple_result/cppad/local/pow.hpp

    r1580 r1584  
    157157                        // put operator in the tape
    158158                        result.taddr_ = tape->Rec_.PutOp(PowvvOp);
    159                         result.taddr_ =
    160                                 CPPAD_POW_FINAL_RESULT(result.taddr_, PowvvOp);
    161159
    162160                        // make result a variable
     
    177175                        // put operator in the tape
    178176                        result.taddr_ = tape->Rec_.PutOp(PowvpOp);
    179                         result.taddr_ =
    180                                 CPPAD_POW_FINAL_RESULT(result.taddr_, PowvpOp);
    181177
    182178                        // make result a variable
     
    199195                        // put operator in the tape
    200196                        result.taddr_ = tape->Rec_.PutOp(PowpvOp);
    201                         result.taddr_ =
    202                                 CPPAD_POW_FINAL_RESULT(result.taddr_, PowpvOp);
    203197
    204198                        // make result a variable
  • branches/multiple_result/cppad/local/pow_op.hpp

    r1451 r1584  
    4040        Base*         taylor      )
    4141{
     42        // convert from final result to first result
     43        i_z -= 2; // NumRes(PowvvOp) - 1;
     44
    4245        // check assumptions
    4346        CPPAD_ASSERT_UNKNOWN( NumArg(PowvvOp) == 2 );
     
    9699        Base*         taylor      )
    97100{
     101        // convert from final result to first result
     102        i_z -= 2; // NumRes(PowvvOp) - 1;
     103
    98104        // check assumptions
    99105        CPPAD_ASSERT_UNKNOWN( NumArg(PowvvOp) == 2 );
     
    140146        Base*         partial     )
    141147{
     148        // convert from final result to first result
     149        i_z -= 2; // NumRes(PowvvOp) - 1;
     150
    142151        // check assumptions
    143152        CPPAD_ASSERT_UNKNOWN( NumArg(PowvvOp) == 2 );
     
    190199        Base*         taylor      )
    191200{
     201        // convert from final result to first result
     202        i_z -= 2; // NumRes(PowpvOp) - 1;
     203
    192204        // check assumptions
    193205        CPPAD_ASSERT_UNKNOWN( NumArg(PowpvOp) == 2 );
     
    249261        Base*         taylor      )
    250262{
     263        // convert from final result to first result
     264        i_z -= 2; // NumRes(PowpvOp) - 1;
     265
    251266        // check assumptions
    252267        CPPAD_ASSERT_UNKNOWN( NumArg(PowpvOp) == 2 );
     
    298313        Base*         partial     )
    299314{
     315        // convert from final result to first result
     316        i_z -= 2; // NumRes(PowpvOp) - 1;
     317
    300318        // check assumptions
    301319        CPPAD_ASSERT_UNKNOWN( NumArg(PowvvOp) == 2 );
     
    345363        Base*         taylor      )
    346364{
     365        // convert from final result to first result
     366        i_z -= 2; // NumRes(PowvpOp) - 1;
     367
    347368        // check assumptions
    348369        CPPAD_ASSERT_UNKNOWN( NumArg(PowvpOp) == 2 );
     
    398419        Base*         taylor      )
    399420{
     421        // convert from final result to first result
     422        i_z -= 2; // NumRes(PowvpOp) - 1;
     423
    400424        // check assumptions
    401425        CPPAD_ASSERT_UNKNOWN( NumArg(PowvpOp) == 2 );
     
    447471        Base*         partial     )
    448472{
     473        // convert from final result to first result
     474        i_z -= 2; // NumRes(PowvpOp) - 1;
     475
    449476        // check assumptions
    450477        CPPAD_ASSERT_UNKNOWN( NumArg(PowvpOp) == 2 );
  • branches/multiple_result/cppad/local/prototype_op.hpp

    r1550 r1584  
    663663
    664664\param i_z
    665 variable index corresponding to the first result for this operation;
     665variable index corresponding to the final result for this operation;
    666666i.e. the row index in \a taylor corresponding to z.
    667667Note that there are three results for this operation,
     
    672672        z_2 = exp(z1)
    673673\endverbatim
    674 It follows that the last result is equal to z; i.e., z = z_2 = pow(x, y).
     674It follows that the final result is equal to z; i.e., z = z_2 = pow(x, y).
    675675
    676676\param arg
     
    712712\li NumArg(op) == 2
    713713\li NumRes(op) == 3
    714 \li If x is a variable, \a arg[0] < \a i_z
    715 \li If y is a variable, \a arg[1] < \a i_z
     714\li If x is a variable, \a arg[0] < \a i_z - 2
     715\li If y is a variable, \a arg[1] < \a i_z - 2
    716716\li \a d < \a nc_taylor
    717717*/
     
    737737
    738738\param i_z
    739 variable index corresponding to the first result for this operation;
     739variable index corresponding to the final result for this operation;
    740740i.e. the row index in \a taylor corresponding to z.
    741741Note that there are three results for this operation,
     
    746746        z_2 = exp(z1)
    747747\endverbatim
    748 It follows that the last result is equal to z; i.e., z = z_2 = pow(x, y).
     748It follows that the final result is equal to z; i.e., z = z_2 = pow(x, y).
    749749
    750750\param arg
     
    780780\li NumArg(op) == 2
    781781\li NumRes(op) == 3
    782 \li If x is a variable, \a arg[0] < \a i_z
    783 \li If y is a variable, \a arg[1] < \a i_z
     782\li If x is a variable, \a arg[0] < \a i_z - 2
     783\li If y is a variable, \a arg[1] < \a i_z - 2
    784784*/
    785785template <class Base>
     
    814814
    815815\param i_z
    816 variable index corresponding to the first result for this operation;
     816variable index corresponding to the final result for this operation;
    817817i.e. the row index in \a taylor corresponding to z.
    818818Note that there are three results for this operation,
     
    823823        z_2 = exp(z1)
    824824\endverbatim
    825 It follows that the last result is equal to z; i.e., z = z_2 = pow(x, y).
     825It follows that the final result is equal to z; i.e., z = z_2 = pow(x, y).
    826826
    827827\param arg
     
    890890\li NumArg(op) == 2
    891891\li NumRes(op) == 3
    892 \li \a If x is a variable, arg[0] < \a i_z
    893 \li \a If y is a variable, arg[1] < \a i_z
     892\li \a If x is a variable, arg[0] < \a i_z - 2
     893\li \a If y is a variable, arg[1] < \a i_z - 2
    894894\li \a d < \a nc_taylor
    895895\li \a d < \a nc_partial
  • branches/multiple_result/cppad/local/recorder.hpp

    r1541 r1584  
    239239        num_rec_var_ += NumRes(op);
    240240
     241        // temporary: make this the only return value when all cases with
     242        // all cases with NumRes(op) > 1 have been converted
     243        switch( op )
     244        {       case PowpvOp:
     245                case PowvpOp:
     246                case PowvvOp:
     247                return num_rec_var_ - 1;
     248                break;
     249
     250                default:
     251                break;
     252        }
     253
    241254        return varIndex;
    242255}
  • branches/multiple_result/cppad/local/rev_hes_sweep.hpp

    r1539 r1584  
    180180                CPPAD_ASSERT_UNKNOWN( (i_op <= n) | (op != InvOp) );
    181181
     182
     183                // rest of information depends on the case
     184                switch( op )
     185                {
     186                        case AbsOp:
     187                        CPPAD_ASSERT_NARG_NRES(op, 1, 1)
     188                        reverse_sparse_hessian_linear_unary_op(
     189                        i_var, arg[0], RevJac, for_jac_sparse, rev_hes_sparse
     190                        );
     191                        break;
     192                        // -------------------------------------------------
     193
     194                        case AddvvOp:
     195                        CPPAD_ASSERT_NARG_NRES(op, 2, 1)
     196                        reverse_sparse_hessian_addsub_op(
     197                        i_var, arg, RevJac, for_jac_sparse, rev_hes_sparse
     198                        );
     199                        break;
     200                        // -------------------------------------------------
     201
     202                        case AddpvOp:
     203                        CPPAD_ASSERT_NARG_NRES(op, 2, 1)
     204                        reverse_sparse_hessian_linear_unary_op(
     205                        i_var, arg[1], RevJac, for_jac_sparse, rev_hes_sparse
     206                        );
     207                        break;
     208                        // -------------------------------------------------
     209
     210                        case AddvpOp:
     211                        CPPAD_ASSERT_NARG_NRES(op, 2, 1)
     212                        reverse_sparse_hessian_linear_unary_op(
     213                        i_var, arg[0], RevJac, for_jac_sparse, rev_hes_sparse
     214                        );
     215                        break;
     216                        // -------------------------------------------------
     217
     218                        case AcosOp:
     219                        // acos(x) and sqrt(1 - x * x) are computed in pairs
     220                        // but i_var + 1 should only be used here
     221                        CPPAD_ASSERT_NARG_NRES(op, 1, 2)
     222                        reverse_sparse_hessian_nonlinear_unary_op(
     223                        i_var, arg[0], RevJac, for_jac_sparse, rev_hes_sparse
     224                        );
     225                        break;
     226                        // -------------------------------------------------
     227
     228                        case AsinOp:
     229                        // asin(x) and sqrt(1 - x * x) are computed in pairs
     230                        // but i_var + 1 should only be used here
     231                        CPPAD_ASSERT_NARG_NRES(op, 1, 2)
     232                        reverse_sparse_hessian_nonlinear_unary_op(
     233                        i_var, arg[0], RevJac, for_jac_sparse, rev_hes_sparse
     234                        );
     235                        break;
     236                        // -------------------------------------------------
     237
     238                        case AtanOp:
     239                        // atan(x) and 1 + x * x must be computed in pairs
     240                        // but i_var + 1 should only be used here
     241                        CPPAD_ASSERT_NARG_NRES(op, 1, 2)
     242                        reverse_sparse_hessian_nonlinear_unary_op(
     243                        i_var, arg[0], RevJac, for_jac_sparse, rev_hes_sparse
     244                        );
     245                        break;
     246                        // -------------------------------------------------
     247                        case CExpOp:
     248                        reverse_sparse_hessian_cond_op(
     249                                i_var, arg, num_par, RevJac, rev_hes_sparse
     250                        );
     251                        break;
     252                        // ---------------------------------------------------
     253
     254                        case ComOp:
     255                        CPPAD_ASSERT_NARG_NRES(op, 4, 0)
     256                        CPPAD_ASSERT_UNKNOWN( arg[1] > 1 );
     257                        break;
     258                        // --------------------------------------------------
     259
     260                        case CosOp:
     261                        // cosine and sine must come in pairs
     262                        // but i_var + 1 should only be used here
     263                        CPPAD_ASSERT_NARG_NRES(op, 1, 2)
     264                        reverse_sparse_hessian_nonlinear_unary_op(
     265                        i_var, arg[0], RevJac, for_jac_sparse, rev_hes_sparse
     266                        );
     267                        break;
     268                        // ---------------------------------------------------
     269
     270                        case CoshOp:
     271                        // hyperbolic cosine and sine must come in pairs
     272                        // but i_var + 1 should only be used here
     273                        CPPAD_ASSERT_NARG_NRES(op, 1, 2)
     274                        reverse_sparse_hessian_nonlinear_unary_op(
     275                        i_var, arg[0], RevJac, for_jac_sparse, rev_hes_sparse
     276                        );
     277                        break;
     278                        // -------------------------------------------------
     279
     280                        case DisOp:
     281                        CPPAD_ASSERT_NARG_NRES(op, 2, 1)
     282
     283                        break;
     284                        // -------------------------------------------------
     285
     286                        case DivvvOp:
     287                        CPPAD_ASSERT_NARG_NRES(op, 2, 1)
     288                        reverse_sparse_hessian_div_op(
     289                        i_var, arg, RevJac, for_jac_sparse, rev_hes_sparse
     290                        );
     291                        break;
     292                        // -------------------------------------------------
     293
     294                        case DivpvOp:
     295                        CPPAD_ASSERT_NARG_NRES(op, 2, 1)
     296                        reverse_sparse_hessian_nonlinear_unary_op(
     297                        i_var, arg[1], RevJac, for_jac_sparse, rev_hes_sparse
     298                        );
     299                        break;
     300                        // -------------------------------------------------
     301
     302                        case DivvpOp:
     303                        CPPAD_ASSERT_NARG_NRES(op, 2, 1)
     304                        reverse_sparse_hessian_linear_unary_op(
     305                        i_var, arg[0], RevJac, for_jac_sparse, rev_hes_sparse
     306                        );
     307                        break;
     308                        // -------------------------------------------------
     309
     310                        case ExpOp:
     311                        CPPAD_ASSERT_NARG_NRES(op, 1, 1)
     312                        reverse_sparse_hessian_nonlinear_unary_op(
     313                        i_var, arg[0], RevJac, for_jac_sparse, rev_hes_sparse
     314                        );
     315                        break;
     316                        // -------------------------------------------------
     317
     318                        case InvOp:
     319                        CPPAD_ASSERT_NARG_NRES(op, 0, 1)
     320                        // Z is already defined
     321                        break;
     322                        // -------------------------------------------------
     323
     324                        case LdpOp:
     325                        reverse_sparse_hessian_load_op(
     326                                op,
     327                                i_var,
     328                                arg,
     329                                num_vecad_ind,
     330                                vecad_ind,
     331                                rev_hes_sparse,
     332                                vecad_sparse,
     333                                RevJac,
     334                                vecad_jac
     335                        );
     336                        break;
     337                        // -------------------------------------------------
     338
     339                        case LdvOp:
     340                        reverse_sparse_hessian_load_op(
     341                                op,
     342                                i_var,
     343                                arg,
     344                                num_vecad_ind,
     345                                vecad_ind,
     346                                rev_hes_sparse,
     347                                vecad_sparse,
     348                                RevJac,
     349                                vecad_jac
     350                        );
     351                        break;
     352                        // -------------------------------------------------
     353
     354                        case LogOp:
     355                        CPPAD_ASSERT_NARG_NRES(op, 1, 1)
     356                        reverse_sparse_hessian_nonlinear_unary_op(
     357                        i_var, arg[0], RevJac, for_jac_sparse, rev_hes_sparse
     358                        );
     359                        break;
     360                        // -------------------------------------------------
     361
     362                        case MulvvOp:
     363                        CPPAD_ASSERT_NARG_NRES(op, 2, 1)
     364                        reverse_sparse_hessian_mul_op(
     365                        i_var, arg, RevJac, for_jac_sparse, rev_hes_sparse
     366                        );
     367                        break;
     368                        // -------------------------------------------------
     369
     370                        case MulpvOp:
     371                        CPPAD_ASSERT_NARG_NRES(op, 2, 1)
     372                        reverse_sparse_hessian_linear_unary_op(
     373                        i_var, arg[1], RevJac, for_jac_sparse, rev_hes_sparse
     374                        );
     375                        break;
     376                        // -------------------------------------------------
     377
     378                        case MulvpOp:
     379                        CPPAD_ASSERT_NARG_NRES(op, 2, 1)
     380                        reverse_sparse_hessian_linear_unary_op(
     381                        i_var, arg[0], RevJac, for_jac_sparse, rev_hes_sparse
     382                        );
     383                        break;
     384                        // -------------------------------------------------
     385
     386                        case NonOp:
     387                        CPPAD_ASSERT_NARG_NRES(op, 0, 1)
     388
     389                        break;
     390                        // -------------------------------------------------
     391
     392                        case ParOp:
     393                        CPPAD_ASSERT_NARG_NRES(op, 1, 1)
     394
     395                        break;
     396                        // -------------------------------------------------
     397
     398                        case PowpvOp:
     399                        CPPAD_ASSERT_NARG_NRES(op, 2, 3)
     400                        reverse_sparse_hessian_nonlinear_unary_op(
     401                        i_var, arg[1], RevJac, for_jac_sparse, rev_hes_sparse
     402                        );
     403                        break;
     404                        // -------------------------------------------------
     405
     406                        case PowvpOp:
     407                        CPPAD_ASSERT_NARG_NRES(op, 2, 3)
     408                        reverse_sparse_hessian_nonlinear_unary_op(
     409                        i_var, arg[0], RevJac, for_jac_sparse, rev_hes_sparse
     410                        );
     411                        break;
     412                        // -------------------------------------------------
     413
     414                        case PowvvOp:
     415                        CPPAD_ASSERT_NARG_NRES(op, 2, 3)
     416                        reverse_sparse_hessian_pow_op(
     417                        i_var, arg, RevJac, for_jac_sparse, rev_hes_sparse
     418                        );
     419                        break;
     420                        // -------------------------------------------------
     421
     422                        case PripOp:
     423                        CPPAD_ASSERT_NARG_NRES(op, 2, 0);
     424                        break;
     425                        // -------------------------------------------------
     426
     427                        case PrivOp:
     428                        CPPAD_ASSERT_NARG_NRES(op, 2, 0);
     429                        break;
     430                        // -------------------------------------------------
     431
     432                        case SinOp:
     433                        // sine and cosine must come in pairs
     434                        // but i_var + 1 should only be used here
     435                        CPPAD_ASSERT_NARG_NRES(op, 1, 2)
     436                        reverse_sparse_hessian_nonlinear_unary_op(
     437                        i_var, arg[0], RevJac, for_jac_sparse, rev_hes_sparse
     438                        );
     439                        break;
     440                        // -------------------------------------------------
     441
     442                        case SinhOp:
     443                        // sine and cosine must come in pairs
     444                        // but i_var + 1 should only be used here
     445                        CPPAD_ASSERT_NARG_NRES(op, 1, 2)
     446                        reverse_sparse_hessian_nonlinear_unary_op(
     447                        i_var, arg[0], RevJac, for_jac_sparse, rev_hes_sparse
     448                        );
     449                        break;
     450                        // -------------------------------------------------
     451
     452                        case SqrtOp:
     453                        CPPAD_ASSERT_NARG_NRES(op, 1, 1)
     454                        reverse_sparse_hessian_nonlinear_unary_op(
     455                        i_var, arg[0], RevJac, for_jac_sparse, rev_hes_sparse
     456                        );
     457                        break;
     458                        // -------------------------------------------------
     459
     460                        case StppOp:
     461                        // sparsity cannot propagate through a parameter
     462                        CPPAD_ASSERT_NARG_NRES(op, 3, 0)
     463                        break;
     464                        // -------------------------------------------------
     465
     466                        case StpvOp:
     467                        reverse_sparse_hessian_store_op(
     468                                op,
     469                                arg,
     470                                num_vecad_ind,
     471                                vecad_ind,
     472                                rev_hes_sparse,
     473                                vecad_sparse,
     474                                RevJac,
     475                                vecad_jac
     476                        );
     477                        break;
     478                        // -------------------------------------------------
     479
     480                        case StvpOp:
     481                        // sparsity cannot propagate through a parameter
     482                        CPPAD_ASSERT_NARG_NRES(op, 3, 0)
     483                        break;
     484                        // -------------------------------------------------
     485
     486                        case StvvOp:
     487                        reverse_sparse_hessian_store_op(
     488                                op,
     489                                arg,
     490                                num_vecad_ind,
     491                                vecad_ind,
     492                                rev_hes_sparse,
     493                                vecad_sparse,
     494                                RevJac,
     495                                vecad_jac
     496                        );
     497                        break;
     498                        // -------------------------------------------------
     499
     500                        case SubvvOp:
     501                        CPPAD_ASSERT_NARG_NRES(op, 2, 1)
     502                        reverse_sparse_hessian_addsub_op(
     503                        i_var, arg, RevJac, for_jac_sparse, rev_hes_sparse
     504                        );
     505                        break;
     506                        // -------------------------------------------------
     507
     508                        case SubpvOp:
     509                        CPPAD_ASSERT_NARG_NRES(op, 2, 1)
     510                        reverse_sparse_hessian_linear_unary_op(
     511                        i_var, arg[1], RevJac, for_jac_sparse, rev_hes_sparse
     512                        );
     513                        break;
     514                        // -------------------------------------------------
     515
     516                        case SubvpOp:
     517                        CPPAD_ASSERT_NARG_NRES(op, 2, 1)
     518                        reverse_sparse_hessian_linear_unary_op(
     519                        i_var, arg[0], RevJac, for_jac_sparse, rev_hes_sparse
     520                        );
     521                        break;
     522                        // -------------------------------------------------
     523
     524                        default:
     525                        CPPAD_ASSERT_UNKNOWN(0);
     526                }
    182527# if CPPAD_REV_HES_SWEEP_TRACE
    183528                for(j = 0; j < limit; j++)
     
    211556                );
    212557# endif
    213 
    214                 // rest of information depends on the case
    215                 switch( op )
    216                 {
    217                         case AbsOp:
    218                         CPPAD_ASSERT_NARG_NRES(op, 1, 1)
    219                         reverse_sparse_hessian_linear_unary_op(
    220                         i_var, arg[0], RevJac, for_jac_sparse, rev_hes_sparse
    221                         );
    222                         break;
    223                         // -------------------------------------------------
    224 
    225                         case AddvvOp:
    226                         CPPAD_ASSERT_NARG_NRES(op, 2, 1)
    227                         reverse_sparse_hessian_addsub_op(
    228                         i_var, arg, RevJac, for_jac_sparse, rev_hes_sparse
    229                         );
    230                         break;
    231                         // -------------------------------------------------
    232 
    233                         case AddpvOp:
    234                         CPPAD_ASSERT_NARG_NRES(op, 2, 1)
    235                         reverse_sparse_hessian_linear_unary_op(
    236                         i_var, arg[1], RevJac, for_jac_sparse, rev_hes_sparse
    237                         );
    238                         break;
    239                         // -------------------------------------------------
    240 
    241                         case AddvpOp:
    242                         CPPAD_ASSERT_NARG_NRES(op, 2, 1)
    243                         reverse_sparse_hessian_linear_unary_op(
    244                         i_var, arg[0], RevJac, for_jac_sparse, rev_hes_sparse
    245                         );
    246                         break;
    247                         // -------------------------------------------------
    248 
    249                         case AcosOp:
    250                         // acos(x) and sqrt(1 - x * x) are computed in pairs
    251                         // but i_var + 1 should only be used here
    252                         CPPAD_ASSERT_NARG_NRES(op, 1, 2)
    253                         reverse_sparse_hessian_nonlinear_unary_op(
    254                         i_var, arg[0], RevJac, for_jac_sparse, rev_hes_sparse
    255                         );
    256                         break;
    257                         // -------------------------------------------------
    258 
    259                         case AsinOp:
    260                         // asin(x) and sqrt(1 - x * x) are computed in pairs
    261                         // but i_var + 1 should only be used here
    262                         CPPAD_ASSERT_NARG_NRES(op, 1, 2)
    263                         reverse_sparse_hessian_nonlinear_unary_op(
    264                         i_var, arg[0], RevJac, for_jac_sparse, rev_hes_sparse
    265                         );
    266                         break;
    267                         // -------------------------------------------------
    268 
    269                         case AtanOp:
    270                         // atan(x) and 1 + x * x must be computed in pairs
    271                         // but i_var + 1 should only be used here
    272                         CPPAD_ASSERT_NARG_NRES(op, 1, 2)
    273                         reverse_sparse_hessian_nonlinear_unary_op(
    274                         i_var, arg[0], RevJac, for_jac_sparse, rev_hes_sparse
    275                         );
    276                         break;
    277                         // -------------------------------------------------
    278                         case CExpOp:
    279                         reverse_sparse_hessian_cond_op(
    280                                 i_var, arg, num_par, RevJac, rev_hes_sparse
    281                         );
    282                         break;
    283                         // ---------------------------------------------------
    284 
    285                         case ComOp:
    286                         CPPAD_ASSERT_NARG_NRES(op, 4, 0)
    287                         CPPAD_ASSERT_UNKNOWN( arg[1] > 1 );
    288                         break;
    289                         // --------------------------------------------------
    290 
    291                         case CosOp:
    292                         // cosine and sine must come in pairs
    293                         // but i_var + 1 should only be used here
    294                         CPPAD_ASSERT_NARG_NRES(op, 1, 2)
    295                         reverse_sparse_hessian_nonlinear_unary_op(
    296                         i_var, arg[0], RevJac, for_jac_sparse, rev_hes_sparse
    297                         );
    298                         break;
    299                         // ---------------------------------------------------
    300 
    301                         case CoshOp:
    302                         // hyperbolic cosine and sine must come in pairs
    303                         // but i_var + 1 should only be used here
    304                         CPPAD_ASSERT_NARG_NRES(op, 1, 2)
    305                         reverse_sparse_hessian_nonlinear_unary_op(
    306                         i_var, arg[0], RevJac, for_jac_sparse, rev_hes_sparse
    307                         );
    308                         break;
    309                         // -------------------------------------------------
    310 
    311                         case DisOp:
    312                         CPPAD_ASSERT_NARG_NRES(op, 2, 1)
    313 
    314                         break;
    315                         // -------------------------------------------------
    316 
    317                         case DivvvOp:
    318                         CPPAD_ASSERT_NARG_NRES(op, 2, 1)
    319                         reverse_sparse_hessian_div_op(
    320                         i_var, arg, RevJac, for_jac_sparse, rev_hes_sparse
    321                         );
    322                         break;
    323                         // -------------------------------------------------
    324 
    325                         case DivpvOp:
    326                         CPPAD_ASSERT_NARG_NRES(op, 2, 1)
    327                         reverse_sparse_hessian_nonlinear_unary_op(
    328                         i_var, arg[1], RevJac, for_jac_sparse, rev_hes_sparse
    329                         );
    330                         break;
    331                         // -------------------------------------------------
    332 
    333                         case DivvpOp:
    334                         CPPAD_ASSERT_NARG_NRES(op, 2, 1)
    335                         reverse_sparse_hessian_linear_unary_op(
    336                         i_var, arg[0], RevJac, for_jac_sparse, rev_hes_sparse
    337                         );
    338                         break;
    339                         // -------------------------------------------------
    340 
    341                         case ExpOp:
    342                         CPPAD_ASSERT_NARG_NRES(op, 1, 1)
    343                         reverse_sparse_hessian_nonlinear_unary_op(
    344                         i_var, arg[0], RevJac, for_jac_sparse, rev_hes_sparse
    345                         );
    346                         break;
    347                         // -------------------------------------------------
    348 
    349                         case InvOp:
    350                         CPPAD_ASSERT_NARG_NRES(op, 0, 1)
    351                         // Z is already defined
    352                         break;
    353                         // -------------------------------------------------
    354 
    355                         case LdpOp:
    356                         reverse_sparse_hessian_load_op(
    357                                 op,
    358                                 i_var,
    359                                 arg,
    360                                 num_vecad_ind,
    361                                 vecad_ind,
    362                                 rev_hes_sparse,
    363                                 vecad_sparse,
    364                                 RevJac,
    365                                 vecad_jac
    366                         );
    367                         break;
    368                         // -------------------------------------------------
    369 
    370                         case LdvOp:
    371                         reverse_sparse_hessian_load_op(
    372                                 op,
    373                                 i_var,
    374                                 arg,
    375                                 num_vecad_ind,
    376                                 vecad_ind,
    377                                 rev_hes_sparse,
    378                                 vecad_sparse,
    379                                 RevJac,
    380                                 vecad_jac
    381                         );
    382                         break;
    383                         // -------------------------------------------------
    384 
    385                         case LogOp:
    386                         CPPAD_ASSERT_NARG_NRES(op, 1, 1)
    387                         reverse_sparse_hessian_nonlinear_unary_op(
    388                         i_var, arg[0], RevJac, for_jac_sparse, rev_hes_sparse
    389                         );
    390                         break;
    391                         // -------------------------------------------------
    392 
    393                         case MulvvOp:
    394                         CPPAD_ASSERT_NARG_NRES(op, 2, 1)
    395                         reverse_sparse_hessian_mul_op(
    396                         i_var, arg, RevJac, for_jac_sparse, rev_hes_sparse
    397                         );
    398                         break;
    399                         // -------------------------------------------------
    400 
    401                         case MulpvOp:
    402                         CPPAD_ASSERT_NARG_NRES(op, 2, 1)
    403                         reverse_sparse_hessian_linear_unary_op(
    404                         i_var, arg[1], RevJac, for_jac_sparse, rev_hes_sparse
    405                         );
    406                         break;
    407                         // -------------------------------------------------
    408 
    409                         case MulvpOp:
    410                         CPPAD_ASSERT_NARG_NRES(op, 2, 1)
    411                         reverse_sparse_hessian_linear_unary_op(
    412                         i_var, arg[0], RevJac, for_jac_sparse, rev_hes_sparse
    413                         );
    414                         break;
    415                         // -------------------------------------------------
    416 
    417                         case NonOp:
    418                         CPPAD_ASSERT_NARG_NRES(op, 0, 1)
    419 
    420                         break;
    421                         // -------------------------------------------------
    422 
    423                         case ParOp:
    424                         CPPAD_ASSERT_NARG_NRES(op, 1, 1)
    425 
    426                         break;
    427                         // -------------------------------------------------
    428 
    429                         case PowpvOp:
    430                         // Pow operator is a special case where final result
    431                         // comes at the end of the three variables
    432                         CPPAD_ASSERT_NARG_NRES(op, 2, 3)
    433                         reverse_sparse_hessian_nonlinear_unary_op(
    434                         i_var+2, arg[1], RevJac, for_jac_sparse, rev_hes_sparse
    435                         );
    436                         break;
    437                         // -------------------------------------------------
    438 
    439                         case PowvpOp:
    440                         // Pow operator is a special case where final result
    441                         // comes at the end of the three variables
    442                         CPPAD_ASSERT_NARG_NRES(op, 2, 3)
    443                         reverse_sparse_hessian_nonlinear_unary_op(
    444                         i_var+2, arg[0], RevJac, for_jac_sparse, rev_hes_sparse
    445                         );
    446                         break;
    447                         // -------------------------------------------------
    448 
    449                         case PowvvOp:
    450                         // Pow operator is a special case where final result
    451                         // comes at the end of the three variables
    452                         CPPAD_ASSERT_NARG_NRES(op, 2, 3)
    453                         reverse_sparse_hessian_pow_op(
    454                         i_var+2, arg, RevJac, for_jac_sparse, rev_hes_sparse
    455                         );
    456                         break;
    457                         // -------------------------------------------------
    458 
    459                         case PripOp:
    460                         CPPAD_ASSERT_NARG_NRES(op, 2, 0);
    461                         break;
    462                         // -------------------------------------------------
    463 
    464                         case PrivOp:
    465                         CPPAD_ASSERT_NARG_NRES(op, 2, 0);
    466                         break;
    467                         // -------------------------------------------------
    468 
    469                         case SinOp:
    470                         // sine and cosine must come in pairs
    471                         // but i_var + 1 should only be used here
    472                         CPPAD_ASSERT_NARG_NRES(op, 1, 2)
    473                         reverse_sparse_hessian_nonlinear_unary_op(
    474                         i_var, arg[0], RevJac, for_jac_sparse, rev_hes_sparse
    475                         );
    476                         break;
    477                         // -------------------------------------------------
    478 
    479                         case SinhOp:
    480                         // sine and cosine must come in pairs
    481                         // but i_var + 1 should only be used here
    482                         CPPAD_ASSERT_NARG_NRES(op, 1, 2)
    483                         reverse_sparse_hessian_nonlinear_unary_op(
    484                         i_var, arg[0], RevJac, for_jac_sparse, rev_hes_sparse
    485                         );
    486                         break;
    487                         // -------------------------------------------------
    488 
    489                         case SqrtOp:
    490                         CPPAD_ASSERT_NARG_NRES(op, 1, 1)
    491                         reverse_sparse_hessian_nonlinear_unary_op(
    492                         i_var, arg[0], RevJac, for_jac_sparse, rev_hes_sparse
    493                         );
    494                         break;
    495                         // -------------------------------------------------
    496 
    497                         case StppOp:
    498                         // sparsity cannot propagate through a parameter
    499                         CPPAD_ASSERT_NARG_NRES(op, 3, 0)
    500                         break;
    501                         // -------------------------------------------------
    502 
    503                         case StpvOp:
    504                         reverse_sparse_hessian_store_op(
    505                                 op,
    506                                 arg,
    507                                 num_vecad_ind,
    508                                 vecad_ind,
    509                                 rev_hes_sparse,
    510                                 vecad_sparse,
    511                                 RevJac,
    512                                 vecad_jac
    513                         );
    514                         break;
    515                         // -------------------------------------------------
    516 
    517                         case StvpOp:
    518                         // sparsity cannot propagate through a parameter
    519                         CPPAD_ASSERT_NARG_NRES(op, 3, 0)
    520                         break;
    521                         // -------------------------------------------------
    522 
    523                         case StvvOp:
    524                         reverse_sparse_hessian_store_op(
    525                                 op,
    526                                 arg,
    527                                 num_vecad_ind,
    528                                 vecad_ind,
    529                                 rev_hes_sparse,
    530                                 vecad_sparse,
    531                                 RevJac,
    532                                 vecad_jac
    533                         );
    534                         break;
    535                         // -------------------------------------------------
    536 
    537                         case SubvvOp:
    538                         CPPAD_ASSERT_NARG_NRES(op, 2, 1)
    539                         reverse_sparse_hessian_addsub_op(
    540                         i_var, arg, RevJac, for_jac_sparse, rev_hes_sparse
    541                         );
    542                         break;
    543                         // -------------------------------------------------
    544 
    545                         case SubpvOp:
    546                         CPPAD_ASSERT_NARG_NRES(op, 2, 1)
    547                         reverse_sparse_hessian_linear_unary_op(
    548                         i_var, arg[1], RevJac, for_jac_sparse, rev_hes_sparse
    549                         );
    550                         break;
    551                         // -------------------------------------------------
    552 
    553                         case SubvpOp:
    554                         CPPAD_ASSERT_NARG_NRES(op, 2, 1)
    555                         reverse_sparse_hessian_linear_unary_op(
    556                         i_var, arg[0], RevJac, for_jac_sparse, rev_hes_sparse
    557                         );
    558                         break;
    559                         // -------------------------------------------------
    560 
    561                         default:
    562                         CPPAD_ASSERT_UNKNOWN(0);
    563                 }
    564558        }
    565559        CPPAD_ASSERT_UNKNOWN( i_op == 1 );
  • branches/multiple_result/cppad/local/rev_jac_sweep.hpp

    r1539 r1584  
    147147                CPPAD_ASSERT_UNKNOWN( (i_op <= n) | (op != InvOp) );
    148148
     149
     150                // rest of information depends on the case
     151                switch( op )
     152                {
     153                        case AbsOp:
     154                        CPPAD_ASSERT_NARG_NRES(op, 1, 1);
     155                        reverse_sparse_jacobian_unary_op(
     156                                i_var, arg[0], var_sparsity
     157                        );
     158                        break;
     159                        // -------------------------------------------------
     160
     161                        case AddvvOp:
     162                        CPPAD_ASSERT_NARG_NRES(op, 2, 1);
     163                        reverse_sparse_jacobian_binary_op(
     164                                i_var, arg, var_sparsity
     165                        );
     166                        break;
     167                        // -------------------------------------------------
     168
     169                        case AddpvOp:
     170                        CPPAD_ASSERT_NARG_NRES(op, 2, 1);
     171                        reverse_sparse_jacobian_unary_op(
     172                                i_var, arg[1], var_sparsity
     173                        );
     174                        break;
     175                        // -------------------------------------------------
     176
     177                        case AddvpOp:
     178                        CPPAD_ASSERT_NARG_NRES(op, 2, 1);
     179                        reverse_sparse_jacobian_unary_op(
     180                                i_var, arg[0], var_sparsity
     181                        );
     182                        break;
     183                        // -------------------------------------------------
     184
     185                        case AcosOp:
     186                        // acos(x) and sqrt(1 - x * x) are computed in pairs
     187                        // but i_var + 1 should only be used here
     188                        CPPAD_ASSERT_NARG_NRES(op, 1, 2);
     189                        reverse_sparse_jacobian_unary_op(
     190                                i_var, arg[0], var_sparsity
     191                        );
     192                        break;
     193                        // -------------------------------------------------
     194
     195                        case AsinOp:
     196                        // asin(x) and sqrt(1 - x * x) are computed in pairs
     197                        // but i_var + 1 should only be used here
     198                        CPPAD_ASSERT_NARG_NRES(op, 1, 2);
     199                        reverse_sparse_jacobian_unary_op(
     200                                i_var, arg[0], var_sparsity
     201                        );
     202                        break;
     203                        // -------------------------------------------------
     204
     205                        case AtanOp:
     206                        // atan(x) and 1 + x * x must be computed in pairs
     207                        // but i_var + 1 should only be used here
     208                        CPPAD_ASSERT_NARG_NRES(op, 1, 2);
     209                        reverse_sparse_jacobian_unary_op(
     210                                i_var, arg[0], var_sparsity
     211                        );
     212                        break;
     213                        // -------------------------------------------------
     214
     215                        case CExpOp:
     216                        reverse_sparse_jacobian_cond_op(
     217                                i_var, arg, num_par, var_sparsity
     218                        );
     219                        break;
     220                        // ---------------------------------------------------
     221
     222                        case ComOp:
     223                        CPPAD_ASSERT_NARG_NRES(op, 4, 0);
     224                        CPPAD_ASSERT_UNKNOWN( arg[1] > 1 );
     225                        break;
     226                        // --------------------------------------------------
     227
     228                        case CosOp:
     229                        // cosine and sine must come in pairs
     230                        // but i_var + 1 should only be used here
     231                        CPPAD_ASSERT_NARG_NRES(op, 1, 2);
     232                        reverse_sparse_jacobian_unary_op(
     233                                i_var, arg[0], var_sparsity
     234                        );
     235                        break;
     236                        // ---------------------------------------------------
     237
     238                        case CoshOp:
     239                        // hyperbolic cosine and sine must come in pairs
     240                        // but i_var + 1 should only be used here
     241                        CPPAD_ASSERT_NARG_NRES(op, 1, 2);
     242                        reverse_sparse_jacobian_unary_op(
     243                                i_var, arg[0], var_sparsity
     244                        );
     245                        break;
     246                        // -------------------------------------------------
     247
     248                        case DisOp:
     249                        CPPAD_ASSERT_NARG_NRES(op, 2, 1);
     250
     251                        break;
     252                        // -------------------------------------------------
     253
     254                        case DivvvOp:
     255                        CPPAD_ASSERT_NARG_NRES(op, 2, 1);
     256                        reverse_sparse_jacobian_binary_op(
     257                                i_var, arg, var_sparsity
     258                        );
     259                        break;
     260                        // -------------------------------------------------
     261
     262                        case DivpvOp:
     263                        CPPAD_ASSERT_NARG_NRES(op, 2, 1);
     264                        reverse_sparse_jacobian_unary_op(
     265                                i_var, arg[1], var_sparsity
     266                        );
     267                        break;
     268                        // -------------------------------------------------
     269
     270                        case DivvpOp:
     271                        CPPAD_ASSERT_NARG_NRES(op, 2, 1);
     272                        reverse_sparse_jacobian_unary_op(
     273                                i_var, arg[0], var_sparsity
     274                        );
     275                        break;
     276                        // -------------------------------------------------
     277
     278                        case ExpOp:
     279                        CPPAD_ASSERT_NARG_NRES(op, 1, 1);
     280                        reverse_sparse_jacobian_unary_op(
     281                                i_var, arg[0], var_sparsity
     282                        );
     283                        break;
     284                        // -------------------------------------------------
     285
     286                        case InvOp:
     287                        CPPAD_ASSERT_NARG_NRES(op, 0, 1);
     288                        break;
     289                        // -------------------------------------------------
     290
     291                        case LdpOp:
     292                        reverse_sparse_jacobian_load_op(
     293                                op,
     294                                i_var,
     295                                arg,
     296                                num_vecad_ind,
     297                                vecad_ind,
     298                                var_sparsity,
     299                                vecad_sparsity
     300                        );
     301                        break;
     302                        // -------------------------------------------------
     303
     304                        case LdvOp:
     305                        reverse_sparse_jacobian_load_op(
     306                                op,
     307                                i_var,
     308                                arg,
     309                                num_vecad_ind,
     310                                vecad_ind,
     311                                var_sparsity,
     312                                vecad_sparsity
     313                        );
     314                        break;
     315                        // -------------------------------------------------
     316
     317                        case LogOp:
     318                        CPPAD_ASSERT_NARG_NRES(op, 1, 1);
     319                        reverse_sparse_jacobian_unary_op(
     320                                i_var, arg[0], var_sparsity
     321                        );
     322                        break;
     323                        // -------------------------------------------------
     324
     325                        case MulvvOp:
     326                        CPPAD_ASSERT_NARG_NRES(op, 2, 1);
     327                        reverse_sparse_jacobian_binary_op(
     328                                i_var, arg, var_sparsity
     329                        );
     330                        break;
     331                        // -------------------------------------------------
     332
     333                        case MulpvOp:
     334                        CPPAD_ASSERT_NARG_NRES(op, 2, 1);
     335                        reverse_sparse_jacobian_unary_op(
     336                                i_var, arg[1], var_sparsity
     337                        );
     338                        break;
     339                        // -------------------------------------------------
     340
     341                        case MulvpOp:
     342                        CPPAD_ASSERT_NARG_NRES(op, 2, 1);
     343                        reverse_sparse_jacobian_unary_op(
     344                                i_var, arg[0], var_sparsity
     345                        );
     346                        break;
     347                        // -------------------------------------------------
     348
     349                        case NonOp:
     350                        CPPAD_ASSERT_NARG_NRES(op, 0, 1);
     351
     352                        break;
     353                        // -------------------------------------------------
     354
     355                        case ParOp:
     356                        CPPAD_ASSERT_NARG_NRES(op, 1, 1);
     357
     358                        break;
     359                        // -------------------------------------------------
     360
     361                        case PowvpOp:
     362                        reverse_sparse_jacobian_unary_op(
     363                                i_var, arg[0], var_sparsity
     364                        );
     365                        break;
     366                        // -------------------------------------------------
     367
     368                        case PowpvOp:
     369                        CPPAD_ASSERT_NARG_NRES(op, 2, 3);
     370                        reverse_sparse_jacobian_unary_op(
     371                                i_var, arg[1], var_sparsity
     372                        );
     373                        break;
     374                        // -------------------------------------------------
     375
     376                        case PowvvOp:
     377                        CPPAD_ASSERT_NARG_NRES(op, 2, 3);
     378                        reverse_sparse_jacobian_binary_op(
     379                                i_var, arg, var_sparsity
     380                        );
     381                        break;
     382                        // -------------------------------------------------
     383
     384                        case PripOp:
     385                        CPPAD_ASSERT_NARG_NRES(op, 2, 0);
     386
     387                        break;
     388                        // -------------------------------------------------
     389
     390                        case PrivOp:
     391                        CPPAD_ASSERT_NARG_NRES(op, 2, 0);
     392                        break;
     393                        // -------------------------------------------------
     394
     395                        case SinOp:
     396                        // sine and cosine must come in pairs
     397                        // but i_var + 1 should only be used here
     398                        CPPAD_ASSERT_NARG_NRES(op, 1, 2);
     399                        reverse_sparse_jacobian_unary_op(
     400                                i_var, arg[0], var_sparsity
     401                        );
     402                        break;
     403                        // -------------------------------------------------
     404
     405                        case SinhOp:
     406                        // hyperbolic sine and cosine must come in pairs
     407                        // but i_var + 1 should only be used here
     408                        CPPAD_ASSERT_NARG_NRES(op, 1, 2);
     409                        reverse_sparse_jacobian_unary_op(
     410                                i_var, arg[0], var_sparsity
     411                        );
     412                        break;
     413                        // -------------------------------------------------
     414
     415                        case SqrtOp:
     416                        CPPAD_ASSERT_NARG_NRES(op, 1, 1);
     417                        reverse_sparse_jacobian_unary_op(
     418                                i_var, arg[0], var_sparsity
     419                        );
     420                        break;
     421                        // -------------------------------------------------
     422
     423                        case StppOp:
     424                        // sparsity cannot proagate through a parameter
     425                        CPPAD_ASSERT_NARG_NRES(op, 3, 0);
     426                        break;
     427                        // -------------------------------------------------
     428
     429                        case StpvOp:
     430                        reverse_sparse_jacobian_store_op(
     431                                op,
     432                                arg,
     433                                num_vecad_ind,
     434                                vecad_ind,
     435                                var_sparsity,
     436                                vecad_sparsity
     437                        );
     438                        break;
     439                        // -------------------------------------------------
     440
     441                        case StvpOp:
     442                        CPPAD_ASSERT_NARG_NRES(op, 3, 0);
     443                        break;
     444                        // -------------------------------------------------
     445
     446                        case StvvOp:
     447                        reverse_sparse_jacobian_store_op(
     448                                op,
     449                                arg,
     450                                num_vecad_ind,
     451                                vecad_ind,
     452                                var_sparsity,
     453                                vecad_sparsity
     454                        );
     455                        break;
     456                        // -------------------------------------------------
     457
     458                        case SubvvOp:
     459                        CPPAD_ASSERT_NARG_NRES(op, 2, 1);
     460                        reverse_sparse_jacobian_binary_op(
     461                                i_var, arg, var_sparsity
     462                        );
     463                        break;
     464                        // -------------------------------------------------
     465
     466                        case SubpvOp:
     467                        CPPAD_ASSERT_NARG_NRES(op, 2, 1);
     468                        reverse_sparse_jacobian_unary_op(
     469                                i_var, arg[1], var_sparsity
     470                        );
     471                        break;
     472                        // -------------------------------------------------
     473
     474                        case SubvpOp:
     475                        CPPAD_ASSERT_NARG_NRES(op, 2, 1);
     476                        reverse_sparse_jacobian_unary_op(
     477                                i_var, arg[0], var_sparsity
     478                        );
     479                        break;
     480                        // -------------------------------------------------
     481
     482                        default:
     483                        CPPAD_ASSERT_UNKNOWN(0);
     484                }
    149485# if CPPAD_REV_JAC_SWEEP_TRACE
    150486                for(j = 0; j < limit; j++)
    151487                        z_value[j] = false;
    152                 j = var_sparsity.get_element(i_var, j);
     488                var_sparsity.begin(i_var);
     489                j = var_sparsity.next_element();
    153490                while( j < limit )
    154491                {       z_value[j] = true;
    155                         j          = var_sparsity.get_element(i_var, j);
     492                        j          = var_sparsity.next_element();
    156493                }
    157494                printOp(
     
    167504                );
    168505# endif
    169 
    170                 // rest of information depends on the case
    171                 switch( op )
    172                 {
    173                         case AbsOp:
    174                         CPPAD_ASSERT_NARG_NRES(op, 1, 1);
    175                         reverse_sparse_jacobian_unary_op(
    176                                 i_var, arg[0], var_sparsity
    177                         );
    178                         break;
    179                         // -------------------------------------------------
    180 
    181                         case AddvvOp:
    182                         CPPAD_ASSERT_NARG_NRES(op, 2, 1);
    183                         reverse_sparse_jacobian_binary_op(
    184                                 i_var, arg, var_sparsity
    185                         );
    186                         break;
    187                         // -------------------------------------------------
    188 
    189                         case AddpvOp:
    190                         CPPAD_ASSERT_NARG_NRES(op, 2, 1);
    191                         reverse_sparse_jacobian_unary_op(
    192                                 i_var, arg[1], var_sparsity
    193                         );
    194                         break;
    195                         // -------------------------------------------------
    196 
    197                         case AddvpOp:
    198                         CPPAD_ASSERT_NARG_NRES(op, 2, 1);
    199                         reverse_sparse_jacobian_unary_op(
    200                                 i_var, arg[0], var_sparsity
    201                         );
    202                         break;
    203                         // -------------------------------------------------
    204 
    205                         case AcosOp:
    206                         // acos(x) and sqrt(1 - x * x) are computed in pairs
    207                         // but i_var + 1 should only be used here
    208                         CPPAD_ASSERT_NARG_NRES(op, 1, 2);
    209                         reverse_sparse_jacobian_unary_op(
    210                                 i_var, arg[0], var_sparsity
    211                         );
    212                         break;
    213                         // -------------------------------------------------
    214 
    215                         case AsinOp:
    216                         // asin(x) and sqrt(1 - x * x) are computed in pairs
    217                         // but i_var + 1 should only be used here
    218                         CPPAD_ASSERT_NARG_NRES(op, 1, 2);
    219                         reverse_sparse_jacobian_unary_op(
    220                                 i_var, arg[0], var_sparsity
    221                         );
    222                         break;
    223                         // -------------------------------------------------
    224 
    225                         case AtanOp:
    226                         // atan(x) and 1 + x * x must be computed in pairs
    227                         // but i_var + 1 should only be used here
    228                         CPPAD_ASSERT_NARG_NRES(op, 1, 2);
    229                         reverse_sparse_jacobian_unary_op(
    230                                 i_var, arg[0], var_sparsity
    231                         );
    232                         break;
    233                         // -------------------------------------------------
    234 
    235                         case CExpOp:
    236                         reverse_sparse_jacobian_cond_op(
    237                                 i_var, arg, num_par, var_sparsity
    238                         );
    239                         break;
    240                         // ---------------------------------------------------
    241 
    242                         case ComOp:
    243                         CPPAD_ASSERT_NARG_NRES(op, 4, 0);
    244                         CPPAD_ASSERT_UNKNOWN( arg[1] > 1 );
    245                         break;
    246                         // --------------------------------------------------
    247 
    248                         case CosOp:
    249                         // cosine and sine must come in pairs
    250                         // but i_var + 1 should only be used here
    251                         CPPAD_ASSERT_NARG_NRES(op, 1, 2);
    252                         reverse_sparse_jacobian_unary_op(
    253                                 i_var, arg[0], var_sparsity
    254                         );
    255                         break;
    256                         // ---------------------------------------------------
    257 
    258                         case CoshOp:
    259                         // hyperbolic cosine and sine must come in pairs
    260                         // but i_var + 1 should only be used here
    261                         CPPAD_ASSERT_NARG_NRES(op, 1, 2);
    262                         reverse_sparse_jacobian_unary_op(
    263                                 i_var, arg[0], var_sparsity
    264                         );
    265                         break;
    266                         // -------------------------------------------------
    267 
    268                         case DisOp:
    269                         CPPAD_ASSERT_NARG_NRES(op, 2, 1);
    270 
    271                         break;
    272                         // -------------------------------------------------
    273 
    274                         case DivvvOp:
    275                         CPPAD_ASSERT_NARG_NRES(op, 2, 1);
    276                         reverse_sparse_jacobian_binary_op(
    277                                 i_var, arg, var_sparsity
    278                         );
    279                         break;
    280                         // -------------------------------------------------
    281 
    282                         case DivpvOp:
    283                         CPPAD_ASSERT_NARG_NRES(op, 2, 1);
    284                         reverse_sparse_jacobian_unary_op(
    285                                 i_var, arg[1], var_sparsity
    286                         );
    287                         break;
    288                         // -------------------------------------------------
    289 
    290                         case DivvpOp:
    291                         CPPAD_ASSERT_NARG_NRES(op, 2, 1);
    292                         reverse_sparse_jacobian_unary_op(
    293                                 i_var, arg[0], var_sparsity
    294                         );
    295                         break;
    296                         // -------------------------------------------------
    297 
    298                         case ExpOp:
    299                         CPPAD_ASSERT_NARG_NRES(op, 1, 1);
    300                         reverse_sparse_jacobian_unary_op(
    301                                 i_var, arg[0], var_sparsity
    302                         );
    303                         break;
    304                         // -------------------------------------------------
    305 
    306                         case InvOp:
    307                         CPPAD_ASSERT_NARG_NRES(op, 0, 1);
    308                         break;
    309                         // -------------------------------------------------
    310 
    311                         case LdpOp:
    312                         reverse_sparse_jacobian_load_op(
    313                                 op,
    314                                 i_var,
    315                                 arg,
    316                                 num_vecad_ind,
    317                                 vecad_ind,
    318                                 var_sparsity,
    319                                 vecad_sparsity
    320                         );
    321                         break;
    322                         // -------------------------------------------------
    323 
    324                         case LdvOp:
    325                         reverse_sparse_jacobian_load_op(
    326                                 op,
    327                                 i_var,
    328                                 arg,
    329                                 num_vecad_ind,
    330                                 vecad_ind,
    331                                 var_sparsity,
    332                                 vecad_sparsity
    333                         );
    334                         break;
    335                         // -------------------------------------------------
    336 
    337                         case LogOp:
    338                         CPPAD_ASSERT_NARG_NRES(op, 1, 1);
    339                         reverse_sparse_jacobian_unary_op(
    340                                 i_var, arg[0], var_sparsity
    341                         );
    342                         break;
    343                         // -------------------------------------------------
    344 
    345                         case MulvvOp:
    346                         CPPAD_ASSERT_NARG_NRES(op, 2, 1);
    347                         reverse_sparse_jacobian_binary_op(
    348                                 i_var, arg, var_sparsity
    349                         );
    350                         break;
    351                         // -------------------------------------------------
    352 
    353                         case MulpvOp:
    354                         CPPAD_ASSERT_NARG_NRES(op, 2, 1);
    355                         reverse_sparse_jacobian_unary_op(
    356                                 i_var, arg[1], var_sparsity
    357                         );
    358                         break;
    359                         // -------------------------------------------------
    360 
    361                         case MulvpOp:
    362                         CPPAD_ASSERT_NARG_NRES(op, 2, 1);
    363                         reverse_sparse_jacobian_unary_op(
    364                                 i_var, arg[0], var_sparsity
    365                         );
    366                         break;
    367                         // -------------------------------------------------
    368 
    369                         case NonOp:
    370                         CPPAD_ASSERT_NARG_NRES(op, 0, 1);
    371 
    372                         break;
    373                         // -------------------------------------------------
    374 
    375                         case ParOp:
    376                         CPPAD_ASSERT_NARG_NRES(op, 1, 1);
    377 
    378                         break;
    379                         // -------------------------------------------------
    380 
    381                         case PowvpOp:
    382                         // Pow operator is a special case where final result
    383                         // comes at the end of the three variables
    384                         CPPAD_ASSERT_NARG_NRES(op, 2, 3);
    385                         reverse_sparse_jacobian_unary_op(
    386                                 i_var + 2, arg[0], var_sparsity
    387                         );
    388                         break;
    389                         // -------------------------------------------------
    390 
    391                         case PowpvOp:
    392                         // Pow operator is a special case where final result
    393                         // comes at the end of the three variables
    394                         CPPAD_ASSERT_NARG_NRES(op, 2, 3);
    395                         reverse_sparse_jacobian_unary_op(
    396                                 i_var + 2, arg[1], var_sparsity
    397                         );
    398                         break;
    399                         // -------------------------------------------------
    400 
    401                         case PowvvOp:
    402                         // Pow operator is a special case where final result
    403                         // comes at the end of the three variables
    404                         CPPAD_ASSERT_NARG_NRES(op, 2, 3);
    405                         reverse_sparse_jacobian_binary_op(
    406                                 i_var + 2, arg, var_sparsity
    407                         );
    408                         break;
    409                         // -------------------------------------------------
    410 
    411                         case PripOp:
    412                         CPPAD_ASSERT_NARG_NRES(op, 2, 0);
    413 
    414                         break;
    415                         // -------------------------------------------------
    416 
    417                         case PrivOp:
    418                         CPPAD_ASSERT_NARG_NRES(op, 2, 0);
    419                         break;
    420                         // -------------------------------------------------
    421 
    422                         case SinOp:
    423                         // sine and cosine must come in pairs
    424                         // but i_var + 1 should only be used here
    425                         CPPAD_ASSERT_NARG_NRES(op, 1, 2);
    426                         reverse_sparse_jacobian_unary_op(
    427                                 i_var, arg[0], var_sparsity
    428                         );
    429                         break;
    430                         // -------------------------------------------------
    431 
    432                         case SinhOp:
    433                         // hyperbolic sine and cosine must come in pairs
    434                         // but i_var + 1 should only be used here
    435                         CPPAD_ASSERT_NARG_NRES(op, 1, 2);
    436                         reverse_sparse_jacobian_unary_op(
    437                                 i_var, arg[0], var_sparsity
    438                         );
    439                         break;
    440                         // -------------------------------------------------
    441 
    442                         case SqrtOp:
    443                         CPPAD_ASSERT_NARG_NRES(op, 1, 1);
    444                         reverse_sparse_jacobian_unary_op(
    445                                 i_var, arg[0], var_sparsity
    446                         );
    447                         break;
    448                         // -------------------------------------------------
    449 
    450                         case StppOp:
    451                         // sparsity cannot proagate through a parameter
    452                         CPPAD_ASSERT_NARG_NRES(op, 3, 0);
    453                         break;
    454                         // -------------------------------------------------
    455 
    456                         case StpvOp:
    457                         reverse_sparse_jacobian_store_op(
    458                                 op,
    459                                 arg,
    460                                 num_vecad_ind,
    461                                 vecad_ind,
    462                                 var_sparsity,
    463                                 vecad_sparsity
    464                         );
    465                         break;
    466                         // -------------------------------------------------
    467 
    468                         case StvpOp:
    469                         CPPAD_ASSERT_NARG_NRES(op, 3, 0);
    470                         break;
    471                         // -------------------------------------------------
    472 
    473                         case StvvOp:
    474                         reverse_sparse_jacobian_store_op(
    475                                 op,
    476                                 arg,
    477                                 num_vecad_ind,
    478                                 vecad_ind,
    479                                 var_sparsity,
    480                                 vecad_sparsity
    481                         );
    482                         break;
    483                         // -------------------------------------------------
    484 
    485                         case SubvvOp:
    486                         CPPAD_ASSERT_NARG_NRES(op, 2, 1);
    487                         reverse_sparse_jacobian_binary_op(
    488                                 i_var, arg, var_sparsity
    489                         );
    490                         break;
    491                         // -------------------------------------------------
    492 
    493                         case SubpvOp:
    494                         CPPAD_ASSERT_NARG_NRES(op, 2, 1);
    495                         reverse_sparse_jacobian_unary_op(
    496                                 i_var, arg[1], var_sparsity
    497                         );
    498                         break;
    499                         // -------------------------------------------------
    500 
    501                         case SubvpOp:
    502                         CPPAD_ASSERT_NARG_NRES(op, 2, 1);
    503                         reverse_sparse_jacobian_unary_op(
    504                                 i_var, arg[0], var_sparsity
    505                         );
    506                         break;
    507                         // -------------------------------------------------
    508 
    509                         default:
    510                         CPPAD_ASSERT_UNKNOWN(0);
    511                 }
    512506        }
    513507        CPPAD_ASSERT_UNKNOWN( i_op == 1 );
  • branches/multiple_result/cppad/local/reverse_sweep.hpp

    r1497 r1584  
    176176                const Base*  pZ_tmp = Partial + i_var * K;
    177177
    178                 if( op == PowvpOp || op == PowpvOp || op == PowvvOp )
    179                 {       i_tmp  += 2;
    180                         Z_tmp  += 2 * J;
    181                         pZ_tmp += 2 * K;
    182                 }
    183178                printOp(
    184179                        std::cout,
  • branches/multiple_result/cppad/speed/det_by_lu.hpp

    r1369 r1584  
    44
    55/* --------------------------------------------------------------------------
    6 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-07 Bradley M. Bell
     6CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-09 Bradley M. Bell
    77
    88CppAD is distributed under multiple licenses. This distribution is under
     
    173173                        n, m, A, B, X, logdet);
    174174
    175 # if 0
     175/*
    176176                // Do not do this for speed test because it makes floating
    177177                // point operation sequence very simple.
     
    179179                        det = 0;
    180180                else    det =  Scalar( signdet ) * exp( logdet );
    181 # endif
     181*/
    182182
    183183                // convert to determinant
  • branches/multiple_result/test_more/for_sparse_jac.cpp

    r1550 r1584  
    301301}
    302302
     303bool case_three()
     304{       bool ok = true;
     305        using namespace CppAD;
     306
     307        // dimension of the domain space
     308        size_t n = 2;
     309
     310        // dimension of the range space
     311        size_t m = 3;
     312
     313        // independent variable vector
     314        CPPAD_TEST_VECTOR< AD<double> > X(n);
     315        X[0] = 2.;
     316        X[1] = 3.;
     317        Independent(X);
     318
     319        // dependent variable vector
     320        CPPAD_TEST_VECTOR< AD<double> > Y(m);
     321
     322        // check results vector
     323        CPPAD_TEST_VECTOR< bool >       Check(m * n);
     324
     325        // initialize index into Y
     326        size_t index = 0;
     327
     328        // Y[0] only depends on X[0];
     329        Y[index]             = pow(X[0], 2.);
     330        Check[index * n + 0] = true;
     331        Check[index * n + 1] = false;
     332        index++;
     333
     334        // Y[1] depends on X[1]
     335        Y[index]             = pow(2., X[1]);
     336        Check[index * n + 0] = false;
     337        Check[index * n + 1] = true;
     338        index++;
     339
     340        // Y[2] depends on X[0] and X[1]
     341        Y[index]             = pow(X[0], X[1]);
     342        Check[index * n + 0] = true;
     343        Check[index * n + 1] = true;
     344        index++;
     345
     346        // check final index
     347        assert( index == m );
     348
     349        // create function object F : X -> Y
     350        ADFun<double> F(X, Y);
     351
     352        // -----------------------------------------------------------------
     353        // dependency matrix for the identity function
     354        CPPAD_TEST_VECTOR< bool > Px(n * n);
     355        size_t i, j;
     356        for(i = 0; i < n; i++)
     357        {       for(j = 0; j < n; j++)
     358                        Px[ i * n + j ] = false;
     359                Px[ i * n + i ] = true;
     360        }
     361
     362        // evaluate the dependency matrix for F(X(x))
     363        CPPAD_TEST_VECTOR< bool > Py(m * n);
     364        Py = F.ForSparseJac(n, Px);
     365
     366        // check values
     367        for(i = 0; i < m; i++)
     368        {       for(j = 0; j < n; j++)
     369                        ok &= (Py[i * n + j] == Check[i * n + j]);
     370        }       
     371
     372        // ---------------------------------------------------------
     373        // dependency matrix for the identity function
     374        CPPAD_TEST_VECTOR< std::set<size_t> > Sx(n);
     375        for(i = 0; i < n; i++)
     376        {       assert( Sx[i].empty() );
     377                Sx[i].insert(i);
     378        }
     379
     380        // evaluate the dependency matrix for F(X(x))
     381        CPPAD_TEST_VECTOR< std::set<size_t> > Sy(m);
     382        Sy = F.ForSparseJac(n, Sx);
     383
     384        // check values
     385        bool found;
     386        for(i = 0; i < m; i++)
     387        {       for(j = 0; j < n; j++)
     388                {       found = Sy[i].find(j) != Sy[i].end();
     389                        ok &= (found == Check[i * n + j]);
     390                }
     391        }       
     392
     393        return ok;
     394}
     395
    303396} // End empty namespace
    304397
     
    308401        ok &= case_one();
    309402        ok &= case_two();
     403        ok &= case_three();
    310404
    311405        return ok;
  • branches/multiple_result/test_more/optimize.cpp

    r1581 r1584  
    8888                CPPAD_TEST_VECTOR< AD<double> > X(n);
    8989                for(j = 0; j < n; j++)
    90                         X[j] = 1. / double(j + 1);
     90                        X[j] = 1. / double(j + 2);
    9191       
    9292                // declare independent variables and start tape recording
  • branches/multiple_result/test_more/rev_sparse_hes.cpp

    r1579 r1584  
    409409        CPPAD_TEST_VECTOR< AD<double> > Y(m);
    410410        Y[0] = pow(X[0], 2.);
    411         Y[1] = pow(2., X[0]);
     411        Y[1] = pow(2., X[1]);
    412412
    413413        // create function object F : X -> Y
     
    433433                for(i = 0; i < n; i++)
    434434                {       for(j = 0; j < n; j++)
    435                         {       bool check = (i == 0) & (j == 0);
     435                        {       bool check = (i == k) & (j == k);
    436436                                ok        &= Pxx[i * n + j] == check;
    437437                        }
  • branches/multiple_result/test_more/rev_sparse_jac.cpp

    r1550 r1584  
    159159        }
    160160
    161         // evaluate the dependency matrix for U(F(x))
     161        // evaluate the dependency matrix for F(x)
    162162        CPPAD_TEST_VECTOR< bool > Px(m * n);
    163163        Px = F.RevSparseJac(m, Py);
     
    300300}
    301301
     302bool case_three()
     303{       bool ok = true;
     304        using namespace CppAD;
     305
     306        // dimension of the domain space
     307        size_t n = 2;
     308
     309        // dimension of the range space
     310        size_t m = 3;
     311
     312        // independent variable vector
     313        CPPAD_TEST_VECTOR< AD<double> > X(n);
     314        X[0] = 2.;
     315        X[1] = 3.;
     316        Independent(X);
     317
     318        // dependent variable vector
     319        CPPAD_TEST_VECTOR< AD<double> > Y(m);
     320
     321        // check results vector
     322        CPPAD_TEST_VECTOR< bool >       Check(m * n);
     323
     324        // initialize index into Y
     325        size_t index = 0;
     326
     327        // Y[0] only depends on X[0];
     328        Y[index]             = pow(X[0], 2.);
     329        Check[index * n + 0] = true;
     330        Check[index * n + 1] = false;
     331        index++;
     332
     333        // Y[1] depends on X[1]
     334        Y[index]             = pow(2., X[1]);
     335        Check[index * n + 0] = false;
     336        Check[index * n + 1] = true;
     337        index++;
     338
     339        // Y[2] depends on X[0] and X[1]
     340        Y[index]             = pow(X[0], X[1]);
     341        Check[index * n + 0] = true;
     342        Check[index * n + 1] = true;
     343        index++;
     344
     345        // check final index
     346        assert( index == m );
     347
     348        // create function object F : X -> Y
     349        ADFun<double> F(X, Y);
     350
     351        // -----------------------------------------------------------------
     352        // dependency matrix for the identity function
     353        CPPAD_TEST_VECTOR< bool > Py(m * m);
     354        size_t i, j;
     355        for(i = 0; i < m; i++)
     356        {       for(j = 0; j < m; j++)
     357                        Py[ i * m + j ] = (i == j);
     358        }
     359
     360        // evaluate the dependency matrix for F(x)
     361        CPPAD_TEST_VECTOR< bool > Px(m * n);
     362        Px = F.RevSparseJac(m, Py);
     363
     364        // check values
     365        for(i = 0; i < m; i++)
     366        {       for(j = 0; j < n; j++)
     367                        ok &= (Px[i * n + j] == Check[i * n + j]);
     368        }       
     369
     370        // ---------------------------------------------------------
     371        // dependency matrix for the identity function
     372        CPPAD_TEST_VECTOR< std::set<size_t> > Sy(m);
     373        for(i = 0; i < m; i++)
     374        {       assert( Sy[i].empty() );
     375                Sy[i].insert(i);
     376        }
     377
     378        // evaluate the dependency matrix for F(x)
     379        CPPAD_TEST_VECTOR< std::set<size_t> > Sx(m);
     380        Sx = F.RevSparseJac(m, Sy);
     381
     382        // check values
     383        bool found;
     384        for(i = 0; i < m; i++)
     385        {       for(j = 0; j < n; j++)
     386                {       found = Sx[i].find(j) != Sx[i].end();
     387                        ok &= (found == Check[i * n + j]);
     388                }
     389        }       
     390
     391        return ok;
     392}
     393
    302394} // END empty namespace
    303395
     
    307399        ok &= case_one();
    308400        ok &= case_two();
     401        ok &= case_three();
    309402
    310403        return ok;
Note: See TracChangeset for help on using the changeset viewer.