Changeset 2921


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

Fix last of the doxygen 1.8.3 warnings corresponding to copdetails.

check_doxygen.sh: check for warnings when using version 1.8.3.
prototype_op.hpp: move two prototypes to store_op.hpp.
store_op.hpp: Fix copydetail warnings in this file.

Location:
trunk
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • trunk/bin/check_doxygen.sh

    r2870 r2921  
    4040        exit 0
    4141fi
    42 if (( $doxygen_version == 183 ))
    43 then
    44         doxygen_version=`doxygen --version`
    45         echo "doxygen version $doxygen_version is == 1.8.3"
    46         echo "Have not yet determined if this is a problem or not"
    47         exit 0
    48 fi
    4942list=`head doxygen.err`
    5043if [ "$list" == "" ]
  • trunk/cppad/local/prototype_op.hpp

    r2919 r2921  
    943943        CPPAD_ASSERT_UNKNOWN( false );
    944944}
    945 // ====================  VecAD Operations     ==============================
    946 /*!
    947 Prototype zero order forward implementation of op is one the following:
    948 StppOp, StpvOp, StvpOp, or StvvOp.
    949 
    950 The C++ source code corresponding to this operation is
    951 \verbatim
    952         v[x] = y
    953 \endverbatim
    954 where v is a VecAD<Base> vector, x is an AD<Base> object,
    955 and y is AD<Base> or Base objects.
    956 We define the index corresponding to v[x] by
    957 \verbatim
    958         i_v_x = combined[ arg[0] + i_vec ]
    959 \endverbatim
    960 where i_vec is defined under the heading \a arg[1] below:
    961 
    962 \tparam Base
    963 base type for the operator; i.e., this operation was recorded
    964 using AD< \a Base > and computations by this routine are done using type
    965 \a Base.
    966 
    967 \param i_z
    968 is the index corresponding to the previous variable on the tape
    969 (only used for error checking).
    970 
    971 \param arg
    972 \n
    973 \a arg[0]
    974 is the offset of this VecAD vector relative to the beginning
    975 of the \a combined VecAD array.
    976 \n
    977 \n
    978 \a arg[1]
    979 \n
    980 If this is a StppOp or StpvOp operation
    981 (the index x is a parameter), i_vec is defined by
    982 \verbatim
    983         i_vec = arg[1]
    984 \endverbatim
    985 If this is a StvpOp or StvvOp operation
    986 (the index x is a variable), i_vec is defined by
    987 \verbatim
    988         i_vec = floor( taylor[ arg[1] * nc_taylor + 0 ] )
    989 \endverbatim
    990 where floor(c) is the greatest integer less that or equal c.
    991 \n
    992 \n
    993 \a arg[2]
    994 \n
    995 index corresponding to the third operand for this operator;
    996 i.e. the index corresponding to y.
    997 
    998 \param num_par
    999 is the total number of parameters on the tape
    1000 (only used for error checking).
    1001 
    1002 \param nc_taylor
    1003 number of columns in the matrix containing the Taylor coefficients.
    1004 
    1005 \param taylor
    1006 \b Input: in StvpOp and StvvOp cases, \a taylor[ arg[1] * nc_taylor + 0 ]
    1007 is used to compute the index in the definition of i_vec above
    1008 
    1009 \param nc_combined
    1010 is the total number of elements in the combined VecAD array.
    1011 
    1012 \param variable
    1013 \b Output: If y is a varable (StpvOp or StvvOp),
    1014 \a variable [ \a arg[0] + i_vec ] is set to true.
    1015 Otherwise y is a paraemter (StppOp or StvpOp) and
    1016 \a variable [ \a arg[0] + i_vec ] is set to false.
    1017 
    1018 \param combined
    1019 \b Output: \a combined [ \a arg[0] + i_vec ]
    1020 is set equal to \a arg[2].
    1021 
    1022 \par Check User Errors
    1023 \li Check that the index is with in range; i.e.
    1024 i_vec < combined[ \a arg[0] - 1 ]
    1025 Note that, if x is a parameter, is the corresponding vector index
    1026 and it does not change.
    1027 In this case, the error above should be detected during tape recording.
    1028 
    1029 \par Checked Assertions
    1030 \li combined != CPPAD_NULL
    1031 \li variable != CPPAD_NULL
    1032 \li NumArg(op) == 3
    1033 \li NumRes(op) == 0
    1034 \li 0 <  \a arg[0]
    1035 \li \a arg[0] + i_vec < nc_combined
    1036 \li if y is a parameter, arg[2] < num_par
    1037 \li if x is a variable, arg[1] <= i_z
    1038 \li if y is a variable, arg[2] <= i_z
    1039 */
    1040 template <class Base>
    1041 inline void forward_store_op_0(
    1042         size_t         i_z         ,
    1043         const addr_t*  arg         ,
    1044         size_t         num_par     ,
    1045         size_t         nc_taylor   ,
    1046         Base*          taylor      ,
    1047         size_t         nc_combined ,
    1048         bool*          variable    ,
    1049         size_t*        combined    )
    1050 {
    1051         // This routine is only for documentaiton, it should not be used
    1052         CPPAD_ASSERT_UNKNOWN( false );
    1053 }
    1054 /*!
    1055 Prototype sparsity operations corresponding to op = StpvOp or StvvOp.
    1056 
    1057 The C++ source code corresponding to this operation is
    1058 \verbatim
    1059         v[x] = y
    1060 \endverbatim
    1061 where v is a VecAD<Base> vector, x is an AD<Base> object,
    1062 and y is AD<Base> or Base objects.
    1063 We define the index corresponding to v[x] by
    1064 \verbatim
    1065         i_v_x = combined[ arg[0] + i_vec ]
    1066 \endverbatim
    1067 where i_vec is defined under the heading \a arg[1] below:
    1068 
    1069 \tparam Vector_set
    1070 is the type used for vectors of sets. It can be either
    1071 \c sparse_pack, \c sparse_set, or \c sparse_list.
    1072 
    1073 
    1074 \param op
    1075 is the code corresponding to this operator; i.e., StpvOp or StvvOp
    1076 (only used for error checking).
    1077 
    1078 \param arg
    1079 \n
    1080 \a arg[0]
    1081 is the offset corresponding to this VecAD vector in the combined array.
    1082 \n
    1083 \n
    1084 \a arg[2]
    1085 \n
    1086 The set with index \a arg[2] in \a var_sparsity
    1087 is the sparsity pattern corresponding to y.
    1088 (Note that \a arg[2] > 0 because y is a variable.)
    1089 
    1090 \param num_combined
    1091 is the total number of elements in the VecAD address array.
    1092 
    1093 \param combined
    1094 \a combined [ arg[0] - 1 ]
    1095 is the index of the set in \a vecad_sparsity corresponding
    1096 to the sparsity pattern for the vector v.
    1097 We use the notation i_v below which is defined by
    1098 \verbatim
    1099         i_v = combined[ \a arg[0] - 1 ]
    1100 \endverbatim
    1101 
    1102 \param var_sparsity
    1103 The set  with index \a arg[2] in \a var_sparsity
    1104 is the sparsity pattern for y.
    1105 This is an input for forward mode operations.
    1106 For reverse mode operations:
    1107 The sparsity pattern for v is added to the spartisy pattern for y.
    1108 
    1109 \param vecad_sparsity
    1110 The set with index \a i_v in \a vecad_sparsity
    1111 is the sparsity pattern for v.
    1112 This is an input for reverse mode operations.
    1113 For forward mode operations, the sparsity pattern for y is added
    1114 to the sparsity pattern for the vector v.
    1115 
    1116 \par Checked Assertions
    1117 \li NumArg(op) == 3
    1118 \li NumRes(op) == 0
    1119 \li 0 <  \a arg[0]
    1120 \li \a arg[0] < \a num_combined
    1121 \li \a arg[2] < \a var_sparsity.n_set()
    1122 \li i_v       < \a vecad_sparsity.n_set()
    1123 */
    1124 inline void sparse_store_op(
    1125         OpCode         op             ,
    1126         const addr_t*  arg            ,
    1127         size_t         num_combined   ,
    1128         const size_t*  combined       ,
    1129         Pack*          var_sparsity   ,
    1130         Pack*          vecad_sparsity )
    1131 {
    1132         // This routine is only for documentaiton, it should not be used
    1133         CPPAD_ASSERT_UNKNOWN( false );
    1134 }
    1135 
    1136945
    1137946// ==================== Sparsity Calculations ==============================
  • trunk/cppad/local/store_op.hpp

    r2910 r2921  
    44
    55/* --------------------------------------------------------------------------
    6 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
     6CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
    77
    88CppAD is distributed under multiple licenses. This distribution is under
     
    2121Changing the current value of a VecAD element.
    2222*/
     23/*!
     24Shared documentation for zero order forward implementation of
     25op = StppOp, StpvOp, StvpOp, or StvvOp (not called).
     26
     27The C++ source code corresponding to this operation is
     28\verbatim
     29        v[x] = y
     30\endverbatim
     31where v is a VecAD<Base> vector, x is an AD<Base> object,
     32and y is AD<Base> or Base objects.
     33We define the index corresponding to v[x] by
     34\verbatim
     35        i_v_x = combined[ arg[0] + i_vec ]
     36\endverbatim
     37where i_vec is defined under the heading \a arg[1] below:
     38
     39\tparam Base
     40base type for the operator; i.e., this operation was recorded
     41using AD< \a Base > and computations by this routine are done using type
     42\a Base.
     43
     44\param i_z
     45is the index corresponding to the previous variable on the tape
     46(only used for error checking).
     47
     48\param arg
     49\n
     50\a arg[0]
     51is the offset of this VecAD vector relative to the beginning
     52of the \a combined VecAD array.
     53\n
     54\n
     55\a arg[1]
     56\n
     57If this is a StppOp or StpvOp operation
     58(the index x is a parameter), i_vec is defined by
     59\verbatim
     60        i_vec = arg[1]
     61\endverbatim
     62If this is a StvpOp or StvvOp operation
     63(the index x is a variable), i_vec is defined by
     64\verbatim
     65        i_vec = floor( taylor[ arg[1] * nc_taylor + 0 ] )
     66\endverbatim
     67where floor(c) is the greatest integer less that or equal c.
     68\n
     69\n
     70\a arg[2]
     71\n
     72index corresponding to the third operand for this operator;
     73i.e. the index corresponding to y.
     74
     75\param num_par
     76is the total number of parameters on the tape
     77(only used for error checking).
     78
     79\param nc_taylor
     80number of columns in the matrix containing the Taylor coefficients.
     81
     82\param taylor
     83\b Input: in StvpOp and StvvOp cases, \a taylor[ arg[1] * nc_taylor + 0 ]
     84is used to compute the index in the definition of i_vec above
     85
     86\param nc_combined
     87is the total number of elements in the combined VecAD array.
     88
     89\param variable
     90\b Output: If y is a varable (StpvOp or StvvOp),
     91\a variable [ \a arg[0] + i_vec ] is set to true.
     92Otherwise y is a paraemter (StppOp or StvpOp) and
     93\a variable [ \a arg[0] + i_vec ] is set to false.
     94
     95\param combined
     96\b Output: \a combined [ \a arg[0] + i_vec ]
     97is set equal to \a arg[2].
     98
     99\par Check User Errors
     100\li Check that the index is with in range; i.e.
     101i_vec < combined[ \a arg[0] - 1 ]
     102Note that, if x is a parameter, is the corresponding vector index
     103and it does not change.
     104In this case, the error above should be detected during tape recording.
     105
     106\par Checked Assertions
     107\li combined != CPPAD_NULL
     108\li variable != CPPAD_NULL
     109\li NumArg(op) == 3
     110\li NumRes(op) == 0
     111\li 0 <  \a arg[0]
     112\li \a arg[0] + i_vec < nc_combined
     113\li if y is a parameter, arg[2] < num_par
     114\li if x is a variable, arg[1] <= i_z
     115\li if y is a variable, arg[2] <= i_z
     116*/
     117template <class Base>
     118inline void forward_store_op_0(
     119        size_t         i_z         ,
     120        const addr_t*  arg         ,
     121        size_t         num_par     ,
     122        size_t         nc_taylor   ,
     123        Base*          taylor      ,
     124        size_t         nc_combined ,
     125        bool*          variable    ,
     126        size_t*        combined    )
     127{
     128        // This routine is only for documentaiton, it should not be used
     129        CPPAD_ASSERT_UNKNOWN( false );
     130}
     131/*!
     132Shared documnetation for sparsity operations corresponding to
     133op = StpvOp or StvvOp (not called).
     134
     135<!-- define sparse_store_op -->
     136The C++ source code corresponding to this operation is
     137\verbatim
     138        v[x] = y
     139\endverbatim
     140where v is a VecAD<Base> vector, x is an AD<Base> object,
     141and y is AD<Base> or Base objects.
     142We define the index corresponding to v[x] by
     143\verbatim
     144        i_v_x = combined[ arg[0] + i_vec ]
     145\endverbatim
     146where i_vec is defined under the heading \a arg[1] below:
     147
     148\tparam Vector_set
     149is the type used for vectors of sets. It can be either
     150\c sparse_pack, \c sparse_set, or \c sparse_list.
     151
     152\param op
     153is the code corresponding to this operator; i.e., StpvOp or StvvOp
     154(only used for error checking).
     155
     156\param arg
     157\n
     158\a arg[0]
     159is the offset corresponding to this VecAD vector in the combined array.
     160\n
     161\n
     162\a arg[2]
     163\n
     164The set with index \a arg[2] in \a var_sparsity
     165is the sparsity pattern corresponding to y.
     166(Note that \a arg[2] > 0 because y is a variable.)
     167
     168\param num_combined
     169is the total number of elements in the VecAD address array.
     170
     171\param combined
     172\a combined [ arg[0] - 1 ]
     173is the index of the set in \a vecad_sparsity corresponding
     174to the sparsity pattern for the vector v.
     175We use the notation i_v below which is defined by
     176\verbatim
     177        i_v = combined[ \a arg[0] - 1 ]
     178\endverbatim
     179
     180\param var_sparsity
     181The set  with index \a arg[2] in \a var_sparsity
     182is the sparsity pattern for y.
     183This is an input for forward mode operations.
     184For reverse mode operations:
     185The sparsity pattern for v is added to the spartisy pattern for y.
     186
     187\param vecad_sparsity
     188The set with index \a i_v in \a vecad_sparsity
     189is the sparsity pattern for v.
     190This is an input for reverse mode operations.
     191For forward mode operations, the sparsity pattern for y is added
     192to the sparsity pattern for the vector v.
     193
     194\par Checked Assertions
     195\li NumArg(op) == 3
     196\li NumRes(op) == 0
     197\li 0 <  \a arg[0]
     198\li \a arg[0] < \a num_combined
     199\li \a arg[2] < \a var_sparsity.n_set()
     200\li i_v       < \a vecad_sparsity.n_set()
     201<!-- end sparse_store_op -->
     202*/
     203template <class Vector_set>
     204inline void sparse_store_op(
     205        OpCode         op             ,
     206        const addr_t*  arg            ,
     207        size_t         num_combined   ,
     208        const size_t*  combined       ,
     209        Vector_set&    var_sparsity   ,
     210        Vector_set&    vecad_sparsity )
     211{
     212        // This routine is only for documentaiton, it should not be used
     213        CPPAD_ASSERT_UNKNOWN( false );
     214}
     215
    23216
    24217/*!
     
    195388\endverbatim
    196389
    197 \copydetails sparse_store_op
     390<!-- replace sparse_store_op -->
     391The C++ source code corresponding to this operation is
     392\verbatim
     393        v[x] = y
     394\endverbatim
     395where v is a VecAD<Base> vector, x is an AD<Base> object,
     396and y is AD<Base> or Base objects.
     397We define the index corresponding to v[x] by
     398\verbatim
     399        i_v_x = combined[ arg[0] + i_vec ]
     400\endverbatim
     401where i_vec is defined under the heading \a arg[1] below:
     402
     403\tparam Vector_set
     404is the type used for vectors of sets. It can be either
     405\c sparse_pack, \c sparse_set, or \c sparse_list.
     406
     407\param op
     408is the code corresponding to this operator; i.e., StpvOp or StvvOp
     409(only used for error checking).
     410
     411\param arg
     412\n
     413\a arg[0]
     414is the offset corresponding to this VecAD vector in the combined array.
     415\n
     416\n
     417\a arg[2]
     418\n
     419The set with index \a arg[2] in \a var_sparsity
     420is the sparsity pattern corresponding to y.
     421(Note that \a arg[2] > 0 because y is a variable.)
     422
     423\param num_combined
     424is the total number of elements in the VecAD address array.
     425
     426\param combined
     427\a combined [ arg[0] - 1 ]
     428is the index of the set in \a vecad_sparsity corresponding
     429to the sparsity pattern for the vector v.
     430We use the notation i_v below which is defined by
     431\verbatim
     432        i_v = combined[ \a arg[0] - 1 ]
     433\endverbatim
     434
     435\param var_sparsity
     436The set  with index \a arg[2] in \a var_sparsity
     437is the sparsity pattern for y.
     438This is an input for forward mode operations.
     439For reverse mode operations:
     440The sparsity pattern for v is added to the spartisy pattern for y.
     441
     442\param vecad_sparsity
     443The set with index \a i_v in \a vecad_sparsity
     444is the sparsity pattern for v.
     445This is an input for reverse mode operations.
     446For forward mode operations, the sparsity pattern for y is added
     447to the sparsity pattern for the vector v.
     448
     449\par Checked Assertions
     450\li NumArg(op) == 3
     451\li NumRes(op) == 0
     452\li 0 <  \a arg[0]
     453\li \a arg[0] < \a num_combined
     454\li \a arg[2] < \a var_sparsity.n_set()
     455\li i_v       < \a vecad_sparsity.n_set()
     456<!-- end sparse_store_op -->
    198457*/
    199458template <class Vector_set>
     
    229488\endverbatim
    230489
    231 \copydetails sparse_store_op
     490<!-- replace sparse_store_op -->
     491The C++ source code corresponding to this operation is
     492\verbatim
     493        v[x] = y
     494\endverbatim
     495where v is a VecAD<Base> vector, x is an AD<Base> object,
     496and y is AD<Base> or Base objects.
     497We define the index corresponding to v[x] by
     498\verbatim
     499        i_v_x = combined[ arg[0] + i_vec ]
     500\endverbatim
     501where i_vec is defined under the heading \a arg[1] below:
     502
     503\tparam Vector_set
     504is the type used for vectors of sets. It can be either
     505\c sparse_pack, \c sparse_set, or \c sparse_list.
     506
     507\param op
     508is the code corresponding to this operator; i.e., StpvOp or StvvOp
     509(only used for error checking).
     510
     511\param arg
     512\n
     513\a arg[0]
     514is the offset corresponding to this VecAD vector in the combined array.
     515\n
     516\n
     517\a arg[2]
     518\n
     519The set with index \a arg[2] in \a var_sparsity
     520is the sparsity pattern corresponding to y.
     521(Note that \a arg[2] > 0 because y is a variable.)
     522
     523\param num_combined
     524is the total number of elements in the VecAD address array.
     525
     526\param combined
     527\a combined [ arg[0] - 1 ]
     528is the index of the set in \a vecad_sparsity corresponding
     529to the sparsity pattern for the vector v.
     530We use the notation i_v below which is defined by
     531\verbatim
     532        i_v = combined[ \a arg[0] - 1 ]
     533\endverbatim
     534
     535\param var_sparsity
     536The set  with index \a arg[2] in \a var_sparsity
     537is the sparsity pattern for y.
     538This is an input for forward mode operations.
     539For reverse mode operations:
     540The sparsity pattern for v is added to the spartisy pattern for y.
     541
     542\param vecad_sparsity
     543The set with index \a i_v in \a vecad_sparsity
     544is the sparsity pattern for v.
     545This is an input for reverse mode operations.
     546For forward mode operations, the sparsity pattern for y is added
     547to the sparsity pattern for the vector v.
     548
     549\par Checked Assertions
     550\li NumArg(op) == 3
     551\li NumRes(op) == 0
     552\li 0 <  \a arg[0]
     553\li \a arg[0] < \a num_combined
     554\li \a arg[2] < \a var_sparsity.n_set()
     555\li i_v       < \a vecad_sparsity.n_set()
     556<!-- end sparse_store_op -->
    232557
    233558\param var_jacobian
Note: See TracChangeset for help on using the changeset viewer.