Changeset 1588


Ignore:
Timestamp:
Nov 24, 2009 3:26:48 PM (11 years ago)
Author:
bradbell
Message:

trunk: merge in branches/multiple_result:1584-158

Location:
trunk
Files:
35 edited

Legend:

Unmodified
Added
Removed
  • trunk/cppad/local/acos_op.hpp

    r1447 r1588  
    4949        CPPAD_ASSERT_UNKNOWN( NumArg(AcosOp) == 1 );
    5050        CPPAD_ASSERT_UNKNOWN( NumRes(AcosOp) == 2 );
    51         CPPAD_ASSERT_UNKNOWN( i_x < i_z );
     51        CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
    5252        CPPAD_ASSERT_UNKNOWN( j < nc_taylor );
    5353
     
    5555        Base* x = taylor + i_x * nc_taylor;
    5656        Base* z = taylor + i_z * nc_taylor;
    57         Base* b = z      +       nc_taylor;  // called y in documentation
     57        Base* b = z      -       nc_taylor;  // called y in documentation
    5858
    5959        size_t k;
     
    110110        CPPAD_ASSERT_UNKNOWN( NumArg(AcosOp) == 1 );
    111111        CPPAD_ASSERT_UNKNOWN( NumRes(AcosOp) == 2 );
    112         CPPAD_ASSERT_UNKNOWN( i_x < i_z );
     112        CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
    113113        CPPAD_ASSERT_UNKNOWN( 0 < nc_taylor );
    114114
     
    116116        Base* x = taylor + i_x * nc_taylor;
    117117        Base* z = taylor + i_z * nc_taylor;
    118         Base* b = z      +       nc_taylor; // called y in documentation
     118        Base* b = z      -       nc_taylor; // called y in documentation
    119119
    120120        z[0] = acos( x[0] );
     
    150150        CPPAD_ASSERT_UNKNOWN( NumArg(AcosOp) == 1 );
    151151        CPPAD_ASSERT_UNKNOWN( NumRes(AcosOp) == 2 );
    152         CPPAD_ASSERT_UNKNOWN( i_x < i_z );
     152        CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
    153153        CPPAD_ASSERT_UNKNOWN( d < nc_taylor );
    154154        CPPAD_ASSERT_UNKNOWN( d < nc_partial );
     
    163163
    164164        // Taylor coefficients and partials corresponding to auxillary result
    165         const Base* b  = z  + nc_taylor; // called y in documentation
    166         Base* pb       = pz + nc_partial;
     165        const Base* b  = z  - nc_taylor; // called y in documentation
     166        Base* pb       = pz - nc_partial;
    167167
    168168        // number of indices to access
  • trunk/cppad/local/ad_copy.hpp

    r1369 r1588  
    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
  • trunk/cppad/local/asin_op.hpp

    r1447 r1588  
    4949        CPPAD_ASSERT_UNKNOWN( NumArg(AsinOp) == 1 );
    5050        CPPAD_ASSERT_UNKNOWN( NumRes(AsinOp) == 2 );
    51         CPPAD_ASSERT_UNKNOWN( i_x < i_z );
     51        CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
    5252        CPPAD_ASSERT_UNKNOWN( j < nc_taylor );
    5353
     
    5555        Base* x = taylor + i_x * nc_taylor;
    5656        Base* z = taylor + i_z * nc_taylor;
    57         Base* b = z      +       nc_taylor;  // called y in documentation
     57        Base* b = z      -       nc_taylor;  // called y in documentation
    5858
    5959        size_t k;
     
    110110        CPPAD_ASSERT_UNKNOWN( NumArg(AsinOp) == 1 );
    111111        CPPAD_ASSERT_UNKNOWN( NumRes(AsinOp) == 2 );
    112         CPPAD_ASSERT_UNKNOWN( i_x < i_z );
     112        CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
    113113        CPPAD_ASSERT_UNKNOWN( 0 < nc_taylor );
    114114
     
    116116        Base* x = taylor + i_x * nc_taylor;
    117117        Base* z = taylor + i_z * nc_taylor;
    118         Base* b = z      +       nc_taylor; // called y in documentation
     118        Base* b = z      -       nc_taylor; // called y in documentation
    119119
    120120        z[0] = asin( x[0] );
     
    150150        CPPAD_ASSERT_UNKNOWN( NumArg(AsinOp) == 1 );
    151151        CPPAD_ASSERT_UNKNOWN( NumRes(AsinOp) == 2 );
    152         CPPAD_ASSERT_UNKNOWN( i_x < i_z );
     152        CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
    153153        CPPAD_ASSERT_UNKNOWN( d < nc_taylor );
    154154        CPPAD_ASSERT_UNKNOWN( d < nc_partial );
     
    163163
    164164        // Taylor coefficients and partials corresponding to auxillary result
    165         const Base* b  = z  + nc_taylor; // called y in documentation
    166         Base* pb       = pz + nc_partial;
     165        const Base* b  = z  - nc_taylor; // called y in documentation
     166        Base* pb       = pz - nc_partial;
    167167
    168168        // number of indices to access
  • trunk/cppad/local/atan_op.hpp

    r1447 r1588  
    4949        CPPAD_ASSERT_UNKNOWN( NumArg(AtanOp) == 1 );
    5050        CPPAD_ASSERT_UNKNOWN( NumRes(AtanOp) == 2 );
    51         CPPAD_ASSERT_UNKNOWN( i_x < i_z );
     51        CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
    5252        CPPAD_ASSERT_UNKNOWN( j < nc_taylor );
    5353
     
    5555        Base* x = taylor + i_x * nc_taylor;
    5656        Base* z = taylor + i_z * nc_taylor;
    57         Base* b = z      +       nc_taylor;  // called y in documentation
     57        Base* b = z      -       nc_taylor;  // called y in documentation
    5858
    5959        size_t k;
     
    101101        CPPAD_ASSERT_UNKNOWN( NumArg(AtanOp) == 1 );
    102102        CPPAD_ASSERT_UNKNOWN( NumRes(AtanOp) == 2 );
    103         CPPAD_ASSERT_UNKNOWN( i_x < i_z );
     103        CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
    104104        CPPAD_ASSERT_UNKNOWN( 0 < nc_taylor );
    105105
     
    107107        Base* x = taylor + i_x * nc_taylor;
    108108        Base* z = taylor + i_z * nc_taylor;
    109         Base* b = z      +       nc_taylor; // called y in documentation
     109        Base* b = z      -       nc_taylor; // called y in documentation
    110110
    111111        z[0] = atan( x[0] );
     
    141141        CPPAD_ASSERT_UNKNOWN( NumArg(AtanOp) == 1 );
    142142        CPPAD_ASSERT_UNKNOWN( NumRes(AtanOp) == 2 );
    143         CPPAD_ASSERT_UNKNOWN( i_x < i_z );
     143        CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
    144144        CPPAD_ASSERT_UNKNOWN( d < nc_taylor );
    145145        CPPAD_ASSERT_UNKNOWN( d < nc_partial );
     
    154154
    155155        // Taylor coefficients and partials corresponding to auxillary result
    156         const Base* b  = z  + nc_taylor; // called y in documentation
    157         Base* pb       = pz + nc_partial;
     156        const Base* b  = z  - nc_taylor; // called y in documentation
     157        Base* pb       = pz - nc_partial;
    158158
    159159        // number of indices to access
  • trunk/cppad/local/cos_op.hpp

    r1447 r1588  
    4949        CPPAD_ASSERT_UNKNOWN( NumArg(CosOp) == 1 );
    5050        CPPAD_ASSERT_UNKNOWN( NumRes(CosOp) == 2 );
    51         CPPAD_ASSERT_UNKNOWN( i_x < i_z );
     51        CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
    5252        CPPAD_ASSERT_UNKNOWN( j < nc_taylor );
    5353
     
    5555        Base* x = taylor + i_x * nc_taylor;
    5656        Base* c = taylor + i_z * nc_taylor;
    57         Base* s = c      +       nc_taylor;
     57        Base* s = c      -       nc_taylor;
    5858
    5959
     
    103103        CPPAD_ASSERT_UNKNOWN( NumArg(CosOp) == 1 );
    104104        CPPAD_ASSERT_UNKNOWN( NumRes(CosOp) == 2 );
    105         CPPAD_ASSERT_UNKNOWN( i_x < i_z );
     105        CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
    106106        CPPAD_ASSERT_UNKNOWN( 0 < nc_taylor );
    107107
     
    109109        Base* x = taylor + i_x * nc_taylor;
    110110        Base* c = taylor + i_z * nc_taylor;  // called z in documentation
    111         Base* s = c      +       nc_taylor;  // called y in documentation
     111        Base* s = c      -       nc_taylor;  // called y in documentation
    112112
    113113        c[0] = cos( x[0] );
     
    143143        CPPAD_ASSERT_UNKNOWN( NumArg(CosOp) == 1 );
    144144        CPPAD_ASSERT_UNKNOWN( NumRes(CosOp) == 2 );
    145         CPPAD_ASSERT_UNKNOWN( i_x < i_z );
     145        CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
    146146        CPPAD_ASSERT_UNKNOWN( d < nc_taylor );
    147147        CPPAD_ASSERT_UNKNOWN( d < nc_partial );
     
    156156
    157157        // Taylor coefficients and partials corresponding to auxillary result
    158         const Base* s  = c  + nc_taylor; // called y in documentation
    159         Base* ps       = pc + nc_partial;
     158        const Base* s  = c  - nc_taylor; // called y in documentation
     159        Base* ps       = pc - nc_partial;
    160160
    161161
  • trunk/cppad/local/cosh_op.hpp

    r1447 r1588  
    4949        CPPAD_ASSERT_UNKNOWN( NumArg(CoshOp) == 1 );
    5050        CPPAD_ASSERT_UNKNOWN( NumRes(CoshOp) == 2 );
    51         CPPAD_ASSERT_UNKNOWN( i_x < i_z );
     51        CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
    5252        CPPAD_ASSERT_UNKNOWN( j < nc_taylor );
    5353
     
    5555        Base* x = taylor + i_x * nc_taylor;
    5656        Base* c = taylor + i_z * nc_taylor;
    57         Base* s = c      +       nc_taylor;
     57        Base* s = c      -       nc_taylor;
    5858
    5959        // rest of this routine is identical for the following cases:
     
    102102        CPPAD_ASSERT_UNKNOWN( NumArg(CoshOp) == 1 );
    103103        CPPAD_ASSERT_UNKNOWN( NumRes(CoshOp) == 2 );
    104         CPPAD_ASSERT_UNKNOWN( i_x < i_z );
     104        CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
    105105        CPPAD_ASSERT_UNKNOWN( 0 < nc_taylor );
    106106
     
    108108        Base* x = taylor + i_x * nc_taylor;
    109109        Base* c = taylor + i_z * nc_taylor;  // called z in documentation
    110         Base* s = c      +       nc_taylor;  // called y in documentation
     110        Base* s = c      -       nc_taylor;  // called y in documentation
    111111
    112112        c[0] = cosh( x[0] );
     
    142142        CPPAD_ASSERT_UNKNOWN( NumArg(CoshOp) == 1 );
    143143        CPPAD_ASSERT_UNKNOWN( NumRes(CoshOp) == 2 );
    144         CPPAD_ASSERT_UNKNOWN( i_x < i_z );
     144        CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
    145145        CPPAD_ASSERT_UNKNOWN( d < nc_taylor );
    146146        CPPAD_ASSERT_UNKNOWN( d < nc_partial );
     
    155155
    156156        // Taylor coefficients and partials corresponding to auxillary result
    157         const Base* s  = c  + nc_taylor; // called y in documentation
    158         Base* ps       = pc + nc_partial;
     157        const Base* s  = c  - nc_taylor; // called y in documentation
     158        Base* ps       = pc - nc_partial;
    159159
    160160        // rest of this routine is identical for the following cases:
  • trunk/cppad/local/define.hpp

    r1580 r1588  
    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/*!
  • trunk/cppad/local/dependent.hpp

    r1534 r1588  
    205205        dep_parameter_.resize(m);
    206206        dep_taddr_.resize(m);
    207         total_num_var_ = tape->Rec_.num_rec_var();
    208207        for(i = 0; i < m; i++)
    209208        {       dep_parameter_[i] = CppAD::Parameter(y[i]);
    210209                if( dep_parameter_[i] )
    211                 {       y_taddr = tape->RecordParOp( y[i].value_ );
    212                         total_num_var_++;
    213                 }
     210                        y_taddr = tape->RecordParOp( y[i].value_ );
    214211                else    y_taddr = y[i].taddr_;
    215212
    216213                CPPAD_ASSERT_UNKNOWN( y_taddr > 0 );
    217                 CPPAD_ASSERT_UNKNOWN( y_taddr < total_num_var_ );
    218214                dep_taddr_[i] = y_taddr;
    219215        }
    220216
     217        // put an EndOp at the end of the tape
     218        tape->Rec_.PutOp(EndOp);
     219
     220        // total number of variables on the tape
     221        total_num_var_ = tape->Rec_.num_rec_var();
     222
    221223        // now that each dependent variable has a place in the tape,
     224        // and there is a EndOp at the end of the tape,
    222225        // we can make a copy for this function and erase the tape.
    223226        play_ = tape->Rec_;
  • trunk/cppad/local/for_jac_sweep.hpp

    r1539 r1588  
    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
    136         // skip the NonOp at the beginning of the recording
     136        // skip the BeginOp at the beginning of the recording
    137137        play->start_forward(op, arg, i_op, i_var);
     138        CPPAD_ASSERT_UNKNOWN( op == BeginOp );
    138139        arg_0 = arg;
    139140        while(i_op < numop_m1)
     
    224225                        case CosOp:
    225226                        // cosine and sine must come in pairs
    226                         // but ivar + 1 should only be used here
     227                        // but ivar should only be used here
    227228                        CPPAD_ASSERT_NARG_NRES(op, 1, 2);
    228229                        forward_sparse_jacobian_unary_op(
     
    234235                        case CoshOp:
    235236                        // hyperbolic cosine and sine must come in pairs
    236                         // but ivar + 1 should only be used here
     237                        // but ivar should only be used here
    237238                        CPPAD_ASSERT_NARG_NRES(op, 1, 2);
    238239                        forward_sparse_jacobian_unary_op(
     
    269270                                i_var, arg[0], var_sparsity
    270271                        );
     272                        break;
     273                        // -------------------------------------------------
     274
     275                        case EndOp:
     276                        CPPAD_ASSERT_NARG_NRES(op, 0, 0);
    271277                        break;
    272278                        // -------------------------------------------------
     
    344350                        // -------------------------------------------------
    345351
    346                         case NonOp:
    347                         CPPAD_ASSERT_NARG_NRES(op, 0, 1);
    348                         var_sparsity.clear(i_var);
    349                         break;
    350 
    351352                        case ParOp:
    352353                        CPPAD_ASSERT_NARG_NRES(op, 1, 1);
     
    356357
    357358                        case PowvpOp:
    358                         // Pow operator is a special case where final result
    359                         // comes at the end of the three variables
    360359                        CPPAD_ASSERT_NARG_NRES(op, 2, 3);
    361360                        forward_sparse_jacobian_unary_op(
    362                                 i_var + 2, arg[0], var_sparsity
     361                                i_var, arg[0], var_sparsity
    363362                        );
    364363                        break;
     
    366365
    367366                        case PowpvOp:
    368                         // Pow operator is a special case where final result
    369                         // comes at the end of the three variables
    370367                        CPPAD_ASSERT_NARG_NRES(op, 2, 3);
    371368                        forward_sparse_jacobian_unary_op(
    372                                 i_var + 2, arg[1], var_sparsity
     369                                i_var, arg[1], var_sparsity
    373370                        );
    374371                        break;
     
    376373
    377374                        case PowvvOp:
    378                         // Pow operator is a special case where final result
    379                         // comes at the end of the three variables
    380375                        CPPAD_ASSERT_NARG_NRES(op, 2, 3);
    381376                        forward_sparse_jacobian_binary_op(
    382                                 i_var + 2, arg, var_sparsity
     377                                i_var, arg, var_sparsity
    383378                        );
    384379                        break;
     
    398393                        case SinOp:
    399394                        // sine and cosine must come in pairs
    400                         // but ivar + 1 should only be used here
     395                        // but ivar should only be used here
    401396                        CPPAD_ASSERT_NARG_NRES(op, 1, 2);
    402397                        forward_sparse_jacobian_unary_op(
     
    408403                        case SinhOp:
    409404                        // hyperbolic sine and cosine must come in pairs
    410                         // but ivar + 1 should only be used here
     405                        // but ivar should only be used here
    411406                        CPPAD_ASSERT_NARG_NRES(op, 1, 2);
    412407                        forward_sparse_jacobian_unary_op(
     
    489484# if CPPAD_FOR_JAC_SWEEP_TRACE
    490485                // value for this variable
    491                 for(j = 0; j < limit j++)
     486                for(j = 0; j < limit; j++)
    492487                        z_value[j] = false;
    493488                var_sparsity.begin(i_var);
     
    513508        }
    514509# endif
    515         CPPAD_ASSERT_UNKNOWN( (i_var + NumRes(op) ) == play->num_rec_var() );
     510        CPPAD_ASSERT_UNKNOWN( i_var + 1 == play->num_rec_var() );
    516511
    517512        if( vecad_ind != CPPAD_NULL )
  • trunk/cppad/local/forward0sweep.hpp

    r1497 r1588  
    158158                text = Rec->GetTxt(0);
    159159
    160         // skip the NonOp at the beginning of the recording
     160        // skip the BeginOp at the beginning of the recording
    161161        Rec->start_forward(op, arg, i_op, i_var);
    162         CPPAD_ASSERT_UNKNOWN( op == NonOp );
     162        CPPAD_ASSERT_UNKNOWN( op == BeginOp );
    163163# if CPPAD_FORWARD0SWEEP_TRACE
    164164        std::cout << std::endl;
     
    197197
    198198                        case AcosOp:
    199                         // results: acos(x),  sqrt(1 - x * x)
    200                         CPPAD_ASSERT_UNKNOWN( (i_var+1) < numvar  );
     199                        // results: sqrt(1 - x * x), acos(x)
     200                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
    201201                        forward_acos_op_0(i_var, arg[0], J, Taylor);
    202202                        break;
     
    204204
    205205                        case AsinOp:
    206                         // results: asin(x),  sqrt(1 - x * x)
    207                         CPPAD_ASSERT_UNKNOWN( (i_var+1) < numvar  );
     206                        // results: sqrt(1 - x * x), asin(x)
     207                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
    208208                        forward_asin_op_0(i_var, arg[0], J, Taylor);
    209209                        break;
     
    211211
    212212                        case AtanOp:
    213                         // results: atan(x),  1 + x * x
    214                         CPPAD_ASSERT_UNKNOWN( (i_var+1) < numvar  );
     213                        // results: 1 + x * x, atan(x)
     214                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
    215215                        forward_atan_op_0(i_var, arg[0], J, Taylor);
    216216                        break;
     
    234234
    235235                        case CosOp:
    236                         // results: cos(x), sin(x)
    237                         CPPAD_ASSERT_UNKNOWN( (i_var+1) < numvar  );
     236                        // results: sin(x), cos(x)
     237                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
    238238                        forward_cos_op_0(i_var, arg[0], J, Taylor);
    239239                        break;
     
    241241
    242242                        case CoshOp:
    243                         // variables: cosh(x), sinh(x)
    244                         CPPAD_ASSERT_UNKNOWN( (i_var+1) < numvar  );
     243                        // variables: sinh(x), cosh(x)
     244                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
    245245                        forward_cosh_op_0(i_var, arg[0], J, Taylor);
    246246                        break;
     
    266266                        CPPAD_ASSERT_UNKNOWN( arg[1] < num_par );
    267267                        forward_divvp_op_0(i_var, arg, parameter, J, Taylor);
     268                        break;
     269                        // -------------------------------------------------
     270
     271                        case EndOp:
     272                        CPPAD_ASSERT_NARG_NRES(op, 0, 0);
    268273                        break;
    269274                        // -------------------------------------------------
     
    336341                        // -------------------------------------------------
    337342
    338                         case NonOp:
    339                         CPPAD_ASSERT_UNKNOWN( NumArg(op) == 0 );
    340                         CPPAD_ASSERT_UNKNOWN( NumRes(op) == 0 );
    341                         break;
    342                         // -------------------------------------------------
    343 
    344343                        case ParOp:
    345344                        forward_par_op_0(
     
    381380
    382381                        case SinOp:
    383                         // variables: sin(x), cos(x)
    384                         CPPAD_ASSERT_UNKNOWN( (i_var+1) < numvar  );
     382                        // variables: cos(x), sin(x)
     383                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
    385384                        forward_sin_op_0(i_var, arg[0], J, Taylor);
    386385                        break;
     
    388387
    389388                        case SinhOp:
    390                         // variables: sinh(x), cosh(x)
    391                         CPPAD_ASSERT_UNKNOWN( (i_var+1) < numvar  );
     389                        // variables: cosh(x), sinh(x)
     390                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
    392391                        forward_sinh_op_0(i_var, arg[0], J, Taylor);
    393392                        break;
     
    479478                size_t       i_tmp  = i_var;
    480479                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                 }
     480
    485481                printOp(
    486482                        std::cout,
     
    499495        }
    500496# endif
    501         CPPAD_ASSERT_UNKNOWN( (i_var + NumRes(op)) == Rec->num_rec_var() );
     497        CPPAD_ASSERT_UNKNOWN( i_var + 1 == Rec->num_rec_var() );
     498
    502499        if( VectorInd != CPPAD_NULL )
    503500                CPPAD_TRACK_DEL_VEC(VectorInd);
  • trunk/cppad/local/forward_sweep.hpp

    r1497 r1588  
    169169       
    170170
    171         // skip the NonOp at the beginning of the recording
     171        // skip the BeginOp at the beginning of the recording
    172172        Rec->start_forward(op, arg, i_op, i_var);
    173         CPPAD_ASSERT_UNKNOWN( op == NonOp );
     173        CPPAD_ASSERT_UNKNOWN( op == BeginOp );
    174174# if CPPAD_FORWARD_SWEEP_TRACE
    175175        std::cout << std::endl;
     
    208208
    209209                        case AcosOp:
    210                         // variables: acos(x),  sqrt(1 - x * x)
    211                         CPPAD_ASSERT_UNKNOWN( (i_var+1) < numvar  );
     210                        // variables: sqrt(1 - x * x), acos(x)
     211                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
    212212                        forward_acos_op(d, i_var, arg[0], J, Taylor);
    213213                        break;
     
    215215
    216216                        case AsinOp:
    217                         // results: asin(x),  sqrt(1 - x * x)
    218                         CPPAD_ASSERT_UNKNOWN( (i_var+1) < numvar  );
     217                        // results: sqrt(1 - x * x), asin(x)
     218                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
    219219                        forward_asin_op(d, i_var, arg[0], J, Taylor);
    220220                        break;
     
    222222
    223223                        case AtanOp:
    224                         // results: atan(x),  1 + x * x
    225                         CPPAD_ASSERT_UNKNOWN( (i_var+1) < numvar  );
     224                        // results: 1 + x * x, atan(x)
     225                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
    226226                        forward_atan_op(d, i_var, arg[0], J, Taylor);
    227227                        break;
     
    245245
    246246                        case CosOp:
    247                         // variables: cos(x), sin(x)
    248                         CPPAD_ASSERT_UNKNOWN( (i_var+1) < numvar  );
     247                        // variables: sin(x), cos(x)
     248                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
    249249                        forward_cos_op(d, i_var, arg[0], J, Taylor);
    250250                        break;
     
    252252
    253253                        case CoshOp:
    254                         // variables: cosh(x), sinh(x)
    255                         CPPAD_ASSERT_UNKNOWN( (i_var+1) < numvar  );
     254                        // variables: sinh(x), cosh(x)
     255                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
    256256                        forward_cosh_op(d, i_var, arg[0], J, Taylor);
    257257                        break;
     
    283283                        CPPAD_ASSERT_UNKNOWN( arg[1] < num_par );
    284284                        forward_divvp_op(d, i_var, arg, parameter, J, Taylor);
     285                        break;
     286                        // -------------------------------------------------
     287
     288                        case EndOp:
     289                        CPPAD_ASSERT_NARG_NRES(op, 0, 0);
    285290                        break;
    286291                        // -------------------------------------------------
     
    364369                        // -------------------------------------------------
    365370
    366                         case NonOp:
    367                         CPPAD_ASSERT_UNKNOWN( NumArg(op) == 0 );
    368                         CPPAD_ASSERT_UNKNOWN( NumRes(op) == 1 );
    369                         break;
    370                         // -------------------------------------------------
    371 
    372371                        case ParOp:
    373372# if ! CPPAD_USE_FORWARD0SWEEP
     
    418417
    419418                        case SinOp:
    420                         // variables: sin(x), cos(x)
    421                         CPPAD_ASSERT_UNKNOWN( (i_var+1) < numvar  );
     419                        // variables: cos(x), sin(x)
     420                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
    422421                        forward_sin_op(d, i_var, arg[0], J, Taylor);
    423422                        break;
     
    425424
    426425                        case SinhOp:
    427                         // variables: sinh(x), cosh(x)
    428                         CPPAD_ASSERT_UNKNOWN( (i_var+1) < numvar  );
     426                        // variables: cosh(x), sinh(x)
     427                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
    429428                        forward_sinh_op(d, i_var, arg[0], J, Taylor);
    430429                        break;
     
    531530                size_t       i_tmp  = i_var;
    532531                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                 }
    537532                printOp(
    538533                        std::cout,
     
    551546        }
    552547# endif
    553         CPPAD_ASSERT_UNKNOWN( (i_var + NumRes(op) ) == Rec->num_rec_var() );
     548        CPPAD_ASSERT_UNKNOWN( i_var + 1 == Rec->num_rec_var() );
     549
    554550        if( VectorInd != CPPAD_NULL )
    555551                CPPAD_TRACK_DEL_VEC(VectorInd);
  • trunk/cppad/local/independent.hpp

    r1447 r1588  
    141141        CPPAD_ASSERT_UNKNOWN( Rec_.num_rec_var() == 0 );
    142142
    143         // skip the first record (parameters use taddr zero)
    144         CPPAD_ASSERT_UNKNOWN( NumRes(NonOp) == 1 );
    145         CPPAD_ASSERT_UNKNOWN( NumArg(NonOp) == 0 );
    146         Rec_.PutOp(NonOp);
    147 
     143        // mark the beginning of the tape and skip the first variable index
     144        // (zero) because parameters use taddr zero
     145        CPPAD_ASSERT_NARG_NRES(BeginOp, 0, 1);
     146        Rec_.PutOp(BeginOp);
    148147
    149148        // place each of the independent variables in the tape
    150         CPPAD_ASSERT_UNKNOWN( NumRes(InvOp) == 1 );
    151         CPPAD_ASSERT_UNKNOWN( NumArg(InvOp) == 0 );
     149        CPPAD_ASSERT_NARG_NRES(InvOp, 0, 1);
    152150        size_t j;
    153151        for(j = 0; j < n; j++)
  • trunk/cppad/local/op_code.hpp

    r1523 r1588  
    5151        AsinOp,   // asin(variable)
    5252        AtanOp,   // atan(variable)
     53        BeginOp,  // used to mark the beginning of the tape
    5354        CExpOp,   // CondExp(cop, left, right, trueCase, falseCase)
    5455        ComOp,    // Compare(cop, result, left, right)
     
    5960        DivvpOp,  //      variable   / parameter
    6061        DivvvOp,  //      variable   / variable
     62        EndOp,    //  used to mark the end of the tape
    6163        ExpOp,    //  exp(variable)
    6264        LdpOp,    //    z[parameter]
     
    6769        MulvpOp,  //      variable   * parameter
    6870        MulvvOp,  //      variable   * variable
    69         NonOp,    //                             space holder
    7071        ParOp,    //      parameter
    7172        PowvpOp,  //  pow(variable,    parameter)
     
    108109        1, // AsinOp
    109110        1, // AtanOp
     111        0, // BeginOp
    110112        6, // CExpOp
    111113        4, // ComOp
     
    116118        2, // DivvpOp
    117119        2, // DivvvOp
     120        0, // EndOp
    118121        1, // ExpOp
    119122        3, // LdpOp
     
    124127        2, // MulpvOp
    125128        2, // MulvpOp
    126         0, // NonOp
    127129        1, // ParOp
    128130        2, // PowvpOp
     
    184186        2, // AsinOp
    185187        2, // AtanOp
     188        1, // BeginOp  offsets first variable to have index one (not zero)
    186189        1, // CExpOp
    187190        0, // ComOp
     
    192195        1, // DivvpOp
    193196        1, // DivvvOp
     197        0, // EndOp
    194198        1, // ExpOp
    195199        1, // LdpOp
     
    200204        1, // MulpvOp
    201205        1, // MulvpOp
    202         1, // NonOp
    203206        1, // ParOp
    204207        3, // PowvpOp
     
    373376                "Asin"  ,
    374377                "Atan"  ,
     378                "Begin" ,
    375379                "CExp"  ,
    376380                "Com"   ,
     
    381385                "Divvp" ,
    382386                "Divvv" ,
     387                "End"   ,
    383388                "Exp"   ,
    384389                "Ldp"   ,
     
    389394                "Mulvp" ,
    390395                "Mulvv" ,
    391                 "Non"   ,
    392396                "Par"   ,
    393397                "Powvp" ,
     
    529533                break;
    530534
     535                case BeginOp:
     536                case EndOp:
    531537                case InvOp:
    532                 case NonOp:
    533538                CPPAD_ASSERT_UNKNOWN( NumArg(op) == 0 );
    534539                break;
  • trunk/cppad/local/optimize.hpp

    r1580 r1588  
    236236
    237237        // Initialize a reverse mode sweep through the operation sequence
    238         play->start_reverse();
    239         size_t i_op = 2;
     238        size_t i_op;
     239        play->start_reverse(op, arg, i_op, i_var);
     240        CPPAD_ASSERT_UNKNOWN( op == EndOp );
    240241        size_t mask;
    241242# if CPPAD_OPTIMIZE_TRACE
     
    265266                {
    266267                        // Unary operator where operand is arg[0]
    267                         case PowvpOp:
    268                         i_var = CPPAD_POW_FINAL_RESULT(i_var, op);
    269268                        case AbsOp:
    270269                        case AddvpOp:
     
    279278                        case LogOp:
    280279                        case MulvpOp:
     280                        case PowvpOp:
    281281                        case SinOp:
    282282                        case SinhOp:
     
    287287
    288288                        // Unary operator where operand is arg[1]
    289                         case PowpvOp:
    290                         i_var = CPPAD_POW_FINAL_RESULT(i_var, op);
    291289                        case AddpvOp:
    292290                        case DivpvOp:
    293291                        case MulpvOp:
    294292                        case SubpvOp:
     293                        case PowpvOp:
    295294                        case PrivOp:
    296295                        connected[ arg[1] ] |= connected[ i_var ];
     
    298297
    299298                        // Binary operator where operands are arg[0], arg[1]
    300                         case PowvvOp:
    301                         i_var = CPPAD_POW_FINAL_RESULT(i_var, op);
    302299                        case AddvvOp:
    303300                        case DivvvOp:
    304301                        case MulvvOp:
     302                        case PowvvOp:
    305303                        case SubvvOp:
    306304                        connected[ arg[0] ] |= connected[ i_var ];
     
    322320
    323321                        // Operations where there is noting to do
     322                        case BeginOp:
    324323                        case ComOp:
     324                        case EndOp:
    325325                        case InvOp:
    326                         case NonOp:
    327326                        case ParOp:
    328327                        case PripOp:
     
    407406        play->start_forward(op, arg, i_op, i_var);
    408407
    409         // put the beginning NonOp in the recording
    410         CPPAD_ASSERT_UNKNOWN( op == NonOp );
    411         CPPAD_ASSERT_NARG_NRES(NonOp, 0, 1);
    412         new_var[ i_var ] = rec->PutOp(NonOp);
     408        // playing forward skips BeginOp at the beginning, but not EndOp at
     409        // the end.  Put BeginOp at beginning of recording
     410        CPPAD_ASSERT_UNKNOWN( op == BeginOp );
     411        CPPAD_ASSERT_NARG_NRES(BeginOp, 0, 1);
     412        new_var[ i_var ] = rec->PutOp(BeginOp);
    413413
    414414        // temporary buffer for new argument values
     
    431431
    432432                        case InvOp:
     433                        case EndOp:
    433434                        keep = true;
    434435                        break;
     
    442443                        keep = vecad_connected[i];
    443444                        break;
    444 
    445                         case PowpvOp:
    446                         case PowvpOp:
    447                         case PowvvOp:
    448                         i_var = CPPAD_POW_FINAL_RESULT(i_var, op);
    449445
    450446                        default:
     
    500496                        rec->PutArg( new_arg[0], new_arg[1] );
    501497                        new_var[ i_var ] = rec->PutOp(op);
    502                         new_var[ i_var ] =
    503                                 CPPAD_POW_FINAL_RESULT(new_var[ i_var ], op);
    504498                        break;
    505499
     
    527521                        rec->PutArg( new_arg[0], new_arg[1] );
    528522                        new_var[ i_var ] = rec->PutOp(op);
    529                         new_var[ i_var ] =
    530                                 CPPAD_POW_FINAL_RESULT(new_var[ i_var ], op);
    531523                        break;
    532524
     
    555547                        rec->PutArg( new_arg[0], new_arg[1] );
    556548                        new_var[ i_var ] = rec->PutOp(op);
    557                         new_var[ i_var ] =
    558                                 CPPAD_POW_FINAL_RESULT(new_var[ i_var ], op);
    559549                        break;
    560550
     
    588578                        break;
    589579
     580                        // Operations with no arguments and no results
     581                        case EndOp:
     582                        CPPAD_ASSERT_NARG_NRES(op, 0, 0);
     583                        break;
     584
    590585                        // Operations with no arguments and one result
    591586                        case InvOp:
    592                         case NonOp:
    593587                        CPPAD_ASSERT_NARG_NRES(op, 0, 1);
    594588                        new_var[ i_var ] = rec->PutOp(op);
  • trunk/cppad/local/player.hpp

    r1561 r1588  
    444444        size_t    op_arg_;
    445445
    446         /// Index for first variable corresponding to current operator
     446        /// Index for primary (last) variable corresponding to current operator
    447447        size_t    var_index_;
    448448
     
    456456        \param op
    457457        The input value of op does not matter. Its output value is the
    458         first operator in the recording; i.e., NonOp.
     458        first operator in the recording; i.e., BeginOp.
    459459
    460460        \param op_arg
     
    469469        \param var_index
    470470        The input value of var_index does not matter. Its output value is the
    471         index of the first result variable corresponding to the the first
    472         operator; i.e., 0.
     471        index of the primary (last) result corresponding to the the first
     472        operator (which must be a BeginOp); i.e., 0.
    473473        */
    474474        void start_forward(
     
    480480                op_index  = op_index_    = 0;
    481481                var_index = var_index_   = 0;
    482 # ifndef NDEBUG
    483                 CPPAD_ASSERT_UNKNOWN( op_         == NonOp );
    484                 CPPAD_ASSERT_UNKNOWN( NumRes(op_) == 1     );
    485                 CPPAD_ASSERT_UNKNOWN( NumArg(op_) == 0     );
    486 # endif
     482
     483                CPPAD_ASSERT_UNKNOWN( op_  == BeginOp );
     484                CPPAD_ASSERT_NARG_NRES(op_, 0, 1);
     485
    487486                return;
    488487        }
     
    492491
    493492        Use start_forward to initialize to the first operator; i.e.,
    494         the NonOp at the beginning of the recording.
     493        the BeginOp at the beginning of the recording.
    495494
    496495        \param op
     
    510509        \param var_index
    511510        The input value of var_index does not matter. Its output value is the
    512         index of the first result variable corresponding to the operator op.
     511        index of the primary (last) result corresponding to the operator op.
    513512        */
    514513
     
    518517                using CppAD::NumArg;
    519518
     519                // index for the next operator
    520520                op_index    = ++op_index_;
    521                 op_arg_    += NumArg(op_);
    522                 var_index_ += NumRes(op_);
    523 
     521
     522                // first argument for next operator
     523                op_arg_    += NumArg(op_);            // index
     524                op_arg      = op_arg_ + rec_op_arg_;  // pointer
     525
     526                // next operator
    524527                op          = op_         = rec_op_[ op_index_ ];
    525                 op_arg      = op_arg_ + rec_op_arg_;
    526                 var_index   = var_index_;
     528
     529                // index for last result for next operator
     530                var_index   = var_index_ += NumRes(op);
    527531
    528532                CPPAD_ASSERT_UNKNOWN( op_index_  < num_rec_op_ );
    529533                CPPAD_ASSERT_UNKNOWN( op_arg_ + NumArg(op) <= num_rec_op_arg_ );
    530                 CPPAD_ASSERT_UNKNOWN( var_index_ + NumRes(op) <= num_rec_var_ );
     534                CPPAD_ASSERT_UNKNOWN( var_index_  < num_rec_var_ );
    531535        }
    532536        /*!
     
    544548
    545549        Use repeated calls to next_reverse to play back one operator at a time.
    546         */
    547         void start_reverse(void)
     550
     551        \param op
     552        The input value of op does not matter. Its output value is the
     553        last operator in the recording; i.e., EndOp.
     554
     555        \param op_arg
     556        The input value of *op_arg does not matter. Its output value is the
     557        beginning of the vector of argument indices for the last operation;
     558        (there are no arguments for the last operation so \a op_arg is invalid).
     559
     560        \param op_index
     561        The input value of op_index does not matter. Its output value
     562        is the index of the last operator in the recording.
     563
     564        \param var_index
     565        The input value of var_index does not matter. Its output value is the
     566        index of the primary (last) result corresponding to the the last
     567        operator (which must be a EndOp).
     568        (there are no results for the last operation
     569        so \a var_index is invalid).
     570        */
     571
     572        void start_reverse(
     573        OpCode& op, const size_t*& op_arg, size_t& op_index, size_t& var_index)
    548574        {
    549                 op_arg_     = num_rec_op_arg_;
    550                 op_index_   = num_rec_op_;
    551                 var_index_  = num_rec_var_;
     575                op_arg_     = num_rec_op_arg_;                // index
     576                op_arg      = op_arg_ + rec_op_arg_;          // pointer
     577
     578                op_index    = op_index_   = num_rec_op_ - 1;
     579                var_index   = var_index_  = num_rec_var_ - 1;
     580
     581                op          = op_         = rec_op_[ op_index_ ];
     582                CPPAD_ASSERT_UNKNOWN( op_ == EndOp );
     583                CPPAD_ASSERT_NARG_NRES(op, 0, 0);
    552584                return;
    553585        }
     
    563595        The input value of op does not matter. Its output value is the
    564596        next operator in the recording (in reverse order).
    565         The last operator sets op equal to NonOp.
     597        The last operator sets op equal to EndOp.
    566598
    567599        \param op_arg
     
    582614        \param var_index
    583615        The input value of var_index does not matter. Its output value is the
    584         index of the first result variable corresponding to the operator op.
    585         The last operator sets var_index equal to 0.
     616        index of the primary (last) result corresponding to the operator op.
     617        The last operator sets var_index equal to 0 (corresponding to BeginOp
     618        at beginning of operation sequence).
    586619        */
    587620
     
    591624                using CppAD::NumArg;
    592625
     626                // index of the last result for the next operator
     627                CPPAD_ASSERT_UNKNOWN( var_index_ >= NumRes(op_) );
     628                var_index   = var_index_ -= NumRes(op_);
     629
     630                // next operator
    593631                CPPAD_ASSERT_UNKNOWN( op_index_  > 0 );
    594                 op_index    = --op_index_;
    595                 op_         = rec_op_[ op_index_ ];
    596 
    597                 CPPAD_ASSERT_UNKNOWN( op_arg_ >= NumArg(op_)  );
    598                 op_arg_    -= NumArg(op_);
    599 
    600                 CPPAD_ASSERT_UNKNOWN( var_index_ >= NumRes(op_) );
    601                 var_index_ -= NumRes(op_);
    602 
    603                 op          = op_;
    604                 op_arg      = op_arg_ + rec_op_arg_;
    605                 var_index   = var_index_;
    606 
     632                op_index    = --op_index_;                           // index
     633                op          = op_         = rec_op_[ op_index_ ];    // value
     634
     635                // first argument for next operator
     636                CPPAD_ASSERT_UNKNOWN( op_arg_ >= NumArg(op)  );
     637                op_arg_    -= NumArg(op);                            // index
     638                op_arg      = op_arg_ + rec_op_arg_;                 // pointer
    607639        }
    608640
  • trunk/cppad/local/pow.hpp

    r1580 r1588  
    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
  • trunk/cppad/local/pow_op.hpp

    r1451 r1588  
    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 );
  • trunk/cppad/local/prototype_op.hpp

    r1550 r1588  
    216216
    217217\param i_z
    218 variable index corresponding to the first result for this operation;
     218variable index corresponding to the last (primary) result for this operation;
    219219i.e. the row index in \a taylor corresponding to z.
    220 The auxillary result is called y has index \a i_z + 1.
     220The auxillary result is called y has index \a i_z - 1.
    221221
    222222\param i_x
     
    236236is the k-th order Taylor coefficient corresponding to z.
    237237\n
    238 \b Input: \a taylor [ ( \a i_z + 1) * \a nc_taylor + k ]
     238\b Input: \a taylor [ ( \a i_z - 1) * \a nc_taylor + k ]
    239239for k = 0 , ... , \a j - 1
    240240is the k-th order Taylor coefficient corresponding to the auxillary result y.
     
    243243is the j-th order Taylor coefficient corresponding to z.
    244244\n
    245 \b Output: \a taylor [ ( \a i_z + 1 ) * \a nc_taylor + j ]
     245\b Output: \a taylor [ ( \a i_z - 1 ) * \a nc_taylor + j ]
    246246is the j-th order Taylor coefficient corresponding to
    247247the autillary result y.
     
    250250\li NumArg(op) == 1
    251251\li NumRes(op) == 2
    252 \li \a i_x < \a i_z
     252\li \a i_x + 1 < \a i_z
    253253\li \a j < \a nc_taylor
    254254*/
     
    273273
    274274\param i_z
    275 variable index corresponding to the result for this operation;
     275variable index corresponding to the last (primary) result for this operation;
    276276i.e. the row index in \a taylor corresponding to z.
    277 The auxillary result is called y and has index \a i_z + 1.
     277The auxillary result is called y and has index \a i_z - 1.
    278278
    279279\param i_x
     
    291291is the zero order Taylor coefficient corresponding to z.
    292292\n
    293 \b Output: \a taylor [ ( \a i_z + 1 ) * \a nc_taylor + j ]
     293\b Output: \a taylor [ ( \a i_z - 1 ) * \a nc_taylor + j ]
    294294is the j-th order Taylor coefficient corresponding to
    295295the autillary result y.
     
    298298\li NumArg(op) == 1
    299299\li NumRes(op) == 2
    300 \li \a i_x < \a i_z
     300\li \a i_x + 1 < \a i_z
    301301\li \a j < \a nc_taylor
    302302*/
     
    332332
    333333\param i_z
    334 variable index corresponding to the result for this operation;
     334variable index corresponding to the last (primary) result for this operation;
    335335i.e. the row index in \a taylor to z.
    336 The auxillary result is called y and has index \a i_z + 1.
     336The auxillary result is called y and has index \a i_z - 1.
    337337
    338338\param i_x
     
    352352is the k-th order Taylor coefficient corresponding to z.
    353353\n
    354 \a taylor [ ( \a i_z + 1) * \a nc_taylor + k ]
     354\a taylor [ ( \a i_z - 1) * \a nc_taylor + k ]
    355355for k = 0 , ... , \a d
    356356is the k-th order Taylor coefficient corresponding to
     
    372372the k-th order Taylor coefficient for z.
    373373\n
    374 \b Input: \a partial [ ( \a i_z + 1) * \a nc_partial + k ]
     374\b Input: \a partial [ ( \a i_z - 1) * \a nc_partial + k ]
    375375for k = 0 , ... , \a d
    376376is the partial derivative of G( z , x , w , u , ... ) with respect to
     
    382382the k-th order Taylor coefficient for x.
    383383\n
    384 \b Output: \a partial [ \a i_z * \a nc_partial + k ]
    385 for k = 0 , ... , \a d
    386 may be used as work space; i.e., may change in an unspecified manner.
    387 \n
    388 \b Output: \a partial [ ( \a i_z + 1) * \a nc_partial + k ]
    389 for k = 0 , ... , \a d
     384\b Output: \a partial [ \a ( i_z - j ) * \a nc_partial + k ]
     385for j = 0 , 1 , and for k = 0 , ... , \a d
    390386may be used as work space; i.e., may change in an unspecified manner.
    391387
     
    394390\li NumArg(op) == 1
    395391\li NumRes(op) == 2
    396 \li \a i_x < \a i_z
     392\li \a i_x + 1 < \a i_z
    397393\li \a d < \a nc_taylor
    398394\li \a d < \a nc_partial
     
    627623is the partial derivative of H( y , x , w , u , ... ) with respect to
    628624the k-th order Taylor coefficient for y.
     625\n
     626\b Output: \a partial [ \a i_z * \a nc_partial + k ]
     627for k = 0 , ... , \a d
     628may be used as work space; i.e., may change in an unspecified manner.
    629629
    630630\par Checked Assumptions
     
    663663
    664664\param i_z
    665 variable index corresponding to the first result for this operation;
     665variable index corresponding to the last (primary) 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
     
    702702is the k-th order Taylor coefficient corresponding to y.
    703703\n
    704 \b Input: \a taylor [ \a (i_z + j) * \a nc_taylor + k ]
     704\b Input: \a taylor [ \a (i_z - 2 + j) * \a nc_taylor + k ]
    705705for j = 0, 1, 2 , and for k = 0 , ... , \a d - 1
    706706is the k-th order Taylor coefficient corresponding to z_j.
    707707\n
    708 \b Output: \a taylor [ \a (i_z + j) * \a nc_taylor + \a d ]
     708\b Output: \a taylor [ \a (i_z - 2 + j) * \a nc_taylor + \a d ]
    709709is the \a d-th order Taylor coefficient corresponding to z_j.
    710710
     
    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 last (primary) 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
     
    774774is the k-th order Taylor coefficient corresponding to y.
    775775\n
    776 \b Output: \a taylor [ \a (i_z + j) * \a nc_taylor + 0 ]
     776\b Output: \a taylor [ \a (i_z - 2 + j) * \a nc_taylor + 0 ]
    777777is the zero order Taylor coefficient corresponding to z_j.
    778778
     
    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 last (primary) 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
     
    845845
    846846\param taylor
    847 \a taylor [ \a (i_z + j) * \a nc_taylor + k ]
     847\a taylor [ \a (i_z - 2 + j) * \a nc_taylor + k ]
    848848for j = 0, 1, 2 and k = 0 , ... , \a d
    849849is the k-th order Taylor coefficient corresponding to z_j.
     
    861861
    862862\param partial
    863 \b Input: \a partial [ \a (i_z + j) * \a nc_partial + k ]
     863\b Input: \a partial [ \a (i_z - 2 + j) * \a nc_partial + k ]
    864864for j = 0, 1, 2, and k = 0 , ... , \a d
    865865is the partial derivative of
     
    886886is the partial derivative of H( y , x , w , u , ... ) with respect to
    887887the k-th order Taylor coefficient for y.
     888\n
     889\b Output: \a partial [ \a ( i_z - j ) * \a nc_partial + k ]
     890for j = 0 , 1 , 2 and for k = 0 , ... , \a d
     891may be used as work space; i.e., may change in an unspecified manner.
    888892
    889893\par Checked Assumptions
    890894\li NumArg(op) == 2
    891895\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
     896\li \a If x is a variable, arg[0] < \a i_z - 2
     897\li \a If y is a variable, arg[1] < \a i_z - 2
    894898\li \a d < \a nc_taylor
    895899\li \a d < \a nc_partial
     
    11231127
    11241128\param i_z
    1125 is the index corresponding to the next variable on the tape
     1129is the index corresponding to the previous variable on the tape
    11261130(only used for error checking).
    11271131
     
    11921196\li \a arg[0] + i_vec < nc_combined
    11931197\li if y is a parameter, arg[2] < num_par
    1194 \li if x is a variable, arg[1] < i_z
    1195 \li if y is a variable, arg[2] < i_z
     1198\li if x is a variable, arg[1] <= i_z
     1199\li if y is a variable, arg[2] <= i_z
    11961200*/
    11971201template <class Base>
  • trunk/cppad/local/recorder.hpp

    r1541 r1588  
    212212
    213213\return
    214 The return value is the index of the first variable
     214The return value is the index of the primary (last) variable
    215215corresponding to the result of this operation.
    216216The number of variables corresponding to the operation is given by
     
    220220With each call to PutOp
    221221the return index increases by the number of variables corresponding
    222 to the previous call to PutOp.
     222to this call to PutOp.
    223223This index starts at zero after the default constructor
    224224and after each call to Erase.
     
    226226template <class Base>
    227227inline size_t recorder<Base>::PutOp(OpCode op)
    228 {       size_t varIndex = num_rec_var_;
    229        
     228{
    230229        CPPAD_ASSERT_UNKNOWN( num_rec_op_ <= len_rec_op_ );
    231230        if( num_rec_op_ == len_rec_op_ )
     
    239238        num_rec_var_ += NumRes(op);
    240239
    241         return varIndex;
     240        // first operator should be a BeginOp and NumRes( BeginOp ) > 0
     241        CPPAD_ASSERT_UNKNOWN( num_rec_var_ > 0 );
     242
     243        return num_rec_var_ - 1;
    242244}
    243245
  • trunk/cppad/local/rev_hes_sweep.hpp

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

    r1539 r1588  
    134134
    135135        // Initialize
    136         play->start_reverse();
     136        play->start_reverse(op, arg, i_op, i_var);
     137        CPPAD_ASSERT_UNKNOWN( op == EndOp );
    137138        i_op = 2;
    138139# if CPPAD_REV_JAC_SWEEP_TRACE
     
    147148                CPPAD_ASSERT_UNKNOWN( (i_op <= n) | (op != InvOp) );
    148149
     150
     151                // rest of information depends on the case
     152                switch( op )
     153                {
     154                        case AbsOp:
     155                        CPPAD_ASSERT_NARG_NRES(op, 1, 1);
     156                        reverse_sparse_jacobian_unary_op(
     157                                i_var, arg[0], var_sparsity
     158                        );
     159                        break;
     160                        // -------------------------------------------------
     161
     162                        case AddvvOp:
     163                        CPPAD_ASSERT_NARG_NRES(op, 2, 1);
     164                        reverse_sparse_jacobian_binary_op(
     165                                i_var, arg, var_sparsity
     166                        );
     167                        break;
     168                        // -------------------------------------------------
     169
     170                        case AddpvOp:
     171                        CPPAD_ASSERT_NARG_NRES(op, 2, 1);
     172                        reverse_sparse_jacobian_unary_op(
     173                                i_var, arg[1], var_sparsity
     174                        );
     175                        break;
     176                        // -------------------------------------------------
     177
     178                        case AddvpOp:
     179                        CPPAD_ASSERT_NARG_NRES(op, 2, 1);
     180                        reverse_sparse_jacobian_unary_op(
     181                                i_var, arg[0], var_sparsity
     182                        );
     183                        break;
     184                        // -------------------------------------------------
     185
     186                        case AcosOp:
     187                        // acos(x) and sqrt(1 - x * x) are computed in pairs
     188                        // but i_var + 1 should only be used here
     189                        CPPAD_ASSERT_NARG_NRES(op, 1, 2);
     190                        reverse_sparse_jacobian_unary_op(
     191                                i_var, arg[0], var_sparsity
     192                        );
     193                        break;
     194                        // -------------------------------------------------
     195
     196                        case AsinOp:
     197                        // asin(x) and sqrt(1 - x * x) are computed in pairs
     198                        // but i_var + 1 should only be used here
     199                        CPPAD_ASSERT_NARG_NRES(op, 1, 2);
     200                        reverse_sparse_jacobian_unary_op(
     201                                i_var, arg[0], var_sparsity
     202                        );
     203                        break;
     204                        // -------------------------------------------------
     205
     206                        case AtanOp:
     207                        // atan(x) and 1 + x * x must be computed in pairs
     208                        // but i_var + 1 should only be used here
     209                        CPPAD_ASSERT_NARG_NRES(op, 1, 2);
     210                        reverse_sparse_jacobian_unary_op(
     211                                i_var, arg[0], var_sparsity
     212                        );
     213                        break;
     214                        // -------------------------------------------------
     215
     216                        case BeginOp:
     217                        CPPAD_ASSERT_NARG_NRES(op, 0, 0);
     218                        break;
     219                        // -------------------------------------------------
     220
     221                        case CExpOp:
     222                        reverse_sparse_jacobian_cond_op(
     223                                i_var, arg, num_par, var_sparsity
     224                        );
     225                        break;
     226                        // ---------------------------------------------------
     227
     228                        case ComOp:
     229                        CPPAD_ASSERT_NARG_NRES(op, 4, 0);
     230                        CPPAD_ASSERT_UNKNOWN( arg[1] > 1 );
     231                        break;
     232                        // --------------------------------------------------
     233
     234                        case CosOp:
     235                        // cosine and sine must come in pairs
     236                        // but i_var should only be used here
     237                        CPPAD_ASSERT_NARG_NRES(op, 1, 2);
     238                        reverse_sparse_jacobian_unary_op(
     239                                i_var, arg[0], var_sparsity
     240                        );
     241                        break;
     242                        // ---------------------------------------------------
     243
     244                        case CoshOp:
     245                        // hyperbolic cosine and sine must come in pairs
     246                        // but i_var should only be used here
     247                        CPPAD_ASSERT_NARG_NRES(op, 1, 2);
     248                        reverse_sparse_jacobian_unary_op(
     249                                i_var, arg[0], var_sparsity
     250                        );
     251                        break;
     252                        // -------------------------------------------------
     253
     254                        case DisOp:
     255                        CPPAD_ASSERT_NARG_NRES(op, 2, 1);
     256
     257                        break;
     258                        // -------------------------------------------------
     259
     260                        case DivvvOp:
     261                        CPPAD_ASSERT_NARG_NRES(op, 2, 1);
     262                        reverse_sparse_jacobian_binary_op(
     263                                i_var, arg, var_sparsity
     264                        );
     265                        break;
     266                        // -------------------------------------------------
     267
     268                        case DivpvOp:
     269                        CPPAD_ASSERT_NARG_NRES(op, 2, 1);
     270                        reverse_sparse_jacobian_unary_op(
     271                                i_var, arg[1], var_sparsity
     272                        );
     273                        break;
     274                        // -------------------------------------------------
     275
     276                        case DivvpOp:
     277                        CPPAD_ASSERT_NARG_NRES(op, 2, 1);
     278                        reverse_sparse_jacobian_unary_op(
     279                                i_var, arg[0], var_sparsity
     280                        );
     281                        break;
     282                        // -------------------------------------------------
     283
     284                        case ExpOp:
     285                        CPPAD_ASSERT_NARG_NRES(op, 1, 1);
     286                        reverse_sparse_jacobian_unary_op(
     287                                i_var, arg[0], var_sparsity
     288                        );
     289                        break;
     290                        // -------------------------------------------------
     291
     292                        case InvOp:
     293                        CPPAD_ASSERT_NARG_NRES(op, 0, 1);
     294                        break;
     295                        // -------------------------------------------------
     296
     297                        case LdpOp:
     298                        reverse_sparse_jacobian_load_op(
     299                                op,
     300                                i_var,
     301                                arg,
     302                                num_vecad_ind,
     303                                vecad_ind,
     304                                var_sparsity,
     305                                vecad_sparsity
     306                        );
     307                        break;
     308                        // -------------------------------------------------
     309
     310                        case LdvOp:
     311                        reverse_sparse_jacobian_load_op(
     312                                op,
     313                                i_var,
     314                                arg,
     315                                num_vecad_ind,
     316                                vecad_ind,
     317                                var_sparsity,
     318                                vecad_sparsity
     319                        );
     320                        break;
     321                        // -------------------------------------------------
     322
     323                        case LogOp:
     324                        CPPAD_ASSERT_NARG_NRES(op, 1, 1);
     325                        reverse_sparse_jacobian_unary_op(
     326                                i_var, arg[0], var_sparsity
     327                        );
     328                        break;
     329                        // -------------------------------------------------
     330
     331                        case MulvvOp:
     332                        CPPAD_ASSERT_NARG_NRES(op, 2, 1);
     333                        reverse_sparse_jacobian_binary_op(
     334                                i_var, arg, var_sparsity
     335                        );
     336                        break;
     337                        // -------------------------------------------------
     338
     339                        case MulpvOp:
     340                        CPPAD_ASSERT_NARG_NRES(op, 2, 1);
     341                        reverse_sparse_jacobian_unary_op(
     342                                i_var, arg[1], var_sparsity
     343                        );
     344                        break;
     345                        // -------------------------------------------------
     346
     347                        case MulvpOp:
     348                        CPPAD_ASSERT_NARG_NRES(op, 2, 1);
     349                        reverse_sparse_jacobian_unary_op(
     350                                i_var, arg[0], var_sparsity
     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 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 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 );
    514         CPPAD_ASSERT_UNKNOWN( play->GetOp(i_op-1) == NonOp );
    515         CPPAD_ASSERT_UNKNOWN( i_var == NumRes(NonOp)  );
     508        CPPAD_ASSERT_UNKNOWN( play->GetOp(i_op-1) == BeginOp );
     509        CPPAD_ASSERT_UNKNOWN( i_var == NumRes(BeginOp)  );
    516510
    517511        if( vecad_ind != CPPAD_NULL )
  • trunk/cppad/local/reverse_sweep.hpp

    r1497 r1588  
    124124
    125125\par Assumptions
    126 The first operator on the tape is a NonOp,
     126The first operator on the tape is a BeginOp,
    127127and the next \a n operators are InvOp operations for the
    128128corresponding independent variables.
     
    159159
    160160        // Initialize
    161         Rec->start_reverse();
     161        Rec->start_reverse(op, arg, i_op, i_var);
     162        CPPAD_ASSERT_UNKNOWN( op == EndOp );
    162163        i_op   = 2;
    163164# if CPPAD_REVERSE_SWEEP_TRACE
     
    176177                const Base*  pZ_tmp = Partial + i_var * K;
    177178
    178                 if( op == PowvpOp || op == PowpvOp || op == PowvvOp )
    179                 {       i_tmp  += 2;
    180                         Z_tmp  += 2 * J;
    181                         pZ_tmp += 2 * K;
    182                 }
    183179                printOp(
    184180                        std::cout,
     
    228224
    229225                        case AcosOp:
    230                         // results: acos(x),  sqrt(1 - x * x)
    231                         CPPAD_ASSERT_UNKNOWN( i_var < numvar - 1 );
     226                        // results: sqrt(1 - x * x), acos(x)
     227                        CPPAD_ASSERT_UNKNOWN( i_var < numvar );
    232228                        reverse_acos_op(
    233229                                d, i_var, arg[0], J, Taylor, K, Partial
     
    237233
    238234                        case AsinOp:
    239                         // results: sin(x),  sqrt(1 - x * x)
    240                         CPPAD_ASSERT_UNKNOWN( i_var < numvar - 1 );
     235                        // results: sqrt(1 - x * x), sin(x)
     236                        CPPAD_ASSERT_UNKNOWN( i_var < numvar );
    241237                        reverse_asin_op(
    242238                                d, i_var, arg[0], J, Taylor, K, Partial
     
    246242
    247243                        case AtanOp:
    248                         // results: atan(x),  1 + x * x
    249                         CPPAD_ASSERT_UNKNOWN( i_var < numvar - 1 );
     244                        // results: 1 + x * x, atan(x)
     245                        CPPAD_ASSERT_UNKNOWN( i_var < numvar );
    250246                        reverse_atan_op(
    251247                                d, i_var, arg[0], J, Taylor, K, Partial
     
    253249                        break;
    254250                        // -------------------------------------------------
     251
     252                        case BeginOp:
     253                        CPPAD_ASSERT_NARG_NRES(op, 0, 0);
     254                        break;
     255                        // --------------------------------------------------
    255256
    256257                        case CExpOp:
     
    274275
    275276                        case CosOp:
    276                         CPPAD_ASSERT_UNKNOWN( i_var < numvar - 1 );
     277                        CPPAD_ASSERT_UNKNOWN( i_var < numvar );
    277278                        reverse_cos_op(
    278279                                d, i_var, arg[0], J, Taylor, K, Partial
     
    282283
    283284                        case CoshOp:
    284                         CPPAD_ASSERT_UNKNOWN( i_var < numvar - 1 );
     285                        CPPAD_ASSERT_UNKNOWN( i_var < numvar );
    285286                        reverse_cosh_op(
    286287                                d, i_var, arg[0], J, Taylor, K, Partial
     
    372373                        // --------------------------------------------------
    373374
    374                         case NonOp:
    375                         break;
    376                         // --------------------------------------------------
    377 
    378375                        case ParOp:
    379376                        break;
     
    415412
    416413                        case SinOp:
    417                         CPPAD_ASSERT_UNKNOWN( i_var < numvar - 1 );
     414                        CPPAD_ASSERT_UNKNOWN( i_var < numvar );
    418415                        reverse_sin_op(
    419416                                d, i_var, arg[0], J, Taylor, K, Partial
     
    423420
    424421                        case SinhOp:
    425                         CPPAD_ASSERT_UNKNOWN( i_var < numvar - 1 );
     422                        CPPAD_ASSERT_UNKNOWN( i_var < numvar );
    426423                        reverse_sinh_op(
    427424                                d, i_var, arg[0], J, Taylor, K, Partial
     
    484481# endif
    485482        CPPAD_ASSERT_UNKNOWN( i_op == 1 );
    486         CPPAD_ASSERT_UNKNOWN( Rec->GetOp(i_op-1) == NonOp );
    487         CPPAD_ASSERT_UNKNOWN( i_var == NumRes(NonOp)  );
     483        CPPAD_ASSERT_UNKNOWN( Rec->GetOp(i_op-1) == BeginOp );
     484        CPPAD_ASSERT_UNKNOWN( i_var == NumRes(BeginOp)  );
    488485}
    489486
  • trunk/cppad/local/sin_op.hpp

    r1447 r1588  
    4949        CPPAD_ASSERT_UNKNOWN( NumArg(SinOp) == 1 );
    5050        CPPAD_ASSERT_UNKNOWN( NumRes(SinOp) == 2 );
    51         CPPAD_ASSERT_UNKNOWN( i_x < i_z );
     51        CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
    5252        CPPAD_ASSERT_UNKNOWN( j < nc_taylor );
    5353
     
    5555        Base* x = taylor + i_x * nc_taylor;
    5656        Base* s = taylor + i_z * nc_taylor;
    57         Base* c = s      +       nc_taylor;
     57        Base* c = s      -       nc_taylor;
    5858
    5959        // rest of this routine is identical for the following cases:
     
    103103        CPPAD_ASSERT_UNKNOWN( NumArg(SinOp) == 1 );
    104104        CPPAD_ASSERT_UNKNOWN( NumRes(SinOp) == 2 );
    105         CPPAD_ASSERT_UNKNOWN( i_x < i_z );
     105        CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
    106106        CPPAD_ASSERT_UNKNOWN( 0 < nc_taylor );
    107107
     
    109109        Base* x = taylor + i_x * nc_taylor;
    110110        Base* s = taylor + i_z * nc_taylor;  // called z in documentation
    111         Base* c = s      +       nc_taylor;  // called y in documentation
     111        Base* c = s      -       nc_taylor;  // called y in documentation
    112112
    113113        s[0] = sin( x[0] );
     
    144144        CPPAD_ASSERT_UNKNOWN( NumArg(SinOp) == 1 );
    145145        CPPAD_ASSERT_UNKNOWN( NumRes(SinOp) == 2 );
    146         CPPAD_ASSERT_UNKNOWN( i_x < i_z );
     146        CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
    147147        CPPAD_ASSERT_UNKNOWN( d < nc_taylor );
    148148        CPPAD_ASSERT_UNKNOWN( d < nc_partial );
     
    157157
    158158        // Taylor coefficients and partials corresponding to auxillary result
    159         const Base* c  = s  + nc_taylor; // called y in documentation
    160         Base* pc       = ps + nc_partial;
     159        const Base* c  = s  - nc_taylor; // called y in documentation
     160        Base* pc       = ps - nc_partial;
    161161
    162162        // rest of this routine is identical for the following cases:
  • trunk/cppad/local/sinh_op.hpp

    r1460 r1588  
    4949        CPPAD_ASSERT_UNKNOWN( NumArg(SinhOp) == 1 );
    5050        CPPAD_ASSERT_UNKNOWN( NumRes(SinhOp) == 2 );
    51         CPPAD_ASSERT_UNKNOWN( i_x < i_z );
     51        CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
    5252        CPPAD_ASSERT_UNKNOWN( j < nc_taylor );
    5353
     
    5555        Base* x = taylor + i_x * nc_taylor;
    5656        Base* s = taylor + i_z * nc_taylor;
    57         Base* c = s      +       nc_taylor;
     57        Base* c = s      -       nc_taylor;
    5858
    5959
     
    103103        CPPAD_ASSERT_UNKNOWN( NumArg(SinhOp) == 1 );
    104104        CPPAD_ASSERT_UNKNOWN( NumRes(SinhOp) == 2 );
    105         CPPAD_ASSERT_UNKNOWN( i_x < i_z );
     105        CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
    106106        CPPAD_ASSERT_UNKNOWN( 0 < nc_taylor );
    107107
     
    109109        Base* x = taylor + i_x * nc_taylor;
    110110        Base* s = taylor + i_z * nc_taylor;  // called z in documentation
    111         Base* c = s      +       nc_taylor;  // called y in documentation
     111        Base* c = s      -       nc_taylor;  // called y in documentation
    112112
    113113        s[0] = sinh( x[0] );
     
    143143        CPPAD_ASSERT_UNKNOWN( NumArg(SinhOp) == 1 );
    144144        CPPAD_ASSERT_UNKNOWN( NumRes(SinhOp) == 2 );
    145         CPPAD_ASSERT_UNKNOWN( i_x < i_z );
     145        CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
    146146        CPPAD_ASSERT_UNKNOWN( d < nc_taylor );
    147147        CPPAD_ASSERT_UNKNOWN( d < nc_partial );
     
    156156
    157157        // Taylor coefficients and partials corresponding to auxillary result
    158         const Base* c  = s  + nc_taylor; // called y in documentation
    159         Base* pc       = ps + nc_partial;
     158        const Base* c  = s  - nc_taylor; // called y in documentation
     159        Base* pc       = ps - nc_partial;
    160160
    161161        // rest of this routine is identical for the following cases:
  • trunk/cppad/local/sparse_pack.hpp

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • trunk/cppad/local/sparse_set.hpp

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • trunk/cppad/local/sparse_unary_op.hpp

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • trunk/cppad/local/store_op.hpp

    r1529 r1588  
    8080        CPPAD_ASSERT_UNKNOWN( 0 < arg[0] );
    8181        CPPAD_ASSERT_UNKNOWN( arg[0] + i_vec < nc_combined );
    82         CPPAD_ASSERT_UNKNOWN( arg[2] < i_z );
     82        CPPAD_ASSERT_UNKNOWN( arg[2] <= i_z );
    8383
    8484        variable[ arg[0] + i_vec ] = true;
     
    102102        size_t*        combined    )
    103103{       
    104         CPPAD_ASSERT_UNKNOWN( arg[1] < i_z );
     104        CPPAD_ASSERT_UNKNOWN( arg[1] <= i_z );
    105105        size_t i_vec = Integer( taylor[ arg[1] * nc_taylor + 0 ] );
    106106        CPPAD_ASSERT_KNOWN(
     
    137137        size_t*        combined    )
    138138{       
    139         CPPAD_ASSERT_UNKNOWN( arg[1] < i_z );
     139        CPPAD_ASSERT_UNKNOWN( arg[1] <= i_z );
    140140        size_t i_vec = Integer( taylor[ arg[1] * nc_taylor + 0 ] );
    141141        CPPAD_ASSERT_KNOWN(
     
    150150        CPPAD_ASSERT_UNKNOWN( 0 < arg[0] );
    151151        CPPAD_ASSERT_UNKNOWN( arg[0] + i_vec < nc_combined );
    152         CPPAD_ASSERT_UNKNOWN( arg[2] < i_z );
     152        CPPAD_ASSERT_UNKNOWN( arg[2] <= i_z );
    153153
    154154        variable[ arg[0] + i_vec ] = true;
  • trunk/cppad/speed/det_by_lu.hpp

    r1369 r1588  
    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
  • trunk/ipopt_cppad/ipopt_get_started.cpp

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • trunk/ipopt_cppad/ipopt_ode_check.cpp

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • trunk/svn_merge.sh

    r1550 r1588  
    2424#
    2525# Name of the directory where the changes have been committed
    26 from_branch=branches/sparsity
     26from_branch=branches/multiple_result
    2727#
    2828# Version of the repository corresponding to from_branch just before changes
    29 Start=1540
     29Start=1583
    3030#
    3131# Version of the repository corresponding to from_branch after the changes
    32 End=1549
     32End=1587
    3333#
    3434# the svn merge command
  • trunk/test_more/for_sparse_jac.cpp

    r1550 r1588  
    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;
  • trunk/test_more/rev_sparse_hes.cpp

    r1579 r1588  
    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                        }
  • trunk/test_more/rev_sparse_jac.cpp

    r1550 r1588  
    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.