Changeset 2920


Ignore:
Timestamp:
Oct 11, 2013 8:40:52 AM (6 years ago)
Author:
bradbell
Message:

cond_op.hpp: Change 'Common documentation' to 'Shared documentation'
load_op.hpp: Change 'Common documentation' to 'Shared documentation'
optimize.hpp: FIx copydetails.

Location:
trunk/cppad/local
Files:
3 edited

Legend:

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

    r2918 r2920  
    2222
    2323/*!
    24 Common documentation for conditional expressions forward and reverse mode.
     24Shared documentation for conditional expressions (not called).
    2525
    2626<!-- define conditional_exp_op -->
     
    112112
    113113/*!
    114 Common documentation for conditional expression sparse operations.
     114Shared documentation for conditional expression sparse operations (not called).
    115115
    116116<!-- define sparse_conditional_exp_op -->
  • trunk/cppad/local/load_op.hpp

    r2919 r2920  
    2424
    2525/*!
    26 Prototype for zero order forward mode implementation of op = LdpOp or LdvOp.
     26Shared documentation for zero order forward mode implementation of
     27op = LdpOp or LdvOp (not called).
    2728
    2829The C++ source code corresponding to this operation is
     
    142143}
    143144/*!
    144 Prototype sparsity operations corresponding to op = LdpOp or LdvOp.
     145Shared documentation for sparsity operations corresponding to
     146op = LdpOp or LdvOp (not called).
    145147
    146148<!-- define sparse_load_op -->
  • trunk/cppad/local/optimize.hpp

    r2910 r2920  
    221221
    222222/*!
    223 Documents arguments that are common to optimization helper functions
    224 (should not be called).
    225 
     223Shared documentation for optimization helper functions (not called).
     224
     225<!-- define optimize_prototype -->
    226226\param tape
    227227is a vector that maps a variable index, in the old operation sequence,
     
    268268given a parameter index \c i, the corresponding parameter value is
    269269<tt>par[i]</tt>.
     270<!-- end optimize_prototype -->
    270271*/
    271272template <class Base>
     
    283284can be used inplace of the result for current operator.
    284285
    285 \copydetails optimize_prototype
     286<!-- replace optimize_prototype -->
     287\param tape
     288is a vector that maps a variable index, in the old operation sequence,
     289to an <tt>optimize_old_variable</tt> information record.
     290Note that the index for this vector must be greater than or equal zero and
     291less than <tt>tape.size()</tt>.
     292
     293\li <tt>tape[i].op</tt>
     294is the operator in the old operation sequence
     295corresponding to the old variable index \c i.
     296Assertion: <tt>NumRes(tape[i].op) > 0</tt>.
     297
     298\li <tt>tape[i].arg</tt>
     299for <tt>j < NumArg( tape[i].op ), tape[i].arg[j]</tt>
     300is the j-th the argument, in the old operation sequence,
     301corresponding to the old variable index \c i.
     302Assertion: <tt>tape[i].arg[j] < i</tt>.
     303
     304\li <tt>tape[i].new_var</tt>
     305Suppose
     306<tt>i <= current, j < NumArg( tape[i].op ), and k = tape[i].arg[j]</tt>,
     307and \c j corresponds to a variable for operator <tt>tape[i].op</tt>.
     308It follows that <tt>tape[k].new_var</tt>
     309has alread been set to the variable in the new operation sequence
     310corresponding to the old variable index \c k.
     311This means that the \c new_var value has been set
     312for all the possible arguments that come before \a current.
     313
     314\param current
     315is the index in the old operation sequence for
     316the variable corresponding to the result for the current operator.
     317Assertions:
     318<tt>
     319current < tape.size(),
     320NumRes( tape[current].op ) > 0.
     321</tt>
     322
     323\param npar
     324is the number of parameters corresponding to this operation sequence.
     325
     326\param par
     327is a vector of length \a npar containing the parameters
     328for this operation sequence; i.e.,
     329given a parameter index \c i, the corresponding parameter value is
     330<tt>par[i]</tt>.
     331<!-- end optimize_prototype -->
    286332
    287333\param hash_table_var
     
    343389Check a binary operator for a complete match with a previous operator,
    344390
    345 \copydetails optimize_unary_match
     391<!-- replace optimize_prototype -->
     392\param tape
     393is a vector that maps a variable index, in the old operation sequence,
     394to an <tt>optimize_old_variable</tt> information record.
     395Note that the index for this vector must be greater than or equal zero and
     396less than <tt>tape.size()</tt>.
     397
     398\li <tt>tape[i].op</tt>
     399is the operator in the old operation sequence
     400corresponding to the old variable index \c i.
     401Assertion: <tt>NumRes(tape[i].op) > 0</tt>.
     402
     403\li <tt>tape[i].arg</tt>
     404for <tt>j < NumArg( tape[i].op ), tape[i].arg[j]</tt>
     405is the j-th the argument, in the old operation sequence,
     406corresponding to the old variable index \c i.
     407Assertion: <tt>tape[i].arg[j] < i</tt>.
     408
     409\li <tt>tape[i].new_var</tt>
     410Suppose
     411<tt>i <= current, j < NumArg( tape[i].op ), and k = tape[i].arg[j]</tt>,
     412and \c j corresponds to a variable for operator <tt>tape[i].op</tt>.
     413It follows that <tt>tape[k].new_var</tt>
     414has alread been set to the variable in the new operation sequence
     415corresponding to the old variable index \c k.
     416This means that the \c new_var value has been set
     417for all the possible arguments that come before \a current.
     418
     419\param current
     420is the index in the old operation sequence for
     421the variable corresponding to the result for the current operator.
     422Assertions:
     423<tt>
     424current < tape.size(),
     425NumRes( tape[current].op ) > 0.
     426</tt>
     427
     428\param npar
     429is the number of parameters corresponding to this operation sequence.
     430
     431\param par
     432is a vector of length \a npar containing the parameters
     433for this operation sequence; i.e.,
     434given a parameter index \c i, the corresponding parameter value is
     435<tt>par[i]</tt>.
     436<!-- end optimize_prototype -->
     437
     438\param hash_table_var
     439is a vector with size CPPAD_HASH_TABLE_SIZE
     440that maps a hash code to the corresponding
     441variable index in the old operation sequence.
     442All the values in this table must be less than \a current.
     443
     444\param code
     445The input value of code does not matter.
     446The output value of code is the hash code corresponding to
     447this operation in the new operation sequence.
     448
     449\return
     450If the return value is zero,
     451no match was found.
     452If the return value is greater than zero,
     453it is the index of a new variable that can be used to replace the
     454old variable.
     455
    346456
    347457\par Restrictions:
    348458The binary operator must be an addition, subtraction, multiplication, division
    349 or power operator.
     459or power operator.  NumArg( tape[current].op ) == 1.
    350460*/
    351461template <class Base>
     
    478588Record an operation of the form (parameter op variable).
    479589
    480 \copydetails optimize_prototype
     590<!-- replace optimize_prototype -->
     591\param tape
     592is a vector that maps a variable index, in the old operation sequence,
     593to an <tt>optimize_old_variable</tt> information record.
     594Note that the index for this vector must be greater than or equal zero and
     595less than <tt>tape.size()</tt>.
     596
     597\li <tt>tape[i].op</tt>
     598is the operator in the old operation sequence
     599corresponding to the old variable index \c i.
     600Assertion: <tt>NumRes(tape[i].op) > 0</tt>.
     601
     602\li <tt>tape[i].arg</tt>
     603for <tt>j < NumArg( tape[i].op ), tape[i].arg[j]</tt>
     604is the j-th the argument, in the old operation sequence,
     605corresponding to the old variable index \c i.
     606Assertion: <tt>tape[i].arg[j] < i</tt>.
     607
     608\li <tt>tape[i].new_var</tt>
     609Suppose
     610<tt>i <= current, j < NumArg( tape[i].op ), and k = tape[i].arg[j]</tt>,
     611and \c j corresponds to a variable for operator <tt>tape[i].op</tt>.
     612It follows that <tt>tape[k].new_var</tt>
     613has alread been set to the variable in the new operation sequence
     614corresponding to the old variable index \c k.
     615This means that the \c new_var value has been set
     616for all the possible arguments that come before \a current.
     617
     618\param current
     619is the index in the old operation sequence for
     620the variable corresponding to the result for the current operator.
     621Assertions:
     622<tt>
     623current < tape.size(),
     624NumRes( tape[current].op ) > 0.
     625</tt>
     626
     627\param npar
     628is the number of parameters corresponding to this operation sequence.
     629
     630\param par
     631is a vector of length \a npar containing the parameters
     632for this operation sequence; i.e.,
     633given a parameter index \c i, the corresponding parameter value is
     634<tt>par[i]</tt>.
     635<!-- end optimize_prototype -->
    481636
    482637\param rec
     
    532687Record an operation of the form (variable op parameter).
    533688
    534 \copydetails optimize_prototype
     689<!-- replace optimize_prototype -->
     690\param tape
     691is a vector that maps a variable index, in the old operation sequence,
     692to an <tt>optimize_old_variable</tt> information record.
     693Note that the index for this vector must be greater than or equal zero and
     694less than <tt>tape.size()</tt>.
     695
     696\li <tt>tape[i].op</tt>
     697is the operator in the old operation sequence
     698corresponding to the old variable index \c i.
     699Assertion: <tt>NumRes(tape[i].op) > 0</tt>.
     700
     701\li <tt>tape[i].arg</tt>
     702for <tt>j < NumArg( tape[i].op ), tape[i].arg[j]</tt>
     703is the j-th the argument, in the old operation sequence,
     704corresponding to the old variable index \c i.
     705Assertion: <tt>tape[i].arg[j] < i</tt>.
     706
     707\li <tt>tape[i].new_var</tt>
     708Suppose
     709<tt>i <= current, j < NumArg( tape[i].op ), and k = tape[i].arg[j]</tt>,
     710and \c j corresponds to a variable for operator <tt>tape[i].op</tt>.
     711It follows that <tt>tape[k].new_var</tt>
     712has alread been set to the variable in the new operation sequence
     713corresponding to the old variable index \c k.
     714This means that the \c new_var value has been set
     715for all the possible arguments that come before \a current.
     716
     717\param current
     718is the index in the old operation sequence for
     719the variable corresponding to the result for the current operator.
     720Assertions:
     721<tt>
     722current < tape.size(),
     723NumRes( tape[current].op ) > 0.
     724</tt>
     725
     726\param npar
     727is the number of parameters corresponding to this operation sequence.
     728
     729\param par
     730is a vector of length \a npar containing the parameters
     731for this operation sequence; i.e.,
     732given a parameter index \c i, the corresponding parameter value is
     733<tt>par[i]</tt>.
     734<!-- end optimize_prototype -->
    535735
    536736\param rec
     
    583783Record an operation of the form (variable op variable).
    584784
    585 \copydetails optimize_prototype
     785<!-- replace optimize_prototype -->
     786\param tape
     787is a vector that maps a variable index, in the old operation sequence,
     788to an <tt>optimize_old_variable</tt> information record.
     789Note that the index for this vector must be greater than or equal zero and
     790less than <tt>tape.size()</tt>.
     791
     792\li <tt>tape[i].op</tt>
     793is the operator in the old operation sequence
     794corresponding to the old variable index \c i.
     795Assertion: <tt>NumRes(tape[i].op) > 0</tt>.
     796
     797\li <tt>tape[i].arg</tt>
     798for <tt>j < NumArg( tape[i].op ), tape[i].arg[j]</tt>
     799is the j-th the argument, in the old operation sequence,
     800corresponding to the old variable index \c i.
     801Assertion: <tt>tape[i].arg[j] < i</tt>.
     802
     803\li <tt>tape[i].new_var</tt>
     804Suppose
     805<tt>i <= current, j < NumArg( tape[i].op ), and k = tape[i].arg[j]</tt>,
     806and \c j corresponds to a variable for operator <tt>tape[i].op</tt>.
     807It follows that <tt>tape[k].new_var</tt>
     808has alread been set to the variable in the new operation sequence
     809corresponding to the old variable index \c k.
     810This means that the \c new_var value has been set
     811for all the possible arguments that come before \a current.
     812
     813\param current
     814is the index in the old operation sequence for
     815the variable corresponding to the result for the current operator.
     816Assertions:
     817<tt>
     818current < tape.size(),
     819NumRes( tape[current].op ) > 0.
     820</tt>
     821
     822\param npar
     823is the number of parameters corresponding to this operation sequence.
     824
     825\param par
     826is a vector of length \a npar containing the parameters
     827for this operation sequence; i.e.,
     828given a parameter index \c i, the corresponding parameter value is
     829<tt>par[i]</tt>.
     830<!-- end optimize_prototype -->
    586831
    587832\param rec
     
    638883Recording a cummulative cummulative summation starting at its highest parrent.
    639884
    640 \copydetails optimize_prototype
     885<!-- replace optimize_prototype -->
     886\param tape
     887is a vector that maps a variable index, in the old operation sequence,
     888to an <tt>optimize_old_variable</tt> information record.
     889Note that the index for this vector must be greater than or equal zero and
     890less than <tt>tape.size()</tt>.
     891
     892\li <tt>tape[i].op</tt>
     893is the operator in the old operation sequence
     894corresponding to the old variable index \c i.
     895Assertion: <tt>NumRes(tape[i].op) > 0</tt>.
     896
     897\li <tt>tape[i].arg</tt>
     898for <tt>j < NumArg( tape[i].op ), tape[i].arg[j]</tt>
     899is the j-th the argument, in the old operation sequence,
     900corresponding to the old variable index \c i.
     901Assertion: <tt>tape[i].arg[j] < i</tt>.
     902
     903\li <tt>tape[i].new_var</tt>
     904Suppose
     905<tt>i <= current, j < NumArg( tape[i].op ), and k = tape[i].arg[j]</tt>,
     906and \c j corresponds to a variable for operator <tt>tape[i].op</tt>.
     907It follows that <tt>tape[k].new_var</tt>
     908has alread been set to the variable in the new operation sequence
     909corresponding to the old variable index \c k.
     910This means that the \c new_var value has been set
     911for all the possible arguments that come before \a current.
     912
     913\param current
     914is the index in the old operation sequence for
     915the variable corresponding to the result for the current operator.
     916Assertions:
     917<tt>
     918current < tape.size(),
     919NumRes( tape[current].op ) > 0.
     920</tt>
     921
     922\param npar
     923is the number of parameters corresponding to this operation sequence.
     924
     925\param par
     926is a vector of length \a npar containing the parameters
     927for this operation sequence; i.e.,
     928given a parameter index \c i, the corresponding parameter value is
     929<tt>par[i]</tt>.
     930<!-- end optimize_prototype -->
    641931
    642932\param rec
Note: See TracChangeset for help on using the changeset viewer.