Changeset 2918


Ignore:
Timestamp:
Oct 11, 2013 12:33:33 AM (7 years ago)
Author:
bradbell
Message:

Use replace_html.py to convert doxygen copydetail commands to work for a
subset of the total parameters in a function.

replace_html.py: new routine that copies doxygen commands.
cond_op.hpp: put replace_html.py commands and results here.
prototype_op.hpp: move cond_op prototypes to cond_op.hpp.

Location:
trunk
Files:
1 added
2 edited

Legend:

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

    r2910 r2918  
    2222
    2323/*!
     24Common documentation for conditional expressions forward and reverse mode.
     25
     26<!-- define conditional_exp_op -->
     27The C++ source code coresponding to this operation is
     28\verbatim
     29        z = CondExpRel(y_0, y_1, y_2, y_3)
     30\endverbatim
     31where Rel is one of the following: Lt, Le, Eq, Ge, Gt.
     32
     33\tparam Base
     34base type for the operator; i.e., this operation was recorded
     35using AD< \a Base > and computations by this routine are done using type
     36\a Base.
     37
     38\param i_z
     39is the AD variable index corresponding to the variable z.
     40
     41\param arg
     42\n
     43\a arg[0]
     44is static cast to size_t from the enum type
     45\verbatim
     46        enum CompareOp {
     47                CompareLt,
     48                CompareLe,
     49                CompareEq,
     50                CompareGe,
     51                CompareGt,
     52                CompareNe
     53        }
     54\endverbatim
     55for this operation.
     56Note that arg[0] cannot be equal to CompareNe.
     57\n
     58\n
     59\a arg[1] & 1
     60\n
     61If this is zero, y_0 is a parameter. Otherwise it is a variable.
     62\n
     63\n
     64\a arg[1] & 2
     65\n
     66If this is zero, y_1 is a parameter. Otherwise it is a variable.
     67\n
     68\n
     69\a arg[1] & 4
     70\n
     71If this is zero, y_2 is a parameter. Otherwise it is a variable.
     72\n
     73\n
     74\a arg[1] & 8
     75\n
     76If this is zero, y_3 is a parameter. Otherwise it is a variable.
     77\n
     78\n
     79\a arg[2 + j ] for j = 0, 1, 2, 3
     80\n
     81is the index corresponding to y_j.
     82
     83\param num_par
     84is the total number of values in the vector \a parameter.
     85
     86\param parameter
     87For j = 0, 1, 2, 3,
     88if y_j is a parameter, \a parameter [ arg[2 + j] ] is its value.
     89
     90\param nc_taylor
     91number of columns in the matrix containing the Taylor coefficients.
     92
     93\par Checked Assertions
     94\li NumArg(CExpOp) == 6
     95\li NumRes(CExpOp) == 1
     96\li arg[0] < static_cast<size_t> ( CompareNe )
     97\li arg[1] != 0; i.e., not all of y_0, y_1, y_2, y_3 are parameters.
     98\li For j = 0, 1, 2, 3 if y_j is a parameter, arg[2+j] < num_par.
     99\li For j = 0, 1, 2, 3 if y_j is a variable, arg[2+j] < iz.
     100<!-- end conditional_exp_op -->
     101*/
     102template <class Base>
     103inline void conditional_exp_op(
     104        size_t         i_z         ,
     105        const addr_t*  arg         ,
     106        size_t         num_par     ,
     107        const Base*    parameter   ,
     108        size_t         nc_taylor   )
     109{       // This routine is only for documentation, it should never be used
     110        CPPAD_ASSERT_UNKNOWN( false );
     111}
     112
     113/*!
     114Common documentation for conditional expression sparse operations.
     115
     116<!-- define sparse_conditional_exp_op -->
     117The C++ source code coresponding to this operation is
     118\verbatim
     119        z = CondExpRel(y_0, y_1, y_2, y_3)
     120\endverbatim
     121where Rel is one of the following: Lt, Le, Eq, Ge, Gt.
     122
     123\tparam Vector_set
     124is the type used for vectors of sets. It can be either
     125\c sparse_pack, \c sparse_set, or \c sparse_list.
     126
     127\param i_z
     128is the AD variable index corresponding to the variable z.
     129
     130\param arg
     131\n
     132\a arg[0]
     133is static cast to size_t from the enum type
     134\verbatim
     135        enum CompareOp {
     136                CompareLt,
     137                CompareLe,
     138                CompareEq,
     139                CompareGe,
     140                CompareGt,
     141                CompareNe
     142        }
     143\endverbatim
     144for this operation.
     145Note that arg[0] cannot be equal to CompareNe.
     146\n
     147\n
     148\a arg[1] & 1
     149\n
     150If this is zero, y_0 is a parameter. Otherwise it is a variable.
     151\n
     152\n
     153\a arg[1] & 2
     154\n
     155If this is zero, y_1 is a parameter. Otherwise it is a variable.
     156\n
     157\n
     158\a arg[1] & 4
     159\n
     160If this is zero, y_2 is a parameter. Otherwise it is a variable.
     161\n
     162\n
     163\a arg[1] & 8
     164\n
     165If this is zero, y_3 is a parameter. Otherwise it is a variable.
     166\n
     167\n
     168\a arg[2 + j ] for j = 0, 1, 2, 3
     169\n
     170is the index corresponding to y_j.
     171
     172\param num_par
     173is the total number of values in the vector \a parameter.
     174
     175\par Checked Assertions
     176\li NumArg(CExpOp) == 6
     177\li NumRes(CExpOp) == 1
     178\li arg[0] < static_cast<size_t> ( CompareNe )
     179\li arg[1] != 0; i.e., not all of y_0, y_1, y_2, y_3 are parameters.
     180\li For j = 0, 1, 2, 3 if y_j is a parameter, arg[2+j] < num_par.
     181\li For j = 0, 1, 2, 3 if y_j is a variable, arg[2+j] < iz.
     182<!-- end sparse_conditional_exp_op -->
     183*/
     184template <class Vector_set>
     185inline void sparse_conditional_exp_op(
     186        size_t         i_z           ,
     187        const addr_t*  arg           ,
     188        size_t         num_par       )
     189{       // This routine is only for documentation, it should never be used
     190        CPPAD_ASSERT_UNKNOWN( false );
     191}
     192
     193/*!
    24194Compute forward mode Taylor coefficients for op = CExpOp.
    25195
    26 \copydetails conditional_exp_op
     196<!-- replace conditional_exp_op -->
     197The C++ source code coresponding to this operation is
     198\verbatim
     199        z = CondExpRel(y_0, y_1, y_2, y_3)
     200\endverbatim
     201where Rel is one of the following: Lt, Le, Eq, Ge, Gt.
     202
     203\tparam Base
     204base type for the operator; i.e., this operation was recorded
     205using AD< \a Base > and computations by this routine are done using type
     206\a Base.
     207
     208\param i_z
     209is the AD variable index corresponding to the variable z.
     210
     211\param arg
     212\n
     213\a arg[0]
     214is static cast to size_t from the enum type
     215\verbatim
     216        enum CompareOp {
     217                CompareLt,
     218                CompareLe,
     219                CompareEq,
     220                CompareGe,
     221                CompareGt,
     222                CompareNe
     223        }
     224\endverbatim
     225for this operation.
     226Note that arg[0] cannot be equal to CompareNe.
     227\n
     228\n
     229\a arg[1] & 1
     230\n
     231If this is zero, y_0 is a parameter. Otherwise it is a variable.
     232\n
     233\n
     234\a arg[1] & 2
     235\n
     236If this is zero, y_1 is a parameter. Otherwise it is a variable.
     237\n
     238\n
     239\a arg[1] & 4
     240\n
     241If this is zero, y_2 is a parameter. Otherwise it is a variable.
     242\n
     243\n
     244\a arg[1] & 8
     245\n
     246If this is zero, y_3 is a parameter. Otherwise it is a variable.
     247\n
     248\n
     249\a arg[2 + j ] for j = 0, 1, 2, 3
     250\n
     251is the index corresponding to y_j.
     252
     253\param num_par
     254is the total number of values in the vector \a parameter.
     255
     256\param parameter
     257For j = 0, 1, 2, 3,
     258if y_j is a parameter, \a parameter [ arg[2 + j] ] is its value.
     259
     260\param nc_taylor
     261number of columns in the matrix containing the Taylor coefficients.
     262
     263\par Checked Assertions
     264\li NumArg(CExpOp) == 6
     265\li NumRes(CExpOp) == 1
     266\li arg[0] < static_cast<size_t> ( CompareNe )
     267\li arg[1] != 0; i.e., not all of y_0, y_1, y_2, y_3 are parameters.
     268\li For j = 0, 1, 2, 3 if y_j is a parameter, arg[2+j] < num_par.
     269\li For j = 0, 1, 2, 3 if y_j is a variable, arg[2+j] < iz.
     270<!-- end conditional_exp_op -->
    27271
    28272\param q
     
    134378Compute zero order forward mode Taylor coefficients for op = CExpOp.
    135379
    136 \copydetails conditional_exp_op
     380<!-- replace conditional_exp_op -->
     381The C++ source code coresponding to this operation is
     382\verbatim
     383        z = CondExpRel(y_0, y_1, y_2, y_3)
     384\endverbatim
     385where Rel is one of the following: Lt, Le, Eq, Ge, Gt.
     386
     387\tparam Base
     388base type for the operator; i.e., this operation was recorded
     389using AD< \a Base > and computations by this routine are done using type
     390\a Base.
     391
     392\param i_z
     393is the AD variable index corresponding to the variable z.
     394
     395\param arg
     396\n
     397\a arg[0]
     398is static cast to size_t from the enum type
     399\verbatim
     400        enum CompareOp {
     401                CompareLt,
     402                CompareLe,
     403                CompareEq,
     404                CompareGe,
     405                CompareGt,
     406                CompareNe
     407        }
     408\endverbatim
     409for this operation.
     410Note that arg[0] cannot be equal to CompareNe.
     411\n
     412\n
     413\a arg[1] & 1
     414\n
     415If this is zero, y_0 is a parameter. Otherwise it is a variable.
     416\n
     417\n
     418\a arg[1] & 2
     419\n
     420If this is zero, y_1 is a parameter. Otherwise it is a variable.
     421\n
     422\n
     423\a arg[1] & 4
     424\n
     425If this is zero, y_2 is a parameter. Otherwise it is a variable.
     426\n
     427\n
     428\a arg[1] & 8
     429\n
     430If this is zero, y_3 is a parameter. Otherwise it is a variable.
     431\n
     432\n
     433\a arg[2 + j ] for j = 0, 1, 2, 3
     434\n
     435is the index corresponding to y_j.
     436
     437\param num_par
     438is the total number of values in the vector \a parameter.
     439
     440\param parameter
     441For j = 0, 1, 2, 3,
     442if y_j is a parameter, \a parameter [ arg[2 + j] ] is its value.
     443
     444\param nc_taylor
     445number of columns in the matrix containing the Taylor coefficients.
     446
     447\par Checked Assertions
     448\li NumArg(CExpOp) == 6
     449\li NumRes(CExpOp) == 1
     450\li arg[0] < static_cast<size_t> ( CompareNe )
     451\li arg[1] != 0; i.e., not all of y_0, y_1, y_2, y_3 are parameters.
     452\li For j = 0, 1, 2, 3 if y_j is a parameter, arg[2+j] < num_par.
     453\li For j = 0, 1, 2, 3 if y_j is a variable, arg[2+j] < iz.
     454<!-- end conditional_exp_op -->
    137455
    138456\param taylor
     
    208526Compute reverse mode Taylor coefficients for op = CExpOp.
    209527
    210 \copydetails conditional_exp_op
    211 
    212528This routine is given the partial derivatives of a function
    213529G( z , y , x , w , ... )
     
    217533\endverbatim
    218534where y above represents y_0, y_1, y_2, y_3.
     535
     536<!-- replace conditional_exp_op -->
     537The C++ source code coresponding to this operation is
     538\verbatim
     539        z = CondExpRel(y_0, y_1, y_2, y_3)
     540\endverbatim
     541where Rel is one of the following: Lt, Le, Eq, Ge, Gt.
     542
     543\tparam Base
     544base type for the operator; i.e., this operation was recorded
     545using AD< \a Base > and computations by this routine are done using type
     546\a Base.
     547
     548\param i_z
     549is the AD variable index corresponding to the variable z.
     550
     551\param arg
     552\n
     553\a arg[0]
     554is static cast to size_t from the enum type
     555\verbatim
     556        enum CompareOp {
     557                CompareLt,
     558                CompareLe,
     559                CompareEq,
     560                CompareGe,
     561                CompareGt,
     562                CompareNe
     563        }
     564\endverbatim
     565for this operation.
     566Note that arg[0] cannot be equal to CompareNe.
     567\n
     568\n
     569\a arg[1] & 1
     570\n
     571If this is zero, y_0 is a parameter. Otherwise it is a variable.
     572\n
     573\n
     574\a arg[1] & 2
     575\n
     576If this is zero, y_1 is a parameter. Otherwise it is a variable.
     577\n
     578\n
     579\a arg[1] & 4
     580\n
     581If this is zero, y_2 is a parameter. Otherwise it is a variable.
     582\n
     583\n
     584\a arg[1] & 8
     585\n
     586If this is zero, y_3 is a parameter. Otherwise it is a variable.
     587\n
     588\n
     589\a arg[2 + j ] for j = 0, 1, 2, 3
     590\n
     591is the index corresponding to y_j.
     592
     593\param num_par
     594is the total number of values in the vector \a parameter.
     595
     596\param parameter
     597For j = 0, 1, 2, 3,
     598if y_j is a parameter, \a parameter [ arg[2 + j] ] is its value.
     599
     600\param nc_taylor
     601number of columns in the matrix containing the Taylor coefficients.
     602
     603\par Checked Assertions
     604\li NumArg(CExpOp) == 6
     605\li NumRes(CExpOp) == 1
     606\li arg[0] < static_cast<size_t> ( CompareNe )
     607\li arg[1] != 0; i.e., not all of y_0, y_1, y_2, y_3 are parameters.
     608\li For j = 0, 1, 2, 3 if y_j is a parameter, arg[2+j] < num_par.
     609\li For j = 0, 1, 2, 3 if y_j is a variable, arg[2+j] < iz.
     610<!-- end conditional_exp_op -->
    219611
    220612\param d
     
    329721Compute forward Jacobian sparsity patterns for op = CExpOp.
    330722
    331 \copydetails sparse_conditional_exp_op
     723<!-- replace sparse_conditional_exp_op -->
     724The C++ source code coresponding to this operation is
     725\verbatim
     726        z = CondExpRel(y_0, y_1, y_2, y_3)
     727\endverbatim
     728where Rel is one of the following: Lt, Le, Eq, Ge, Gt.
     729
     730\tparam Vector_set
     731is the type used for vectors of sets. It can be either
     732\c sparse_pack, \c sparse_set, or \c sparse_list.
     733
     734\param i_z
     735is the AD variable index corresponding to the variable z.
     736
     737\param arg
     738\n
     739\a arg[0]
     740is static cast to size_t from the enum type
     741\verbatim
     742        enum CompareOp {
     743                CompareLt,
     744                CompareLe,
     745                CompareEq,
     746                CompareGe,
     747                CompareGt,
     748                CompareNe
     749        }
     750\endverbatim
     751for this operation.
     752Note that arg[0] cannot be equal to CompareNe.
     753\n
     754\n
     755\a arg[1] & 1
     756\n
     757If this is zero, y_0 is a parameter. Otherwise it is a variable.
     758\n
     759\n
     760\a arg[1] & 2
     761\n
     762If this is zero, y_1 is a parameter. Otherwise it is a variable.
     763\n
     764\n
     765\a arg[1] & 4
     766\n
     767If this is zero, y_2 is a parameter. Otherwise it is a variable.
     768\n
     769\n
     770\a arg[1] & 8
     771\n
     772If this is zero, y_3 is a parameter. Otherwise it is a variable.
     773\n
     774\n
     775\a arg[2 + j ] for j = 0, 1, 2, 3
     776\n
     777is the index corresponding to y_j.
     778
     779\param num_par
     780is the total number of values in the vector \a parameter.
     781
     782\par Checked Assertions
     783\li NumArg(CExpOp) == 6
     784\li NumRes(CExpOp) == 1
     785\li arg[0] < static_cast<size_t> ( CompareNe )
     786\li arg[1] != 0; i.e., not all of y_0, y_1, y_2, y_3 are parameters.
     787\li For j = 0, 1, 2, 3 if y_j is a parameter, arg[2+j] < num_par.
     788\li For j = 0, 1, 2, 3 if y_j is a variable, arg[2+j] < iz.
     789<!-- end sparse_conditional_exp_op -->
    332790
    333791\param sparsity
     
    412870where y represents the combination of y_0, y_1, y_2, and y_3.
    413871
    414 \copydetails sparse_conditional_exp_op
     872<!-- replace sparse_conditional_exp_op -->
     873The C++ source code coresponding to this operation is
     874\verbatim
     875        z = CondExpRel(y_0, y_1, y_2, y_3)
     876\endverbatim
     877where Rel is one of the following: Lt, Le, Eq, Ge, Gt.
     878
     879\tparam Vector_set
     880is the type used for vectors of sets. It can be either
     881\c sparse_pack, \c sparse_set, or \c sparse_list.
     882
     883\param i_z
     884is the AD variable index corresponding to the variable z.
     885
     886\param arg
     887\n
     888\a arg[0]
     889is static cast to size_t from the enum type
     890\verbatim
     891        enum CompareOp {
     892                CompareLt,
     893                CompareLe,
     894                CompareEq,
     895                CompareGe,
     896                CompareGt,
     897                CompareNe
     898        }
     899\endverbatim
     900for this operation.
     901Note that arg[0] cannot be equal to CompareNe.
     902\n
     903\n
     904\a arg[1] & 1
     905\n
     906If this is zero, y_0 is a parameter. Otherwise it is a variable.
     907\n
     908\n
     909\a arg[1] & 2
     910\n
     911If this is zero, y_1 is a parameter. Otherwise it is a variable.
     912\n
     913\n
     914\a arg[1] & 4
     915\n
     916If this is zero, y_2 is a parameter. Otherwise it is a variable.
     917\n
     918\n
     919\a arg[1] & 8
     920\n
     921If this is zero, y_3 is a parameter. Otherwise it is a variable.
     922\n
     923\n
     924\a arg[2 + j ] for j = 0, 1, 2, 3
     925\n
     926is the index corresponding to y_j.
     927
     928\param num_par
     929is the total number of values in the vector \a parameter.
     930
     931\par Checked Assertions
     932\li NumArg(CExpOp) == 6
     933\li NumRes(CExpOp) == 1
     934\li arg[0] < static_cast<size_t> ( CompareNe )
     935\li arg[1] != 0; i.e., not all of y_0, y_1, y_2, y_3 are parameters.
     936\li For j = 0, 1, 2, 3 if y_j is a parameter, arg[2+j] < num_par.
     937\li For j = 0, 1, 2, 3 if y_j is a variable, arg[2+j] < iz.
     938<!-- end sparse_conditional_exp_op -->
    415939
    416940
     
    4891013where y represents the combination of y_0, y_1, y_2, and y_3.
    4901014
    491 \copydetails sparse_conditional_exp_op
     1015<!-- replace sparse_conditional_exp_op -->
     1016The C++ source code coresponding to this operation is
     1017\verbatim
     1018        z = CondExpRel(y_0, y_1, y_2, y_3)
     1019\endverbatim
     1020where Rel is one of the following: Lt, Le, Eq, Ge, Gt.
     1021
     1022\tparam Vector_set
     1023is the type used for vectors of sets. It can be either
     1024\c sparse_pack, \c sparse_set, or \c sparse_list.
     1025
     1026\param i_z
     1027is the AD variable index corresponding to the variable z.
     1028
     1029\param arg
     1030\n
     1031\a arg[0]
     1032is static cast to size_t from the enum type
     1033\verbatim
     1034        enum CompareOp {
     1035                CompareLt,
     1036                CompareLe,
     1037                CompareEq,
     1038                CompareGe,
     1039                CompareGt,
     1040                CompareNe
     1041        }
     1042\endverbatim
     1043for this operation.
     1044Note that arg[0] cannot be equal to CompareNe.
     1045\n
     1046\n
     1047\a arg[1] & 1
     1048\n
     1049If this is zero, y_0 is a parameter. Otherwise it is a variable.
     1050\n
     1051\n
     1052\a arg[1] & 2
     1053\n
     1054If this is zero, y_1 is a parameter. Otherwise it is a variable.
     1055\n
     1056\n
     1057\a arg[1] & 4
     1058\n
     1059If this is zero, y_2 is a parameter. Otherwise it is a variable.
     1060\n
     1061\n
     1062\a arg[1] & 8
     1063\n
     1064If this is zero, y_3 is a parameter. Otherwise it is a variable.
     1065\n
     1066\n
     1067\a arg[2 + j ] for j = 0, 1, 2, 3
     1068\n
     1069is the index corresponding to y_j.
     1070
     1071\param num_par
     1072is the total number of values in the vector \a parameter.
     1073
     1074\par Checked Assertions
     1075\li NumArg(CExpOp) == 6
     1076\li NumRes(CExpOp) == 1
     1077\li arg[0] < static_cast<size_t> ( CompareNe )
     1078\li arg[1] != 0; i.e., not all of y_0, y_1, y_2, y_3 are parameters.
     1079\li For j = 0, 1, 2, 3 if y_j is a parameter, arg[2+j] < num_par.
     1080\li For j = 0, 1, 2, 3 if y_j is a variable, arg[2+j] < iz.
     1081<!-- end sparse_conditional_exp_op -->
    4921082
    4931083
  • trunk/cppad/local/prototype_op.hpp

    r2910 r2918  
    14851485}
    14861486
    1487 // ==================== Conditional Expressions ============================
    1488 /*!
    1489 Common documentation for conditional expressions forward and reverse mode.
    1490 
    1491 The C++ source code coresponding to this operation is
    1492 \verbatim
    1493         z = CondExpRel(y_0, y_1, y_2, y_3)
    1494 \endverbatim
    1495 where Rel is one of the following: Lt, Le, Eq, Ge, Gt.
    1496 
    1497 \tparam Base
    1498 base type for the operator; i.e., this operation was recorded
    1499 using AD< \a Base > and computations by this routine are done using type
    1500 \a Base.
    1501 
    1502 \param i_z
    1503 is the AD variable index corresponding to the variable z.
    1504 
    1505 \param arg
    1506 \n
    1507 \a arg[0]
    1508 is static cast to size_t from the enum type
    1509 \verbatim
    1510         enum CompareOp {
    1511                 CompareLt,
    1512                 CompareLe,
    1513                 CompareEq,
    1514                 CompareGe,
    1515                 CompareGt,
    1516                 CompareNe
    1517         }
    1518 \endverbatim
    1519 for this operation.
    1520 Note that arg[0] cannot be equal to CompareNe.
    1521 \n
    1522 \n
    1523 \a arg[1] & 1
    1524 \n
    1525 If this is zero, y_0 is a parameter. Otherwise it is a variable.
    1526 \n
    1527 \n
    1528 \a arg[1] & 2
    1529 \n
    1530 If this is zero, y_1 is a parameter. Otherwise it is a variable.
    1531 \n
    1532 \n
    1533 \a arg[1] & 4
    1534 \n
    1535 If this is zero, y_2 is a parameter. Otherwise it is a variable.
    1536 \n
    1537 \n
    1538 \a arg[1] & 8
    1539 \n
    1540 If this is zero, y_3 is a parameter. Otherwise it is a variable.
    1541 \n
    1542 \n
    1543 \a arg[2 + j ] for j = 0, 1, 2, 3
    1544 \n
    1545 is the index corresponding to y_j.
    1546 
    1547 \param num_par
    1548 is the total number of values in the vector \a parameter.
    1549 
    1550 \param parameter
    1551 For j = 0, 1, 2, 3,
    1552 if y_j is a parameter, \a parameter [ arg[2 + j] ] is its value.
    1553 
    1554 \param nc_taylor
    1555 number of columns in the matrix containing the Taylor coefficients.
    1556 
    1557 \par Checked Assertions
    1558 \li NumArg(CExpOp) == 6
    1559 \li NumRes(CExpOp) == 1
    1560 \li arg[0] < static_cast<size_t> ( CompareNe )
    1561 \li arg[1] != 0; i.e., not all of y_0, y_1, y_2, y_3 are parameters.
    1562 \li For j = 0, 1, 2, 3 if y_j is a parameter, arg[2+j] < num_par.
    1563 \li For j = 0, 1, 2, 3 if y_j is a variable, arg[2+j] < iz.
    1564 */
    1565 template <class Base>
    1566 inline void conditional_exp_op(
    1567         size_t         i_z         ,
    1568         const addr_t*  arg         ,
    1569         size_t         num_par     ,
    1570         const Base*    parameter   ,
    1571         size_t         nc_taylor   )
    1572 {       // This routine is only for documentation, it should never be used
    1573         CPPAD_ASSERT_UNKNOWN( false );
    1574 }
    1575 
    1576 /*!
    1577 Common documentation for conditional expression sparse operations.
    1578 
    1579 The C++ source code coresponding to this operation is
    1580 \verbatim
    1581         z = CondExpRel(y_0, y_1, y_2, y_3)
    1582 \endverbatim
    1583 where Rel is one of the following: Lt, Le, Eq, Ge, Gt.
    1584 
    1585 \tparam Vector_set
    1586 is the type used for vectors of sets. It can be either
    1587 \c sparse_pack, \c sparse_set, or \c sparse_list.
    1588 
    1589 \param i_z
    1590 is the AD variable index corresponding to the variable z.
    1591 
    1592 \param arg
    1593 \n
    1594 \a arg[0]
    1595 is static cast to size_t from the enum type
    1596 \verbatim
    1597         enum CompareOp {
    1598                 CompareLt,
    1599                 CompareLe,
    1600                 CompareEq,
    1601                 CompareGe,
    1602                 CompareGt,
    1603                 CompareNe
    1604         }
    1605 \endverbatim
    1606 for this operation.
    1607 Note that arg[0] cannot be equal to CompareNe.
    1608 \n
    1609 \n
    1610 \a arg[1] & 1
    1611 \n
    1612 If this is zero, y_0 is a parameter. Otherwise it is a variable.
    1613 \n
    1614 \n
    1615 \a arg[1] & 2
    1616 \n
    1617 If this is zero, y_1 is a parameter. Otherwise it is a variable.
    1618 \n
    1619 \n
    1620 \a arg[1] & 4
    1621 \n
    1622 If this is zero, y_2 is a parameter. Otherwise it is a variable.
    1623 \n
    1624 \n
    1625 \a arg[1] & 8
    1626 \n
    1627 If this is zero, y_3 is a parameter. Otherwise it is a variable.
    1628 \n
    1629 \n
    1630 \a arg[2 + j ] for j = 0, 1, 2, 3
    1631 \n
    1632 is the index corresponding to y_j.
    1633 
    1634 \param num_par
    1635 is the total number of values in the vector \a parameter.
    1636 
    1637 \par Checked Assertions
    1638 \li NumArg(CExpOp) == 6
    1639 \li NumRes(CExpOp) == 1
    1640 \li arg[0] < static_cast<size_t> ( CompareNe )
    1641 \li arg[1] != 0; i.e., not all of y_0, y_1, y_2, y_3 are parameters.
    1642 \li For j = 0, 1, 2, 3 if y_j is a parameter, arg[2+j] < num_par.
    1643 \li For j = 0, 1, 2, 3 if y_j is a variable, arg[2+j] < iz.
    1644 */
    1645 template <class Vector_set>
    1646 inline void sparse_conditional_exp_op(
    1647         size_t         i_z           ,
    1648         const addr_t*  arg           ,
    1649         size_t         num_par       )
    1650 {       // This routine is only for documentation, it should never be used
    1651         CPPAD_ASSERT_UNKNOWN( false );
    1652 }
    16531487
    16541488/*! \} */
Note: See TracChangeset for help on using the changeset viewer.