Changeset 3788


Ignore:
Timestamp:
Feb 9, 2016 10:50:06 AM (4 years ago)
Author:
bradbell
Message:

merge to branch: trunk
from repository: https://github.com/coin-or/CppAD
start hash code: c4559d5e01e1b0f09943490dd84449557eced25d
end hash code: 431e0a227dbfe6172d265d9d79a2b5b258c5bc18

commit 431e0a227dbfe6172d265d9d79a2b5b258c5bc18
Author: Brad Bell <bradbell@…>
Date: Tue Feb 9 07:41:29 2016 -0700

  1. Change package.sh to automatically update version on (master branch only).
  2. Change version.sh copy to check and change.

commit a14455414810cfe3c3e4bca90090defc2528a353
Author: Brad Bell <bradbell@…>
Date: Tue Feb 9 06:19:54 2016 -0700

Change check_verbatim to check_srcfile
because all but one of the verbatim commands were changed to srcfile commands.


check_include_omh.sh: old check that file names did not change case (for cygwin development).

commit 4ce45b796b57629332ab46d8ae6df94e0a1ed998
Author: Brad Bell <bradbell@…>
Date: Tue Feb 9 06:04:57 2016 -0700

batch_edit.sh to change $verbatim and $codep to $srcfile and $srccode.


det_by_minor.c: remove some invisible white space.

commit 56553b88c9623c30d2222425a9640b95ce4c8281
Author: Brad Bell <bradbell@…>
Date: Mon Feb 8 18:01:49 2016 -0700

check_jenkins.sh: jenkins.sh no longer takes an argument.
jenkins.sh: fix name of script in error message.

commit 3b8a208cfc7e8ef3c928c17eb291aa3b90ff0050
Author: Brad Bell <bradbell@…>
Date: Mon Feb 8 07:57:02 2016 -0700

new_release.sh: track branches in comments, back to master at OK end, first check of response.

commit 442b7cbc45c022776e8257d3c3404dccdd06c420
Author: Brad Bell <bradbell@…>
Date: Mon Feb 8 06:01:11 2016 -0700

  1. Advance to release 20160000.1.
  2. Check using master version of new_release.sh.
  3. Make sure auto-tools version up to date.
  4. Ask user if doing further testing before commiting new release.

commit f7bdd1f48e72feb05d604da63914022809f45c28
Author: Brad Bell <bradbell@…>
Date: Sun Feb 7 07:59:41 2016 -0700

Add shared library version number to cppad_lib; i.e., cppad_lib.yyyy.mmdd.rel

commit a4c716552e3ad05b337aea58b643c9ad1cbcd4ac
Author: Brad Bell <bradbell@…>
Date: Sun Feb 7 05:25:39 2016 -0700

Make cppad_lib libarary conditional on colpack_prefix being specified.

commit 5e8890eb8de8b0cde146a6ed59c391d7c355ff24
Author: Brad Bell <bradbell@…>
Date: Tue Jan 26 10:49:37 2016 -0700

vector.hpp: fix The -> This.

commit e4e5442b069d7b00e197c31616da32eee20460b3
Merge: c4559d5 ed28b89
Author: Brad Bell <bradbell@…>
Date: Tue Jan 26 09:47:58 2016 -0700

Merge pull request #14 from barak/master


fix spelling in description of cppad_profile_flag on cmake command line

commit ed28b899c9fedab52a578aa7dd73818638081fe6
Author: Barak A. Pearlmutter <barak+git@…>
Date: Tue Jan 26 16:24:32 2016 +0000

typo

Location:
trunk
Files:
1 added
2 deleted
302 edited

Legend:

Unmodified
Added
Removed
  • trunk/AUTHORS

    r3692 r3788  
    22             ===========================================
    33
    4 To date, 2015-06-01, Bradley M. Bell is the sole author of CppAD.
     4To date, 2016-02-09, Bradley M. Bell is the sole author of CppAD.
    55While Bradley M. Bell worked for the University of Washington during
    66the development of CppAD, the following are also true:
  • trunk/CMakeLists.txt

    r3762 r3788  
    11# $Id$
    22# -----------------------------------------------------------------------------
    3 # CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44#
    55# CppAD is distributed under multiple licenses. This distribution is under
     
    1818
    1919# cppad_version is used by set_version.sh to get the version number.
    20 SET(cppad_version      "20150601" )
     20SET(cppad_version      "20160209" )
    2121SET(cppad_url          "http://www.coin-or.org/CppAD" )
    2222SET(cppad_description  "Differentiation of C++ Algorithms" )
     
    121121# cppad_profile_flag
    122122command_line_arg(cppad_profile_flag NOTFOUND STRING
    123         "compile flag used to compoile and link a profile version of a program"
     123        "compile flag used to compile and link a profile version of a program"
    124124)
    125125# -----------------------------------------------------------------------------
     
    144144optional_package(sacado_prefix "sacado install prefix")
    145145# -----------------------------------------------------------------------------
    146 # cppad_has_colpack, colpack_libs
     146# cppad_has_colpack, colpack_libs, cppad_lib
    147147#
    148148IF( colpack_prefix )
    149149        SET(cppad_has_colpack 1)
    150150        SET( colpack_libs "ColPack" )
     151        SET( cppad_lib "cppad_lib" )
    151152ELSE( colpack_prefix )
    152153        SET(cppad_has_colpack 0)
    153154        SET( colpack_libs "" )
     155        SET( cppad_lib "" )
    154156ENDIF( colpack_prefix )
    155157# =============================================================================
     
    289291ADD_SUBDIRECTORY(cppad)
    290292ADD_SUBDIRECTORY(pkgconfig)
    291 ADD_SUBDIRECTORY(cppad_lib)
     293IF( colpack_prefix )
     294        ADD_SUBDIRECTORY(cppad_lib)
     295ENDIF( colpack_prefix)
    292296#
    293297ADD_SUBDIRECTORY(compare_c)
  • trunk/bin/batch_edit.sh

    r3781 r3788  
    1111# Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
    1212# -----------------------------------------------------------------------------
    13 move_sed='s|list_files.sh|ls_files.sh|'
     13revert_list='
     14'
    1415move_list='
    1516'
     17move_sed='s|list_files.sh|ls_files.sh|'
     18#
    1619cat << EOF > junk.sed
    17 s|inline AD Abs(void) const;|inline AD abs_me(void) const;|
    18 s|AD<Base> AD<Base>::Abs (void) const|AD<Base> AD<Base>::abs_me (void) const|
    19 s|return x.Abs();|return x.abs_me();|
    20 s|return abs( *x.ADBase() *);|return x.ADBase().abs_me();|
    2120#
    22 s|inline AD Sign(void) const;|inline AD sign_me(void) const;|
    23 s|AD<Base> AD<Base>::Sign (void) const|AD<Base> AD<Base>::sign_me (void) const|
    24 s|return x.Sign();|return x.sign_me();|
    25 s|return sign( *x.ADBase() *);|return x.ADBase().sign_me();|
     21/\$codep [*]\//! b two
     22: one
     23N
     24/\/[*] *\$\\\$/! b one
     25s|\$codep [*]/|\$srccode%cpp% */|
     26s|/[*] *\$\\\$|/* %\$\$|
     27#
     28: two
     29/\$verbatim/! b end
     30/\$\\\$/! N
     31/\$\\\$/! b two
     32/\.[ch]pp%/s|\$verbatim|\$srcfile|
     33#
     34: end
    2635EOF
    2736# -----------------------------------------------------------------------------
     
    4049cp bin/batch_edit.sh $HOME/trash/batch_edit.sh
    4150git reset --hard
    42 cp $HOME/trash/batch_edit.sh bin/batch_edit.sh
    4351# ---------------------------------------------------------------------------
    4452list_all=`bin/ls_files.sh`
     
    6371fi
    6472# ----------------------------------------------------------------------------
     73for file in $revert_list
     74do
     75        echo_eval git checkout $file
     76done
     77# ----------------------------------------------------------------------------
     78cp $HOME/trash/batch_edit.sh bin/batch_edit.sh
    6579echo "$0: OK"
    6680exit 0
  • trunk/bin/check_jenkins.sh

    r3768 r3788  
    22# $Id$
    33# -----------------------------------------------------------------------------
    4 # CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     4# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    55#
    66# CppAD is distributed under multiple licenses. This distribution is under
     
    3737echo_eval svn update
    3838# ----------------------------------------------------------------------------
    39 redo_external='install'
    40 echo_eval bin/jenkins.sh $redo_external
     39echo_eval bin/jenkins.sh
    4140# ----------------------------------------------------------------------------
    4241echo "$0: OK"
  • trunk/bin/jenkins.sh

    r3758 r3788  
    22# $Id$
    33# -----------------------------------------------------------------------------
    4 # CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     4# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    55#
    66# CppAD is distributed under multiple licenses. This distribution is under
     
    1818if [ "$1" != '' ]
    1919then
    20         echo 'bin/junk.sh no longer has any arguments'
     20        echo 'bin/jenkins.sh no longer has any arguments'
    2121        exit 1
    2222fi
  • trunk/bin/new_release.sh

    r3775 r3788  
    22# $Id$
    33# -----------------------------------------------------------------------------
    4 # CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     4# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    55#
    66# CppAD is distributed under multiple licenses. This distribution is under
     
    1111# Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
    1212# -----------------------------------------------------------------------------
    13 if [ "$0" != 'bin/junk.sh' ]
     13if [ "$0" != 'bin/new_release.sh' ]
    1414then
    1515        echo "bin/new_release.sh: must be executed from its parent directory"
     
    2424svn_repo="https://projects.coin-or.org/svn/CppAD"
    2525stable_version="20160000"
    26 release='0'
    27 # -----------------------------------------------------------------------------
    28 # check that local branch is up to date
    29 list=`git status -s`
    30 if [ "$list" != '' ]
    31 then
    32         echo "new_release.sh: 'git status -s' is not empty"
    33         exit 1
    34 fi
    35 # -----------------------------------------------------------------------------
     26release='1'
     27# -----------------------------------------------------------------------------
     28branch=`git branch | grep '^\*'`
     29if [ "$branch" != '* master' ]
     30then
     31        echo 'new_release.sh: must use master branch version of new_release.sh'
     32        exit 1
     33fi
     34# =============================================================================
     35# master branch
     36# =============================================================================
    3637# Make sure local, remote and svn hash codes agree for this stable branch
    3738stable_branch=stable/$stable_version
     
    127128fi
    128129# -----------------------------------------------------------------------------
     130# Make sure master branch does not have uncomitted changes
     131# before checking out stable branch
     132list=`git status -s`
     133if [ "$list" != '' ]
     134then
     135        echo "new_release.sh: 'git status -s' is not empty (for master branch)"
     136        exit 1
     137fi
     138# =============================================================================
     139# stable branch
     140# =============================================================================
    129141# checkout the stable branch
    130142branch=`git branch | grep '^\*' | sed -e 's|^\* *||'`
     
    141153        echo 'bin/new_release.sh: version number is not correct ?'
    142154        echo "  bin/version.sh set $stable_version.$release"
    143         echo '  bin/version.sh copy'
    144         echo 'Then test and then commit the changes.'
     155        echo '  bin/version.sh check'
     156        echo 'Then commit the changes.'
     157        exit 1
     158fi
     159# -----------------------------------------------------------------------------
     160# make sure that autotools version of makfiles is up to current version
     161echo_eval "./build.sh automake"
     162list=`git status -s`
     163if [ "$list" != '' ]
     164then
     165        echo "new_release.sh: 'git status -s' is not empty"
     166        echo 'stable branch auto-tools install not up to current version'
     167        echo 'commit the local changes.'
     168        exit 1
     169fi
     170# -----------------------------------------------------------------------------
     171read -p 'All checks have passed. More testing or commit release [t/c] ?' \
     172        response
     173if [ "$response" != 'c' ]
     174then
     175        echo 'Exiting for more testing of stable branch'
    145176        exit 1
    146177fi
     
    176207echo "Use the command the following command to finish the process"
    177208echo "  svn commit -m \"$msg\" build/conf/projDesc.xml"
    178 # ----------------------------------------------------------------------------
     209# =============================================================================
     210# master branch
     211# =============================================================================
     212git checkout master
    179213echo "$0: OK"
    180214exit 0
  • trunk/bin/package.sh

    r3781 r3788  
    5353fi
    5454# ----------------------------------------------------------------------------
    55 # Automated updates to source directory
     55# Make sure version is set correctly
    5656#
    57 # Get version number and make sure all copies of it are up to date.
     57# if this is the master, set version to today
     58branch=`git branch | grep '^\*' | sed -e 's|^\* *||'`
     59if [ "$branch" == 'master' ]
     60then
     61        bin/version.sh set
     62fi
     63# make sure that version number is the same in all files
     64echo_log_eval bin/version.sh check
     65#
     66# Get version number and make sure all copies agree
    5867version=`bin/version.sh get`
    5968echo_log_eval bin/version.sh get
    60 echo_log_eval bin/version.sh copy
    6169# ----------------------------------------------------------------------------
    6270# Run automated checks for the form bin/check_*.sh with a few exceptions.
    63 # Note that check_include_omh.sh uses files built by cmake.
    6471list=`ls bin/check_* | sed \
    6572        -e '/check_all.sh/d' \
  • trunk/bin/tag_month.sh

    r3768 r3788  
    22# $Id:$
    33# -----------------------------------------------------------------------------
    4 # CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     4# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    55#
    66# CppAD is distributed under multiple licenses. This distribution is under
     
    2727# --------------------------------------------------------------------------
    2828# make sure that version is consistent and all changes are checked in
    29 bin/version.sh copy > /dev/null
     29bin/version.sh check
     30# --------------------------------------------------------------------------
     31# make sure repo is up to date
    3032git_status=`git status -s`
    3133if [ "$git_status" != '' ]
  • trunk/bin/version.sh

    r3693 r3788  
    22# $Id$
    33# -----------------------------------------------------------------------------
    4 # CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     4# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    55#
    66# CppAD is distributed under multiple licenses. This distribution is under
     
    1616        exit 1
    1717fi
    18 if [ "$1" != 'get' ] && [ "$1" != 'set' ] && [ "$1" != 'copy' ]
     18if [ "$1" != 'get' ] && [ "$1" != 'set' ] && [ "$1" != 'check' ]
    1919then
    20         echo 'usage: bin/version.sh (get | set | copy) [version]'
    21         echo 'get:  Gets the current version number from CMakeLists.txt.'
    22         echo 'set:  Sets CMakeLists.txt version number to version.'
    23         echo '      If version is not present, uses current yyyymmdd.'
    24         echo 'copy: Copies version number from CMakeLists.txt to other files.'
     20        echo 'usage: bin/version.sh (get | set | check) [version]'
     21        echo 'get:   Gets the current version number from CMakeLists.txt.'
     22        echo 'set:   Sets CMakeLists.txt version number to version.'
     23        echo '       If version is not present, uses current yyyymmdd.'
     24        echo 'check: Checks that the version version number in CMakeLists.txt'
     25        echo '       is the same as in other files. If not, changes the other'
     26        echo '       files and exits with an error message'
    2527        exit 1
    2628fi
     
    4850        echo_eval rm CMakeLists.txt.old
    4951        #
    50         echo 'bin/version.sh set: OK'
     52        echo 'version.sh set: OK'
    5153        exit 0
    5254fi
     
    5759if ! (echo $version | grep '[0-9]\{8\}') > /dev/null
    5860then
    59         echo 'bin/version.sh: Cannot find verison number in CMakeLists.txt'
     61        echo 'version.sh: Cannot find verison number in CMakeLists.txt'
    6062        exit 1
    6163fi
     
    7072        -e 's|\([0-9]\{4\}\)0000|\10101|' \
    7173        -e 's|\(....\)\(..\)\(..\).*|\1-\2-\3|'`
    72 echo 'sed -i.old AUTHORS ...'
    7374sed  \
    7475        -e "s/, [0-9]\{4\}-[0-9]\{2\}-[0-9]\{2\} *,/, $yyyy_mm_dd,/" \
    7576        -i.old AUTHORS
    7677#
    77 echo 'sed -i.old configure.ac ...'
    7878sed  \
    7979        -e "s/(\[cppad\], *\[[0-9]\{8\}[.0-9]*\] *,/([cppad], [$version],/"  \
    8080        -i.old configure.ac
    8181#
    82 echo 'sed -i.old configure ...'
    8382sed \
    8483        -e "s/cppad [0-9]\{8\}[.0-9]*/cppad $version/g" \
     
    107106        configure
    108107"
     108ok='yes'
    109109for name in $list
    110110do
    111         echo '-------------------------------------------------------------'
    112         echo "diff $name.old $name"
    113         if diff $name.old $name
     111        if ! diff $name.old $name > /dev/null
    114112        then
    115                 echo '  no difference was found'
     113                echo '-------------------------------------------------------------'
     114                echo "diff $name.old $name"
     115                if diff $name.old $name
     116                then
     117                        echo 'version.sh check: program error'
     118                        exit 1
     119                fi
     120                ok='no'
    116121        fi
    117         #
    118         echo_eval rm $name.old
     122        rm $name.old
    119123done
    120 echo 'bin/version.sh copy: OK'
     124if [ "$ok" != 'yes' ]
     125then
     126        echo 'version.sh check: Found and fixed differences'
     127        exit 1
     128fi
     129echo 'version.sh check: OK'
     130exit 0
  • trunk/compare_c/det_by_minor.c

    r2613 r3788  
    22
    33/* --------------------------------------------------------------------------
    4 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
     4CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    55
    66CppAD is distributed under multiple licenses. This distribution is under
    7 the terms of the 
     7the terms of the
    88                    Eclipse Public License Version 1.0.
    99
     
    2323# define true 1
    2424# define false 0
    25 # endif 
     25# endif
    2626
    2727/*
     
    3636
    3737$head Syntax$$
    38 $icode%d% = det_of_minor(%a%, %m%, %n%, %r%, %c%)%$$ 
     38$icode%d% = det_of_minor(%a%, %m%, %n%, %r%, %c%)%$$
    3939
    4040$head Purpose$$
    4141returns the determinant of a minor of the matrix $latex A$$
    4242using expansion by minors.
    43 The elements of the $latex n \times n$$ minor $latex M$$ 
     43The elements of the $latex n \times n$$ minor $latex M$$
    4444of the matrix $latex A$$ are defined,
    4545for $latex i = 0 , \ldots , n-1$$ and $latex j = 0 , \ldots , n-1$$, by
     
    4747        M_{i,j} = A_{R(i), C(j)}
    4848\]$$
    49 where the functions 
     49where the functions
    5050$latex R(i)$$ is defined by the $cref/argument r/det_of_minor/r/$$ and
    5151$latex C(j)$$ is defined by the $cref/argument c/det_of_minor/c/$$.
     
    5757Expansion by minors is chosen as an example because it uses
    5858a lot of floating point operations yet does not require much source code
    59 (on the order of $icode m$$ factorial floating point operations and 
     59(on the order of $icode m$$ factorial floating point operations and
    6060about 70 lines of source code including comments).
    6161This is not an efficient method for computing a determinant;
     
    7070$latex n = m$$.
    7171$lnext
    72 for $latex i = 0 , \ldots , m-1$$, $latex r[i] = i+1$$, 
     72for $latex i = 0 , \ldots , m-1$$, $latex r[i] = i+1$$,
    7373and $latex r[m] = 0$$.
    7474$lnext
     
    8181$codei%
    8282        const double* %a%
    83 %$$ 
     83%$$
    8484and is a vector with size $latex m * m$$.
    8585The elements of the $latex m \times m$$ matrix $latex A$$ are defined,
     
    109109%$$
    110110and is a vector with $latex m + 1$$ elements.
    111 This vector defines the function $latex R(i)$$ 
     111This vector defines the function $latex R(i)$$
    112112which specifies the rows of the minor $latex M$$.
    113 To be specific, the function $latex R(i)$$ 
    114 for $latex i = 0, \ldots , n-1$$ is defined by 
     113To be specific, the function $latex R(i)$$
     114for $latex i = 0, \ldots , n-1$$ is defined by
    115115$latex \[
    116116\begin{array}{rcl}
     
    122122All the elements of $icode r$$ must have value
    123123less than or equal $icode m$$.
    124 The elements of vector $icode r$$ are modified during the computation, 
     124The elements of vector $icode r$$ are modified during the computation,
    125125and restored to their original value before the return from
    126126$code det_of_minor$$.
     
    132132%$$
    133133and is a vector with $latex m + 1$$ elements
    134 This vector defines the function $latex C(i)$$ 
     134This vector defines the function $latex C(i)$$
    135135which specifies the rows of the minor $latex M$$.
    136 To be specific, the function $latex C(i)$$ 
    137 for $latex j = 0, \ldots , n-1$$ is defined by 
     136To be specific, the function $latex C(i)$$
     137for $latex j = 0, \ldots , n-1$$ is defined by
    138138$latex \[
    139139\begin{array}{rcl}
     
    145145All the elements of $icode c$$ must have value
    146146less than or equal $icode m$$.
    147 The elements of vector $icode c$$ are modified during the computation, 
     147The elements of vector $icode c$$ are modified during the computation,
    148148and restored to their original value before the return from
    149149$code det_of_minor$$.
     
    160160$$
    161161$head Source Code$$
    162 $codep */
    163 double det_of_minor( 
    164         const double*        a  , 
    165         size_t               m  , 
    166         size_t               n  , 
    167         size_t*              r  , 
     162$srccode%cpp% */
     163double det_of_minor(
     164        const double*        a  ,
     165        size_t               m  ,
     166        size_t               n  ,
     167        size_t*              r  ,
    168168        size_t*              c  )
    169169{       size_t R0, Cj, Cj1, j;
    170170        double detM, M0j, detS;
    171171        int s;
    172        
     172
    173173        R0 = r[m]; /* R(0) */
    174174        Cj = c[m]; /* C(j)    (case j = 0) */
     
    209209                Cj1 = Cj;
    210210                Cj  = c[Cj];
    211                 s   = - s;             
     211                s   = - s;
    212212        }
    213213
     
    218218        return detM;
    219219}
    220 /* $$
     220/* %$$
    221221$end
    222222-------------------------------------------------------------------------------
     
    230230
    231231$head Syntax$$
    232 $icode%d% = det_by_minor(%a%, %n%)%$$ 
     232$icode%d% = det_by_minor(%a%, %n%)%$$
    233233
    234234$head Purpose$$
    235235returns the determinant of the matrix $latex A$$
    236236using expansion by minors.
    237 The elements of the $latex n \times n$$ minor $latex M$$ 
     237The elements of the $latex n \times n$$ minor $latex M$$
    238238of the matrix $latex A$$ are defined,
    239239for $latex i = 0 , \ldots , n-1$$ and $latex j = 0 , \ldots , n-1$$, by
     
    246246$codei%
    247247        const double* %a%
    248 %$$ 
     248%$$
    249249and is a vector with size $latex m * m$$.
    250250The elements of the $latex m \times m$$ matrix $latex A$$ are defined,
     
    271271$$
    272272$head Source Code$$
    273 $codep */
     273$srccode%cpp% */
    274274double det_by_minor(double* a, size_t m)
    275275{       size_t *r, *c, i;
     
    293293        return value;
    294294}
    295 /* $$
     295/* %$$
    296296$end
    297297--------------------------------------------------------------------------
    298298$begin uniform_01_c$$
    299299
    300 $section Simulate a [0,1] Uniform Random Variate$$ 
     300$section Simulate a [0,1] Uniform Random Variate$$
    301301
    302302$head Syntax$$
     
    341341$$
    342342$head Source Code$$
    343 $codep */
     343$srccode%cpp% */
    344344void random_seed(size_t seed)
    345345{       srand(seed); }
     
    349349                a[n] = rand() * factor;
    350350}
    351 /* $$
     351/* %$$
    352352$end
    353353------------------------------------------------------------------------------
     
    379379$$
    380380$head Source Code$$
    381 $codep */
     381$srccode%cpp% */
    382382bool correct_det_by_minor(void)
    383383{       double a[9], det, check;
     
    388388        /* compute determinant using expansion by minors */
    389389        det = det_by_minor(a, 3);
    390        
     390
    391391        /* use expansion by minors to hand code the determinant  */
    392392        check = 0.;
     
    399399        return false;
    400400}
    401 /* $$
     401/* %$$
    402402$end
    403403------------------------------------------------------------------------------
     
    437437$$
    438438$head Source Code$$
    439 $codep */
     439$srccode%cpp% */
    440440void repeat_det_by_minor(size_t repeat, size_t size)
    441441{       double *a;
     
    446446                det_by_minor(a, size);
    447447        }
    448        
     448
    449449        free(a);
    450450        return;
    451451}
    452 /* $$
     452/* %$$
    453453$end
    454454------------------------------------------------------------------------------
     
    469469
    470470$head s$$
    471 is a $code double$$ equal to the 
     471is a $code double$$ equal to the
    472472number of seconds since the first call to $code elapsed_seconds$$.
    473473
     
    485485$$
    486486$head Source Code$$
    487 $codep */
     487$srccode%cpp% */
    488488# if _MSC_VER
    489489// ---------------------------------------------------------------------------
     
    524524
    525525        static bool first_ = true;
    526         static struct timeval tv_first;         
     526        static struct timeval tv_first;
    527527        struct timeval        tv;
    528528        if( first_ )
     
    541541}
    542542# endif
    543 /* $$
     543/* %$$
    544544$end
    545545-----------------------------------------------------------------------------
     
    579579$codei%
    580580        double %time%
    581 %$$ 
     581%$$
    582582and is the number of wall clock seconds that it took for
    583583$code det_by_minor$$ to compute its determinant
     
    593593$$
    594594$head Source Code$$
    595 $codep */
     595$srccode%cpp% */
    596596double time_det_by_minor(size_t size, double time_min)
    597597{       size_t repeat;
     
    611611        return time;
    612612}
    613 /* $$
     613/* %$$
    614614$end
    615615------------------------------------------------------------------------------
     
    629629$$
    630630$head Source Code$$
    631 $codep */
     631$srccode|cpp| */
    632632int main(void)
    633633{       bool flag;
     
    654654        return 1;
    655655}
    656 /* $$
     656/* |$$
    657657$end
    658658*/
  • trunk/configure

    r3762 r3788  
    11#! /bin/sh
    22# Guess values for system-dependent variables and create Makefiles.
    3 # Generated by GNU Autoconf 2.69 for cppad 20150601.
     3# Generated by GNU Autoconf 2.69 for cppad 20160209.
    44#
    55# Report bugs to <cppad@list.coin-or.org>.
     
    581581PACKAGE_NAME='cppad'
    582582PACKAGE_TARNAME='cppad'
    583 PACKAGE_VERSION='20150601'
    584 PACKAGE_STRING='cppad 20150601'
     583PACKAGE_VERSION='20160209'
     584PACKAGE_STRING='cppad 20160209'
    585585PACKAGE_BUGREPORT='cppad@list.coin-or.org'
    586586PACKAGE_URL=''
     
    14081408  # This message is too long to be a string in the A/UX 3.1 sh.
    14091409  cat <<_ACEOF
    1410 \`configure' configures cppad 20150601 to adapt to many kinds of systems.
     1410\`configure' configures cppad 20160209 to adapt to many kinds of systems.
    14111411
    14121412Usage: $0 [OPTION]... [VAR=VALUE]...
     
    14781478if test -n "$ac_init_help"; then
    14791479  case $ac_init_help in
    1480      short | recursive ) echo "Configuration of cppad 20150601:";;
     1480     short | recursive ) echo "Configuration of cppad 20160209:";;
    14811481   esac
    14821482  cat <<\_ACEOF
     
    16121612if $ac_init_version; then
    16131613  cat <<\_ACEOF
    1614 cppad configure 20150601
     1614cppad configure 20160209
    16151615generated by GNU Autoconf 2.69
    16161616
     
    22412241running configure, to aid debugging if configure makes a mistake.
    22422242
    2243 It was created by cppad $as_me 20150601, which was
     2243It was created by cppad $as_me 20160209, which was
    22442244generated by GNU Autoconf 2.69.  Invocation command line was
    22452245
     
    31313131# Define the identity of the package.
    31323132 PACKAGE='cppad'
    3133  VERSION='20150601'
     3133 VERSION='20160209'
    31343134
    31353135
     
    85838583# values after options handling.
    85848584ac_log="
    8585 This file was extended by cppad $as_me 20150601, which was
     8585This file was extended by cppad $as_me 20160209, which was
    85868586generated by GNU Autoconf 2.69.  Invocation command line was
    85878587
     
    86408640ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`"
    86418641ac_cs_version="\\
    8642 cppad config.status 20150601
     8642cppad config.status 20160209
    86438643configured by $0, generated by GNU Autoconf 2.69,
    86448644  with options \\"\$ac_cs_config\\"
  • trunk/configure.ac

    r3762 r3788  
    11dnl $Id$
    22dnl ---------------------------------------------------------------------------
    3 dnl CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3dnl CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44dnl
    55dnl CppAD is distributed under multiple licenses. This distribution is under
     
    1313dnl Process this file with autoconf to produce a configure script.
    1414dnl   package   version              bug-report
    15 AC_INIT([cppad], [20150601], [cppad@list.coin-or.org])
     15AC_INIT([cppad], [20160209], [cppad@list.coin-or.org])
    1616AM_SILENT_RULES([yes])
    1717
  • trunk/cppad/base_require.hpp

    r3783 r3788  
    133133%$$
    134134where the macro is defined by
    135 $codep */
     135$srccode%cpp% */
    136136# define CPPAD_AZMUL(Base) \
    137137    inline Base azmul(const Base& x, const Base& y) \
     
    141141        return x * y;     \
    142142    }
    143 /* $$
     143/* %$$
    144144
    145145$childtable%
  • trunk/cppad/example/base_adolc.hpp

    r3783 r3788  
    8787but it needs to include parts of CppAD that are used by this file.
    8888This is done with the following include commands:
    89 $codep */
     89$srccode%cpp% */
    9090# include <adolc/adolc.h>
    9191# include <cppad/base_require.hpp>
    92 /* $$
     92/* %$$
    9393
    9494$head CondExpOp$$
     
    106106values of the independent variables
    107107(in the same spirit as the CppAD $cref CondExp$$ function).
    108 $codep */
     108$srccode%cpp% */
    109109namespace CppAD {
    110110        inline adouble CondExpOp(
     
    148148        }
    149149}
    150 /* $$
     150/* %$$
    151151
    152152$head CondExpRel$$
    153153The $cref/CPPAD_COND_EXP_REL/base_cond_exp/CondExpRel/$$ macro invocation
    154 $codep */
     154$srccode%cpp% */
    155155namespace CppAD {
    156156        CPPAD_COND_EXP_REL(adouble)
    157157}
    158 /* $$
     158/* %$$
    159159
    160160$head EqualOpSeq$$
     
    162162two $code adouble$$ variables correspond to the same operations sequence.
    163163Make $code EqualOpSeq$$ an error if it gets used:
    164 $codep */
     164$srccode%cpp% */
    165165namespace CppAD {
    166166        inline bool EqualOpSeq(const adouble &x, const adouble &y)
     
    173173        }
    174174}
    175 /* $$
     175/* %$$
    176176
    177177$head Identical$$
     
    179179$code adouble$$ depends on the independent variables.
    180180To be safe (but slow) return $code false$$ in all the cases below.
    181 $codep */
     181$srccode%cpp% */
    182182namespace CppAD {
    183183        inline bool IdenticalPar(const adouble &x)
     
    190190        {       return false; }
    191191}
    192 /* $$
     192/* %$$
    193193
    194194$head Integer$$
    195 $codep */
     195$srccode%cpp% */
    196196        inline int Integer(const adouble &x)
    197197        {    return static_cast<int>( x.getValue() ); }
    198 /* $$
     198/* %$$
    199199
    200200$head azmul$$
    201 $codep */
     201$srccode%cpp% */
    202202namespace CppAD {
    203203        CPPAD_AZMUL( adouble )
    204204}
    205 /* $$
     205/* %$$
    206206
    207207$head Ordered$$
    208 $codep */
     208$srccode%cpp% */
    209209namespace CppAD {
    210210        inline bool GreaterThanZero(const adouble &x)
     
    219219        {       return fabs(x) >= fabs(y); }
    220220}
    221 /* $$
     221/* %$$
    222222
    223223$head Unary Standard Math$$
     
    249249The adolc package does not support these functions so make
    250250their use an error:
    251 $codep */
     251$srccode%cpp% */
    252252namespace CppAD {
    253253# define CPPAD_BASE_ADOLC_NO_SUPPORT(fun)                         \
     
    269269# undef CPPAD_BASE_ADOLC_NO_SUPPORT
    270270}
    271 /* $$
     271/* %$$
    272272
    273273$head sign$$
     
    275275$code codassign$$ function so that its $code adouble$$ operation sequence
    276276does not depend on the value of $icode x$$.
    277 $codep */
     277$srccode%cpp% */
    278278namespace CppAD {
    279279        inline adouble sign(const adouble& x)
     
    287287        }
    288288}
    289 /* $$
     289/* %$$
    290290
    291291$head abs$$
    292292This $cref/required/base_require/$$ function uses the adolc $code fabs$$
    293293function:
    294 $codep */
     294$srccode%cpp% */
    295295namespace CppAD {
    296296        inline adouble abs(const adouble& x)
    297297        {       return fabs(x); }
    298298}
    299 /* $$
     299/* %$$
    300300
    301301$head pow$$
     
    306306The following defines the CppAD $cref numeric_limits$$
    307307for the type $code adouble$$:
    308 $codep */
     308$srccode%cpp% */
    309309namespace CppAD {
    310310        CPPAD_NUMERIC_LIMITS(double, adouble)
    311311}
    312 /* $$
     312/* %$$
    313313
    314314$head to_string$$
    315315The following defines the CppAD $cref to_string$$ function
    316316for the type $code adouble$$:
    317 $codep */
     317$srccode%cpp% */
    318318namespace CppAD {
    319319        template <> struct to_string_struct<adouble>
     
    329329        };
    330330}
    331 /* $$
     331/* %$$
    332332
    333333$head hash_code$$
     
    337337$cref/default/base_hash/Default/$$ hashing function.
    338338For this reason, the $code adouble$$ class overrides the default definition.
    339 $codep */
     339$srccode|cpp| */
    340340namespace CppAD {
    341341        inline unsigned short hash_code(const adouble& x)
     
    353353        }
    354354}
    355 /* $$
     355/* |$$
    356356Note that after the hash codes match, the
    357357$cref/Identical/base_adolc.hpp/Identical/$$ function will be used
  • trunk/cppad/example/cppad_eigen.hpp

    r3757 r3788  
    33# define CPPAD_CPPAD_EIGEN_HPP
    44/* --------------------------------------------------------------------------
    5 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     5CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    66
    77CppAD is distributed under multiple licenses. This distribution is under
     
    6969in the Eigen matrix class definition so its vectors are
    7070$cref/simple vectors/SimpleVector/$$.
    71 $codep */
     71$srccode%cpp% */
    7272# define EIGEN_MATRIXBASE_PLUGIN <cppad/example/eigen_plugin.hpp>
    7373# include <Eigen/Core>
    7474# include <cppad/cppad.hpp>
    75 /* $$
     75/* %$$
    7676$head Eigen NumTraits$$
    7777Eigen needs the following definitions to work properly
    7878with $codei%AD<%Base%>%$$ scalars:
    79 $codep */
     79$srccode%cpp% */
    8080namespace Eigen {
    8181        template <class Base> struct NumTraits< CppAD::AD<Base> >
     
    124124        };
    125125}
    126 /* $$
     126/* %$$
    127127$head CppAD Namespace$$
    128128Eigen also needs the following definitions to work properly
    129129with $codei%AD<%Base%>%$$ scalars:
    130 $codep */
     130$srccode%cpp% */
    131131namespace CppAD {
    132132                // functions that return references
     
    163163        }
    164164}
    165 /* $$
     165/* %$$
    166166$end
    167167*/
  • trunk/cppad/example/eigen_plugin.hpp

    r3757 r3788  
    33# define CPPAD_EIGEN_PLUGIN_HPP
    44/* --------------------------------------------------------------------------
    5 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     5CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    66
    77CppAD is distributed under multiple licenses. This distribution is under
     
    2020
    2121$section Source Code for eigen_plugin.hpp$$
    22 $codep */
     22$srccode%cpp% */
    2323// Declaration needed so an Eigen vector is a simple vector
    2424typedef Scalar value_type;
    25 /* $$
     25/* %$$
    2626$end
    2727*/
  • trunk/cppad/example/matrix_mul.hpp

    r3757 r3788  
    44
    55/* --------------------------------------------------------------------------
    6 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     6CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    77
    88CppAD is distributed under multiple licenses. This distribution is under
     
    2424
    2525$head Start Class Definition$$
    26 $codep */
     26$srccode%cpp% */
    2727# include <cppad/cppad.hpp>
    2828namespace { // Begin empty namespace
     
    4646// matrix result = left * right
    4747class matrix_mul : public CppAD::atomic_base<double> {
    48 /* $$
     48/* %$$
    4949$head Constructor$$
    50 $codep */
     50$srccode%cpp% */
    5151        private:
    5252        // number of rows in left operand and in the result
     
    7676        { }
    7777        private:
    78 /* $$
     78/* %$$
    7979$head Left Operand Element Index$$
    80 $codep */
     80$srccode%cpp% */
    8181        // left matrix element index in the taylor coefficient vector tx.
    8282        size_t left(
     
    8989                return (i * n_middle_ + j) * nk + k;
    9090        }
    91 /* $$
     91/* %$$
    9292$head Right Operand Element Index$$
    93 $codep */
     93$srccode%cpp% */
    9494        // right matrix element index in the taylor coefficient vector tx.
    9595        size_t right(
     
    103103                return (offset + i * nc_result_ + j) * nk + k;
    104104        }
    105 /* $$
     105/* %$$
    106106$head Result Element Index$$
    107 $codep */
     107$srccode%cpp% */
    108108        // result matrix element index in the taylor coefficient vector ty.
    109109        size_t result(
     
    116116                return (i * nc_result_ + j) * nk + k;
    117117        }
    118 /* $$
     118/* %$$
    119119$head Forward Matrix Multipliy$$
    120 $codep */
     120$srccode%cpp% */
    121121        // Forward mode multiply Taylor coefficients in tx and sum into ty
    122122        // (for one pair of left and right orders)
     
    145145                }
    146146        }
    147 /* $$
     147/* %$$
    148148$head Reverse Matrix Multipliy$$
    149 $codep */
     149$srccode%cpp% */
    150150        // Reverse mode partials of Taylor coefficients and sum into px
    151151        // (for one pair of left and right orders)
     
    179179                return;
    180180        }
    181 /* $$
     181/* %$$
    182182$head forward$$
    183 $codep */
     183$srccode%cpp% */
    184184        // forward mode routine called by CppAD
    185185        bool forward(
     
    237237                return true;
    238238        }
    239 /* $$
     239/* %$$
    240240$head reverse$$
    241 $codep */
     241$srccode%cpp% */
    242242        // reverse mode routine called by CppAD
    243243        virtual bool reverse(
     
    269269                return true;
    270270        }
    271 /* $$
     271/* %$$
    272272$head for_sparse_jac$$
    273 $codep */
     273$srccode%cpp% */
    274274        // forward Jacobian sparsity routine called by CppAD
    275275        virtual bool for_sparse_jac(
     
    327327                return true;
    328328        }
    329 /* $$
     329/* %$$
    330330$head rev_sparse_jac$$
    331 $codep */
     331$srccode%cpp% */
    332332        // reverse Jacobian sparsity routine called by CppAD
    333333        virtual bool rev_sparse_jac(
     
    392392                return true;
    393393        }
    394 /* $$
     394/* %$$
    395395$head rev_sparse_hes$$
    396 $codep */
     396$srccode%cpp% */
    397397        // reverse Hessian sparsity routine called by CppAD
    398398        virtual bool rev_sparse_hes(
     
    516516        }
    517517
    518 /* $$
     518/* %$$
    519519$head End Class Definition$$
    520 $codep */
     520$srccode%cpp% */
    521521}; // End of matrix_mul class
    522522}  // End empty namespace
    523 /* $$
     523/* %$$
    524524$$ $comment end nospell$$
    525525$end
  • trunk/cppad/local/base_complex.hpp

    r3768 r3788  
    33# define CPPAD_BASE_COMPLEX_HPP
    44/* --------------------------------------------------------------------------
    5 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     5CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    66
    77CppAD is distributed under multiple licenses. This distribution is under
     
    7070in addition to including
    7171$cref/base_require.hpp/base_require/Include Order/$$
    72 $codep */
     72$srccode%cpp% */
    7373# include <limits>
    7474# include <complex>
     
    7676# include <cppad/local/cppad_assert.hpp>
    7777
    78 /* $$
     78/* %$$
    7979
    8080$head CondExpOp$$
     
    8383$cref/not ordered/base_cond_exp/CondExpTemplate/Not Ordered/$$.
    8484Hence its $code CondExpOp$$ function is defined by
    85 $codep */
     85$srccode%cpp% */
    8686namespace CppAD {
    8787        inline std::complex<double> CondExpOp(
     
    9999        }
    100100}
    101 /* $$
     101/* %$$
    102102
    103103$head CondExpRel$$
    104104The $cref/CPPAD_COND_EXP_REL/base_cond_exp/CondExpRel/$$ macro invocation
    105 $codep */
     105$srccode%cpp% */
    106106namespace CppAD {
    107107        CPPAD_COND_EXP_REL( std::complex<double> )
    108108}
    109 /* $$
     109/* %$$
    110110used $code CondExpOp$$ above to
    111111define $codei%CondExp%Rel%$$ for $code std::complex<double>$$ arguments
     
    116116Complex numbers do not carry operation sequence information.
    117117Thus they are equal in this sense if and only if there values are equal.
    118 $codep */
     118$srccode%cpp% */
    119119namespace CppAD {
    120120        inline bool EqualOpSeq(
     
    124124        }
    125125}
    126 /* $$
     126/* %$$
    127127
    128128$head Identical$$
    129129Complex numbers do not carry operation sequence information.
    130130Thus they are all parameters so the identical functions just check values.
    131 $codep */
     131$srccode%cpp% */
    132132namespace CppAD {
    133133        inline bool IdenticalPar(const std::complex<double> &x)
     
    141141        {       return (x == y); }
    142142}
    143 /* $$
     143/* %$$
    144144
    145145$head Ordered$$
    146146Complex types do not support comparison operators,
    147 $codep */
     147$srccode%cpp% */
    148148# undef  CPPAD_USER_MACRO
    149149# define CPPAD_USER_MACRO(Fun)                                     \
     
    166166        {       return std::abs(x) >= std::abs(y); }
    167167}
    168 /* $$
     168/* %$$
    169169
    170170$head Integer$$
     
    172172with the CppAD user specifications for complex arguments to the
    173173$cref/Integer/Integer/x/Complex Types/$$ function:
    174 $codep */
     174$srccode%cpp% */
    175175namespace CppAD {
    176176        inline int Integer(const std::complex<double> &x)
    177177        {       return static_cast<int>( x.real() ); }
    178178}
    179 /* $$
     179/* %$$
    180180
    181181$head azmul$$
    182 $codep */
     182$srccode%cpp% */
    183183namespace CppAD {
    184184        CPPAD_AZMUL( std::complex<double> )
    185185}
    186 /* $$
     186/* %$$
    187187
    188188$head isnan$$
     
    196196We avoid this ambiguity by defining a non-template version of
    197197this function in the CppAD namespace.
    198 $codep */
     198$srccode%cpp% */
    199199namespace CppAD {
    200200        inline bool isnan(const std::complex<double>& z)
     
    202202        }
    203203}
    204 /* $$
     204/* %$$
    205205
    206206$head Valid Unary Math$$
     
    208208math functions that are valid with complex arguments and are
    209209required to use $code AD< std::complex<double> >$$.
    210 $codep */
     210$srccode%cpp% */
    211211namespace CppAD {
    212212        CPPAD_STANDARD_MATH_UNARY(std::complex<double>, cos)
     
    218218        CPPAD_STANDARD_MATH_UNARY(std::complex<double>, sqrt)
    219219}
    220 /* $$
     220/* %$$
    221221
    222222$head Invalid Unary Math$$
     
    224224math functions that are invalid with complex arguments and are
    225225required to use $code AD< std::complex<double> >$$.
    226 $codep */
     226$srccode%cpp% */
    227227# undef  CPPAD_USER_MACRO
    228228# define CPPAD_USER_MACRO(Fun)                                     \
     
    250250# endif
    251251}
    252 /* $$
     252/* %$$
    253253
    254254$head pow $$
    255255The following defines a $code CppAD::pow$$ function that
    256256is required to use $code AD< std::complex<double> >$$:
    257 $codep */
     257$srccode%cpp% */
    258258namespace CppAD {
    259259        inline std::complex<double> pow(
     
    262262        {       return std::pow(x, y); }
    263263}
    264 /*$$
     264/* %$$
    265265
    266266$head numeric_limits$$
    267267The following defines the CppAD $cref numeric_limits$$
    268268for the type $code std::complex<double>$$:
    269 $codep */
     269$srccode%cpp% */
    270270namespace CppAD {
    271271        CPPAD_NUMERIC_LIMITS(double, std::complex<double>)
    272272}
    273 /*$$
     273/* %$$
    274274
    275275$head to_string$$
    276276The following defines the function CppAD $cref to_string$$
    277277for the type $code std::complex<double>$$:
    278 $codep */
     278$srccode%cpp% */
    279279namespace CppAD {
    280280        CPPAD_TO_STRING(std::complex<double>)
    281281}
    282 /* $$
     282/* %$$
    283283$end
    284284*/
  • trunk/cppad/local/base_double.hpp

    r3781 r3788  
    5858$cref/ordered type/base_cond_exp/CondExpTemplate/Ordered Type/$$.
    5959Hence its $code CondExpOp$$ function is defined by
    60 $codep */
     60$srccode%cpp% */
    6161namespace CppAD {
    6262        inline double CondExpOp(
     
    6969        }
    7070}
    71 /* $$
     71/* %$$
    7272
    7373$head CondExpRel$$
    7474The $cref/CPPAD_COND_EXP_REL/base_cond_exp/CondExpRel/$$ macro invocation
    75 $codep */
     75$srccode%cpp% */
    7676namespace CppAD {
    7777        CPPAD_COND_EXP_REL(double)
    7878}
    79 /* $$
     79/* %$$
    8080uses $code CondExpOp$$ above to
    8181define $codei%CondExp%Rel%$$ for $code double$$ arguments
     
    8585$head EqualOpSeq$$
    8686The type $code double$$ is simple (in this respect) and so we define
    87 $codep */
     87$srccode%cpp% */
    8888namespace CppAD {
    8989        inline bool EqualOpSeq(const double& x, const double& y)
    9090        {       return x == y; }
    9191}
    92 /* $$
     92/* %$$
    9393
    9494$head Identical$$
    9595The type $code double$$ is simple (in this respect) and so we define
    96 $codep */
     96$srccode%cpp% */
    9797namespace CppAD {
    9898        inline bool IdenticalPar(const double& x)
     
    105105        {       return (x == y); }
    106106}
    107 /* $$
     107/* %$$
    108108
    109109$head Integer$$
    110 $codep */
     110$srccode%cpp% */
    111111namespace CppAD {
    112112        inline int Integer(const double& x)
    113113        {       return static_cast<int>(x); }
    114114}
    115 /* $$
     115/* %$$
    116116
    117117$head azmul$$
    118 $codep */
     118$srccode%cpp% */
    119119namespace CppAD {
    120120        CPPAD_AZMUL( double )
    121121}
    122 /* $$
     122/* %$$
    123123
    124124$head Ordered$$
    125125The $code double$$ type supports ordered comparisons
    126 $codep */
     126$srccode%cpp% */
    127127namespace CppAD {
    128128        inline bool GreaterThanZero(const double& x)
     
    137137        {       return std::fabs(x) >= std::fabs(y); }
    138138}
    139 /* $$
     139/* %$$
    140140
    141141$head Unary Standard Math$$
     
    146146Note this also defines the $cref/float/base_float.hpp/Unary Standard Math/$$
    147147versions of these functions.
    148 $codep */
     148$srccode%cpp% */
    149149namespace CppAD {
    150150        using std::acos;
     
    171171# endif
    172172}
    173 /* $$
     173/* %$$
    174174The absolute value function is special because its $code std$$ name is
    175175$code fabs$$
    176 $codep */
     176$srccode%cpp% */
    177177namespace CppAD {
    178178        inline double abs(const double& x)
    179179        {       return std::fabs(x); }
    180180}
    181 /* $$
     181/* %$$
    182182
    183183$head sign$$
    184184The following defines the $code CppAD::sign$$ function that
    185185is required to use $code AD<double>$$:
    186 $codep */
     186$srccode%cpp% */
    187187namespace CppAD {
    188188        inline double sign(const double& x)
     
    194194        }
    195195}
    196 /* $$
     196/* %$$
    197197
    198198$head pow$$
     
    202202this has the exact same signature as $code std::pow$$,
    203203so use it instead of defining another function.
    204 $codep */
     204$srccode%cpp% */
    205205namespace CppAD {
    206206        using std::pow;
    207207}
    208 /*$$
     208/* %$$
    209209
    210210$head numeric_limits$$
    211211The following defines the CppAD $cref numeric_limits$$
    212212for the type $code double$$:
    213 $codep */
     213$srccode%cpp% */
    214214namespace CppAD {
    215215        CPPAD_NUMERIC_LIMITS(double, double)
    216216}
    217 /*$$
     217/* %$$
    218218
    219219$head to_string$$
  • trunk/cppad/local/base_float.hpp

    r3781 r3788  
    5858$cref/ordered type/base_cond_exp/CondExpTemplate/Ordered Type/$$.
    5959Hence its $code CondExpOp$$ function is defined by
    60 $codep */
     60$srccode%cpp% */
    6161namespace CppAD {
    6262        inline float CondExpOp(
     
    6969        }
    7070}
    71 /* $$
     71/* %$$
    7272
    7373$head CondExpRel$$
    7474The $cref/CPPAD_COND_EXP_REL/base_cond_exp/CondExpRel/$$ macro invocation
    75 $codep */
     75$srccode%cpp% */
    7676namespace CppAD {
    7777        CPPAD_COND_EXP_REL(float)
    7878}
    79 /* $$
     79/* %$$
    8080uses $code CondExpOp$$ above to
    8181define $codei%CondExp%Rel%$$ for $code float$$ arguments
     
    8585$head EqualOpSeq$$
    8686The type $code float$$ is simple (in this respect) and so we define
    87 $codep */
     87$srccode%cpp% */
    8888namespace CppAD {
    8989        inline bool EqualOpSeq(const float& x, const float& y)
    9090        {       return x == y; }
    9191}
    92 /* $$
     92/* %$$
    9393
    9494$head Identical$$
    9595The type $code float$$ is simple (in this respect) and so we define
    96 $codep */
     96$srccode%cpp% */
    9797namespace CppAD {
    9898        inline bool IdenticalPar(const float& x)
     
    105105        {       return (x == y); }
    106106}
    107 /* $$
     107/* %$$
    108108
    109109$head Integer$$
    110 $codep */
     110$srccode%cpp% */
    111111namespace CppAD {
    112112        inline int Integer(const float& x)
    113113        {       return static_cast<int>(x); }
    114114}
    115 /* $$
     115/* %$$
    116116
    117117$head azmul$$
    118 $codep */
     118$srccode%cpp% */
    119119namespace CppAD {
    120120        CPPAD_AZMUL( float )
    121121}
    122 /* $$
     122/* %$$
    123123
    124124$head Ordered$$
    125125The $code float$$ type supports ordered comparisons
    126 $codep */
     126$srccode%cpp% */
    127127namespace CppAD {
    128128        inline bool GreaterThanZero(const float& x)
     
    137137        {       return std::fabs(x) >= std::fabs(y); }
    138138}
    139 /* $$
     139/* %$$
    140140
    141141$head Unary Standard Math$$
     
    146146Note this also defines the $cref/double/base_double.hpp/Unary Standard Math/$$
    147147versions of these functions.
    148 $codep */
     148$srccode%cpp% */
    149149namespace CppAD {
    150150        using std::acos;
     
    172172}
    173173
    174 /* $$
     174/* %$$
    175175The absolute value function is special because its $code std$$ name is
    176176$code fabs$$
    177 $codep */
     177$srccode%cpp% */
    178178namespace CppAD {
    179179        inline float abs(const float& x)
    180180        {       return std::fabs(x); }
    181181}
    182 /* $$
     182/* %$$
    183183
    184184$head sign$$
    185185The following defines the $code CppAD::sign$$ function that
    186186is required to use $code AD<float>$$:
    187 $codep */
     187$srccode%cpp% */
    188188namespace CppAD {
    189189        inline float sign(const float& x)
     
    195195        }
    196196}
    197 /* $$
     197/* %$$
    198198$head pow$$
    199199The following defines a $code CppAD::pow$$ function that
     
    202202this has the exact same signature as $code std::pow$$,
    203203so use it instead of defining another function.
    204 $codep */
     204$srccode%cpp% */
    205205namespace CppAD {
    206206        using std::pow;
    207207}
    208 /*$$
     208/* %$$
    209209
    210210$head numeric_limits$$
    211211The following defines the CppAD $cref numeric_limits$$
    212212for the type $code float$$:
    213 $codep */
     213$srccode%cpp% */
    214214namespace CppAD {
    215215        CPPAD_NUMERIC_LIMITS(float, float)
    216216}
    217 /*$$
     217/* %$$
    218218
    219219$head to_string$$
  • trunk/cppad/local/base_limits.hpp

    r3768 r3788  
    44
    55/* --------------------------------------------------------------------------
    6 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     6CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    77
    88CppAD is distributed under multiple licenses. This distribution is under
     
    4747%$$
    4848where the macro is defined by
    49 $codep */
     49$srccode%cpp% */
    5050# define CPPAD_NUMERIC_LIMITS(Other, Base) \
    5151template <> class numeric_limits<Base>\
     
    6161        {       return static_cast<Base>( std::numeric_limits<Other>::quiet_NaN() ); }\
    6262};
    63 /* $$
     63/* %$$
    6464$end
    6565*/
  • trunk/cppad/local/base_to_string.hpp

    r3769 r3788  
    44
    55/* --------------------------------------------------------------------------
    6 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     6CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    77
    88CppAD is distributed under multiple licenses. This distribution is under
     
    4646for this type.
    4747This macro is defined as follows:
    48 $codep */
     48$srccode%cpp% */
    4949# define CPPAD_TO_STRING(Base) \
    5050template <> struct to_string_struct<Base>\
     
    5959        }\
    6060};
    61 /* $$
     61/* %$$
    6262$end
    6363------------------------------------------------------------------------------
  • trunk/cppad/local/cond_exp.hpp

    r3768 r3788  
    44
    55/* --------------------------------------------------------------------------
    6 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     6CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    77
    88CppAD is distributed under multiple licenses. This distribution is under
     
    168168example of using conditional expressions:
    169169$code
    170 $verbatim%cppad/local/atan2.hpp%0%BEGIN CondExp%// END CondExp%$$
     170$srcfile%cppad/local/atan2.hpp%0%BEGIN CondExp%// END CondExp%$$
    171171$$
    172172
  • trunk/cppad/local/test_vector.hpp

    r3757 r3788  
    44
    55/* --------------------------------------------------------------------------
    6 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     6CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    77
    88CppAD is distributed under multiple licenses. This distribution is under
     
    5252If we are using Microsofts compiler, the following code overrides the setting
    5353of $code CPPAD_BOOSTVECTOR$$:
    54 $codep */
     54$srccode%cpp% */
    5555// The next 7 lines are C++ source code.
    5656# ifdef _MSC_VER
     
    6262# endif
    6363# endif
    64 /* $$
     64/* %$$
    6565
    6666$head CppAD::vector$$
    6767By default $code CPPAD_CPPADVECTOR$$ is true
    6868and $code CPPAD_TEST_VECTOR$$ is defined by the following source code
    69 $codep */
     69$srccode%cpp% */
    7070// The next 3 line are C++ source code.
    7171# if CPPAD_CPPADVECTOR
    7272# define CPPAD_TEST_VECTOR CppAD::vector
    7373# endif
    74 /* $$
     74/* %$$
    7575If you specify $code --with-eigenvector$$ on the
    7676$cref/configure/auto_tools/Configure/$$ command line,
     
    7979(use $cref/CPPAD_TESTVECTOR/testvector/$$ for this support)
    8080so $code CppAD::vector$$ is used in this case
    81 $codep */
     81$srccode%cpp% */
    8282// The next 3 line are C++ source code.
    8383# if CPPAD_EIGENVECTOR
    8484# define CPPAD_TEST_VECTOR CppAD::vector
    8585# endif
    86 /* $$
     86/* %$$
    8787
    8888
     
    9393$code CPPAD_STDVECTOR$$ is true
    9494and $code CPPAD_TEST_VECTOR$$ is defined by the following source code
    95 $codep */
     95$srccode%cpp% */
    9696// The next 4 lines are C++ source code.
    9797# if CPPAD_STDVECTOR
     
    9999# define CPPAD_TEST_VECTOR std::vector
    100100# endif
    101 /* $$
     101/* %$$
    102102In this case CppAD will use $code std::vector$$ for its examples and tests.
    103103Use of $code CppAD::vector$$, $code std::vector$$,
     
    111111$code CPPAD_BOOSTVECTOR$$ is true
    112112and $code CPPAD_TEST_VECTOR$$ is defined by the following source code
    113 $codep */
     113$srccode%cpp% */
    114114// The next 4 lines are C++ source code.
    115115# if CPPAD_BOOSTVECTOR
     
    117117# define CPPAD_TEST_VECTOR boost::numeric::ublas::vector
    118118# endif
    119 /* $$
     119/* %$$
    120120In this case CppAD will use Ublas vectors for its examples and tests.
    121121Use of $code CppAD::vector$$, $code std::vector$$,
     
    127127The preprocessor symbol $code CppADvector$$ is defined to
    128128have the same value as $code CPPAD_TEST_VECTOR$$ but its use is deprecated:
    129 $codep */
     129$srccode%cpp% */
    130130# define CppADvector CPPAD_TEST_VECTOR
    131 /* $$
     131/* %$$
    132132$end
    133133------------------------------------------------------------------------
  • trunk/cppad/local/testvector.hpp

    r3757 r3788  
    44
    55/* --------------------------------------------------------------------------
    6 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     6CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    77
    88CppAD is distributed under multiple licenses. This distribution is under
     
    5454In this case,
    5555$code CPPAD_TESTVECTOR$$ is defined by the following source code:
    56 $codep */
     56$srccode%cpp% */
    5757# if CPPAD_CPPADVECTOR
    5858# define CPPAD_TESTVECTOR(Scalar) CppAD::vector< Scalar >
    5959# endif
    60 /* $$
     60/* %$$
    6161In this case CppAD will use its own vector for
    6262many of its examples and tests.
     
    6868In this case,
    6969$code CPPAD_TESTVECTOR$$ is defined by the following source code:
    70 $codep */
     70$srccode%cpp% */
    7171# if CPPAD_STDVECTOR
    7272# include <vector>
    7373# define CPPAD_TESTVECTOR(Scalar) std::vector< Scalar >
    7474# endif
    75 /* $$
     75/* %$$
    7676In this case CppAD will use standard vector for
    7777many of its examples and tests.
     
    8383In this case,
    8484$code CPPAD_TESTVECTOR$$ is defined by the following source code:
    85 $codep */
     85$srccode%cpp% */
    8686# if CPPAD_BOOSTVECTOR
    8787# include <boost/numeric/ublas/vector.hpp>
    8888# define CPPAD_TESTVECTOR(Scalar) boost::numeric::ublas::vector< Scalar >
    8989# endif
    90 /* $$
     90/* %$$
    9191In this case CppAD will use this boost vector for
    9292many of its examples and tests.
     
    9898In this case,
    9999$code CPPAD_TESTVECTOR$$ is defined by the following source code:
    100 $codep */
     100$srccode%cpp% */
    101101# if CPPAD_EIGENVECTOR
    102102# include <cppad/example/cppad_eigen.hpp>
    103103# define CPPAD_TESTVECTOR(Scalar) Eigen::Matrix< Scalar , Eigen::Dynamic, 1>
    104104# endif
    105 /* $$
     105/* %$$
    106106In this case CppAD will use the Eigen vector
    107107for many of its examples and tests.
  • trunk/cppad/utility/vector.hpp

    r3782 r3788  
    180180All memory allocated for the vector is freed
    181181and both its size and capacity are set to zero.
    182 The can be useful when using very large vectors
     182This can be useful when using very large vectors
    183183and when checking for memory leaks (and there are global vectors)
    184184see the $cref/memory/CppAD_vector/Memory and Parallel Mode/$$ discussion.
  • trunk/cppad_ipopt/example/CMakeLists.txt

    r3754 r3788  
    11# $Id$
    22# -----------------------------------------------------------------------------
    3 # CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44#
    55# CppAD is distributed under multiple licenses. This distribution is under
     
    4545TARGET_LINK_LIBRARIES(cppad_ipopt_example
    4646        cppad_ipopt
    47         cppad_lib
     47        ${cppad_lib}
    4848        ${ipopt_LIBRARIES}
    4949        ${colpack_libs}
  • trunk/cppad_ipopt/example/get_started.cpp

    r3757 r3788  
    11// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    4545
    4646$code
    47 $verbatim%cppad_ipopt/example/get_started.cpp%0%// BEGIN C++%// END C++%1%$$
     47$srcfile%cppad_ipopt/example/get_started.cpp%0%// BEGIN C++%// END C++%1%$$
    4848$$
    4949
  • trunk/cppad_ipopt/example/ode_check.cpp

    r3780 r3788  
    11// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    1616
    1717$code
    18 $verbatim%cppad_ipopt/example/ode_check.cpp%0%// BEGIN C++%// END C++%1%$$
     18$srcfile%cppad_ipopt/example/ode_check.cpp%0%// BEGIN C++%// END C++%1%$$
    1919$$
    2020
  • trunk/cppad_ipopt/example/ode_fast.hpp

    r3757 r3788  
    33# define CPPAD_ODE_FAST_HPP
    44/* --------------------------------------------------------------------------
    5 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     5CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    66
    77CppAD is distributed under multiple licenses. This distribution is under
     
    2323
    2424$code
    25 $verbatim%cppad_ipopt/example/ode_fast.hpp%0%// BEGIN C++%// END C++%1%$$
     25$srcfile%cppad_ipopt/example/ode_fast.hpp%0%// BEGIN C++%// END C++%1%$$
    2626$$
    2727
  • trunk/cppad_ipopt/example/ode_problem.hpp

    r3757 r3788  
    33# define CPPAD_ODE_PROBLEM_HPP
    44/* --------------------------------------------------------------------------
    5 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     5CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    66
    77CppAD is distributed under multiple licenses. This distribution is under
     
    2727
    2828$code
    29 $verbatim%cppad_ipopt/example/ode_problem.hpp%0%// BEGIN C++%// END C++%1%$$
     29$srcfile%cppad_ipopt/example/ode_problem.hpp%0%// BEGIN C++%// END C++%1%$$
    3030$$
    3131
  • trunk/cppad_ipopt/example/ode_run.hpp

    r3757 r3788  
    33# define CPPAD_ODE_RUN_HPP
    44/* --------------------------------------------------------------------------
    5 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     5CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    66
    77CppAD is distributed under multiple licenses. This distribution is under
     
    2222
    2323$code
    24 $verbatim%cppad_ipopt/example/ode_run.hpp%0%// BEGIN C++%// END C++%1%$$
     24$srcfile%cppad_ipopt/example/ode_run.hpp%0%// BEGIN C++%// END C++%1%$$
    2525$$
    2626
  • trunk/cppad_ipopt/example/ode_simple.hpp

    r3757 r3788  
    44
    55/* --------------------------------------------------------------------------
    6 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     6CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    77
    88CppAD is distributed under multiple licenses. This distribution is under
     
    2727
    2828$code
    29 $verbatim%cppad_ipopt/example/ode_simple.hpp%0%// BEGIN C++%// END C++%1%$$
     29$srcfile%cppad_ipopt/example/ode_simple.hpp%0%// BEGIN C++%// END C++%1%$$
    3030$$
    3131
  • trunk/cppad_ipopt/speed/CMakeLists.txt

    r3754 r3788  
    11# $Id$
    22# -----------------------------------------------------------------------------
    3 # CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44#
    55# CppAD is distributed under multiple licenses. This distribution is under
     
    4646        cppad_ipopt_speed
    4747        cppad_ipopt
    48         cppad_lib
     48        ${cppad_lib}
    4949        ${ipopt_LIBRARIES}
    5050        ${colpack_libs}
  • trunk/cppad_ipopt/speed/ode_speed.cpp

    r3779 r3788  
    11// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    1616
    1717$code
    18 $verbatim%cppad_ipopt/speed/ode_speed.cpp%0%// BEGIN C++%// END C++%1%$$
     18$srcfile%cppad_ipopt/speed/ode_speed.cpp%0%// BEGIN C++%// END C++%1%$$
    1919$$
    2020
  • trunk/cppad_ipopt/test/CMakeLists.txt

    r3754 r3788  
    11# $Id$
    22# -----------------------------------------------------------------------------
    3 # CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44#
    55# CppAD is distributed under multiple licenses. This distribution is under
     
    3737TARGET_LINK_LIBRARIES(cppad_ipopt_test
    3838        cppad_ipopt
    39         cppad_lib
     39        ${cppad_lib}
    4040        ${ipopt_LIBRARIES}
    4141        ${colpack_libs}
  • trunk/cppad_lib/CMakeLists.txt

    r3754 r3788  
    11# $Id$
    22# -----------------------------------------------------------------------------
    3 # CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44#
    55# CppAD is distributed under multiple licenses. This distribution is under
     
    1111# -----------------------------------------------------------------------------
    1212# Build and install the cppad_lib shared library
    13 
     13#
     14# string(REGEX REPLACE <regular_expression>
     15#        <replace_expression> <output variable>
     16#        <input> [<input>...])
     17STRING(REGEX REPLACE
     18        "([0-9][0-9][0-9][0-9])([0-9]*)[.]([0-9]*)"
     19        "\\1.\\2.\\3"
     20        soversion
     21        ${cppad_version}
     22)
     23MESSAGE(STATUS "soversion=${soversion}")
     24#
    1425#  add_library(<name> [STATIC | SHARED | MODULE] [EXCLUDE_FROM_ALL]
    1526#       source1 source2 ... sourceN)
     
    1829        cppad_colpack.cpp
    1930)
    20 
    21 # Add extra compiler flags
    22 add_cppad_cxx_flags( cppad_lib )
    23 
     31# set_target_properties(target1 target2 ...
     32# PROPERTIES prop1 value1 prop2 value2 ...)
     33SET_TARGET_PROPERTIES( cppad_lib PROPERTIES SOVERSION ${soversion} )
     34#
    2435# install(TARGETS myExe mySharedLib myStaticLib
    2536#       RUNTIME DESTINATION bin
  • trunk/doc.omh

    r3757 r3788  
    11$Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    9292$comment bin/version assumes that : follows cppad version number here$$
    9393$section
    94 cppad-20150601: A Package for Differentiation of C++ Algorithms
     94cppad-20160209: A Package for Differentiation of C++ Algorithms
    9595$$
    9696$mindex AD algorithmic differentiation automatic C++ algorithm derivative CppAD version cppad.hpp$$
  • trunk/example/CMakeLists.txt

    r3768 r3788  
    11# $Id$
    22# -----------------------------------------------------------------------------
    3 # CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44#
    55# CppAD is distributed under multiple licenses. This distribution is under
     
    216216# List of libraries to be linked into the specified target
    217217TARGET_LINK_LIBRARIES(example
    218         cppad_lib
     218        ${cppad_lib}
    219219        ${adolc_libs}
    220220        ${colpack_libs}
  • trunk/example/abort_recording.cpp

    r3757 r3788  
    11// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    2121
    2222$code
    23 $verbatim%example/abort_recording.cpp%0%// BEGIN C++%// END C++%1%$$
     23$srcfile%example/abort_recording.cpp%0%// BEGIN C++%// END C++%1%$$
    2424$$
    2525
  • trunk/example/abs.cpp

    r3757 r3788  
    11// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    2323
    2424$code
    25 $verbatim%example/abs.cpp%0%// BEGIN C++%// END C++%1%$$
     25$srcfile%example/abs.cpp%0%// BEGIN C++%// END C++%1%$$
    2626$$
    2727
  • trunk/example/acos.cpp

    r3680 r3788  
    1 /* $Id$ */
     1// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    2121
    2222$code
    23 $verbatim%example/acos.cpp%0%// BEGIN C++%// END C++%1%$$
     23$srcfile%example/acos.cpp%0%// BEGIN C++%// END C++%1%$$
    2424$$
    2525
  • trunk/example/acosh.cpp

    r3680 r3788  
    1 /* $Id$ */
     1// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    2121
    2222$code
    23 $verbatim%example/acosh.cpp%0%// BEGIN C++%// END C++%1%$$
     23$srcfile%example/acosh.cpp%0%// BEGIN C++%// END C++%1%$$
    2424$$
    2525
  • trunk/example/ad_assign.cpp

    r3757 r3788  
    11// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    2222
    2323$code
    24 $verbatim%example/ad_assign.cpp%0%// BEGIN C++%// END C++%1%$$
     24$srcfile%example/ad_assign.cpp%0%// BEGIN C++%// END C++%1%$$
    2525$$
    2626$end
  • trunk/example/ad_ctor.cpp

    r3757 r3788  
    11// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    2222
    2323$code
    24 $verbatim%example/ad_ctor.cpp%0%// BEGIN C++%// END C++%1%$$
     24$srcfile%example/ad_ctor.cpp%0%// BEGIN C++%// END C++%1%$$
    2525$$
    2626$end
  • trunk/example/ad_fun.cpp

    r3757 r3788  
    11// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    2121
    2222$code
    23 $verbatim%example/ad_fun.cpp%0%// BEGIN C++%// END C++%1%$$
     23$srcfile%example/ad_fun.cpp%0%// BEGIN C++%// END C++%1%$$
    2424$$
    2525
  • trunk/example/ad_in_c.cpp

    r3757 r3788  
    11// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    2323
    2424$code
    25 $verbatim%example/ad_in_c.cpp%0%// BEGIN C++%// END C++%1%$$
     25$srcfile%example/ad_in_c.cpp%0%// BEGIN C++%// END C++%1%$$
    2626$$
    2727
  • trunk/example/ad_input.cpp

    r3757 r3788  
    11// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    2323
    2424$code
    25 $verbatim%example/ad_input.cpp%0%// BEGIN C++%// END C++%1%$$
     25$srcfile%example/ad_input.cpp%0%// BEGIN C++%// END C++%1%$$
    2626$$
    2727
  • trunk/example/ad_output.cpp

    r3757 r3788  
    11// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    2323
    2424$code
    25 $verbatim%example/ad_output.cpp%0%// BEGIN C++%// END C++%1%$$
     25$srcfile%example/ad_output.cpp%0%// BEGIN C++%// END C++%1%$$
    2626$$
    2727
  • trunk/example/add.cpp

    r3757 r3788  
    11// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    1919
    2020$code
    21 $verbatim%example/add.cpp%0%// BEGIN C++%// END C++%1%$$
     21$srcfile%example/add.cpp%0%// BEGIN C++%// END C++%1%$$
    2222$$
    2323
  • trunk/example/add_eq.cpp

    r3757 r3788  
    11// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    2020
    2121$code
    22 $verbatim%example/add_eq.cpp%0%// BEGIN C++%// END C++%1%$$
     22$srcfile%example/add_eq.cpp%0%// BEGIN C++%// END C++%1%$$
    2323$$
    2424
  • trunk/example/asin.cpp

    r3675 r3788  
    1 /* $Id$ */
     1// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    2121
    2222$code
    23 $verbatim%example/asin.cpp%0%// BEGIN C++%// END C++%1%$$
     23$srcfile%example/asin.cpp%0%// BEGIN C++%// END C++%1%$$
    2424$$
    2525
  • trunk/example/asinh.cpp

    r3675 r3788  
    1 /* $Id$ */
     1// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    2121
    2222$code
    23 $verbatim%example/asinh.cpp%0%// BEGIN C++%// END C++%1%$$
     23$srcfile%example/asinh.cpp%0%// BEGIN C++%// END C++%1%$$
    2424$$
    2525
  • trunk/example/atan.cpp

    r3757 r3788  
    11// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    2222
    2323$code
    24 $verbatim%example/atan.cpp%0%// BEGIN C++%// END C++%1%$$
     24$srcfile%example/atan.cpp%0%// BEGIN C++%// END C++%1%$$
    2525$$
    2626
  • trunk/example/atan2.cpp

    r3757 r3788  
    11// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    2222
    2323$code
    24 $verbatim%example/atan2.cpp%0%// BEGIN C++%// END C++%1%$$
     24$srcfile%example/atan2.cpp%0%// BEGIN C++%// END C++%1%$$
    2525$$
    2626
  • trunk/example/atanh.cpp

    r3682 r3788  
    1 /* $Id$ */
     1// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    2121
    2222$code
    23 $verbatim%example/atanh.cpp%0%// BEGIN C++%// END C++%1%$$
     23$srcfile%example/atanh.cpp%0%// BEGIN C++%// END C++%1%$$
    2424$$
    2525
  • trunk/example/atomic/checkpoint.cpp

    r3721 r3788  
    1 /* $Id$ */
     1// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    4545
    4646$code
    47 $verbatim%example/atomic/checkpoint.cpp%0%// BEGIN C++%// END C++%1%$$
     47$srcfile%example/atomic/checkpoint.cpp%0%// BEGIN C++%// END C++%1%$$
    4848$$
    4949
  • trunk/example/atomic/get_started.cpp

    r3715 r3788  
    11// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    2323
    2424$head Start Class Definition$$
    25 $codep */
     25$srccode%cpp% */
    2626# include <cppad/cppad.hpp>
    2727namespace {          // isolate items below to this file
    2828using CppAD::vector; // abbreviate as vector
    2929class atomic_get_started : public CppAD::atomic_base<double> {
    30 /* $$
     30/* %$$
    3131
    3232$head Constructor$$
    33 $codep */
     33$srccode%cpp% */
    3434        public:
    3535        // constructor (could use const char* for name)
     
    3939        { }
    4040        private:
    41 /* $$
     41/* %$$
    4242$head forward$$
    43 $codep */
     43$srccode%cpp% */
    4444        // forward mode routine called by CppAD
    4545        virtual bool forward(
     
    7474                return ok;
    7575        }
    76 /* $$
     76/* %$$
    7777$head End Class Definition$$
    78 $codep */
     78$srccode%cpp% */
    7979}; // End of atomic_get_started class
    8080}  // End empty namespace
    8181
    82 /* $$
     82/* %$$
    8383$head Use Atomic Function$$
    84 $codep */
     84$srccode%cpp% */
    8585bool get_started(void)
    8686{       bool ok = true;
     
    8888        using CppAD::NearEqual;
    8989        double eps = 10. * CppAD::numeric_limits<double>::epsilon();
    90 /* $$
     90/* %$$
    9191$subhead Constructor$$
    92 $codep */
     92$srccode%cpp% */
    9393        // Create the atomic get_started object
    9494        atomic_get_started afun("atomic_get_started");
    95 /* $$
     95/* %$$
    9696$subhead Recording$$
    97 $codep */
     97$srccode%cpp% */
    9898        // Create the function f(x)
    9999        //
     
    121121        CppAD::ADFun<double> f;
    122122        f.Dependent (ax, ay);  // f(x) = x
    123 /* $$
     123/* %$$
    124124$subhead forward$$
    125 $codep */
     125$srccode%cpp% */
    126126        // check function value
    127127        double check = x0;
     
    138138        return ok;
    139139}
    140 /* $$
     140/* %$$
    141141$$ $comment end nospell$$
    142142$end
  • trunk/example/atomic/hes_sparse.cpp

    r3757 r3788  
    11// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    2323
    2424$head Start  Class Definition$$
    25 $codep */
     25$srccode%cpp% */
    2626# include <cppad/cppad.hpp>
    2727namespace {          // isolate items below to this file
     
    4545//
    4646class atomic_hes_sparse : public CppAD::atomic_base<double> {
    47 /* $$
     47/* %$$
    4848$head Constructor $$
    49 $codep */
     49$srccode%cpp% */
    5050        public:
    5151        // constructor (could use const char* for name)
     
    5454        { }
    5555        private:
    56 /* $$
     56/* %$$
    5757$head forward$$
    58 $codep */
     58$srccode%cpp% */
    5959        // forward mode routine called by CppAD
    6060        virtual bool forward(
     
    9393                return ok;
    9494        }
    95 /* $$
     95/* %$$
    9696$head for_sparse_jac$$
    97 $codep */
     97$srccode%cpp% */
    9898        // forward Jacobian set sparsity routine called by CppAD
    9999        virtual bool for_sparse_jac(
     
    114114                return true;
    115115        }
    116 /* $$
     116/* %$$
    117117$head rev_sparse_hes$$
    118 $codep */
     118$srccode%cpp% */
    119119        // reverse Hessian set sparsity routine called by CppAD
    120120        virtual bool rev_sparse_hes(
     
    166166}; // End of atomic_hes_sparse class
    167167
    168 /* $$
     168/* %$$
    169169$head Use Atomic Function$$
    170 $codep */
     170$srccode%cpp% */
    171171bool use_atomic_hes_sparse(bool x_1_variable)
    172172{       bool ok = true;
     
    252252}
    253253}  // End empty namespace
    254 /* $$
     254/* %$$
    255255$head Test with x_1 Both a Variable and a Parameter$$
    256 $codep */
     256$srccode%cpp% */
    257257bool hes_sparse(void)
    258258{       bool ok = true;
     
    263263        return ok;
    264264}
    265 /* $$
     265/* %$$
    266266$$ $comment end nospell$$
    267267$end
  • trunk/example/atomic/mat_mul.cpp

    r3757 r3788  
    11// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    3131
    3232$head Use Atomic Function$$
    33 $codep */
     33$srccode%cpp% */
    3434# include <cppad/cppad.hpp>
    3535# include <cppad/example/matrix_mul.hpp>
     
    4040        using CppAD::vector;
    4141        size_t i, j;
    42 /* $$
     42/* %$$
    4343$subhead Constructor$$
    44 $codep */
     44$srccode%cpp% */
    4545        // -------------------------------------------------------------------
    4646        // object that multiplies  2 x 2  matrices
     
    4949        size_t nc_result = 2;
    5050        matrix_mul afun(nr_result, n_middle, nc_result);
    51 /* $$
     51/* %$$
    5252$subhead Recording$$
    53 $codep */
     53$srccode%cpp% */
    5454        // start recording with four independent varables
    5555        size_t n = 4;
     
    9191        // g(x) = [ x0*x2 + x1*x3 , x0*7 + x1*8 , 5*x2  + 6*x3  , 5*7 + 6*8 ]^T
    9292        CppAD::ADFun<double> g(ax, atom_y);
    93 /* $$
     93/* %$$
    9494$subhead forward$$
    95 $codep */
     95$srccode%cpp% */
    9696        // Test zero order forward mode evaluation of g(x)
    9797        size_t m = atom_y.size();
     
    138138        ok &= ddy[2] == 0.;
    139139        ok &= ddy[3] == 0.;
    140 /* $$
     140/* %$$
    141141$subhead reverse$$
    142 $codep */
     142$srccode%cpp% */
    143143        // Test second order reverse mode
    144144        CppAD::vector<double> w(m), dw(2 * n);
     
    160160        ok &= dw[2*2 + 1] == 1.;
    161161        ok &= dw[3*2 + 1] == 2.;
    162 /* $$
     162/* %$$
    163163$subhead option$$
    164 $codep */
     164$srccode%cpp% */
    165165        //----------------------------------------------------------------------
    166166        // Test both the boolean and set sparsity at the atomic level
     
    169169                        afun.option( CppAD::atomic_base<double>::bool_sparsity_enum );
    170170                else    afun.option( CppAD::atomic_base<double>::set_sparsity_enum );
    171 /* $$
     171/* %$$
    172172$subhead for_sparse_jac$$
    173 $codep */
     173$srccode%cpp% */
    174174        // Test forward Jacobian sparsity pattern
    175175        /*
     
    201201        // s[3] == {}
    202202        ok &= s[3].empty();
    203 /* $$
     203/* %$$
    204204$subhead rev_sparse_jac$$
    205 $codep */
     205$srccode%cpp% */
    206206        // Test reverse Jacobian sparsity pattern
    207207        for(i = 0; i <  m; i++)
     
    224224        // r[3] == {}
    225225        ok &= r[3].empty();
    226 /* $$
     226/* %$$
    227227$subhead rev_sparse_hes$$
    228 $codep */
     228$srccode%cpp% */
    229229        /* Test reverse Hessian sparsity pattern
    230230        g_0^2 (x) = [ 0, 0, 1, 0 ] and for i > 0, g_i^2 = 0
     
    267267        return ok;
    268268}
    269 /* $$
     269/* %$$
    270270$$ $comment end nospell$$
    271271$end
  • trunk/example/atomic/norm_sq.cpp

    r3757 r3788  
    11// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    3737
    3838$head Start Class Definition$$
    39 $codep */
     39$srccode%cpp% */
    4040# include <cppad/cppad.hpp>
    4141namespace {           // isolate items below to this file
     
    4343//
    4444class atomic_norm_sq : public CppAD::atomic_base<double> {
    45 /* $$
     45/* %$$
    4646$head Constructor $$
    47 $codep */
     47$srccode%cpp% */
    4848        public:
    4949        // constructor (could use const char* for name)
     
    5353        { }
    5454        private:
    55 /* $$
     55/* %$$
    5656$head forward$$
    57 $codep */
     57$srccode%cpp% */
    5858        // forward mode routine called by CppAD
    5959        virtual bool forward(
     
    106106                return ok;
    107107        }
    108 /* $$
     108/* %$$
    109109$head reverse$$
    110 $codep */
     110$srccode%cpp% */
    111111        // reverse mode routine called by CppAD
    112112        virtual bool reverse(
     
    143143                return ok;
    144144        }
    145 /* $$
     145/* %$$
    146146$head for_sparse_jac$$
    147 $codep */
     147$srccode%cpp% */
    148148        // forward Jacobian bool sparsity routine called by CppAD
    149149        virtual bool for_sparse_jac(
     
    168168                return true;
    169169        }
    170 /* $$
     170/* %$$
    171171$head rev_sparse_jac$$
    172 $codep */
     172$srccode%cpp% */
    173173        // reverse Jacobian bool sparsity routine called by CppAD
    174174        virtual bool rev_sparse_jac(
     
    190190                return true;
    191191        }
    192 /* $$
     192/* %$$
    193193$head rev_sparse_hes$$
    194 $codep */
     194$srccode%cpp% */
    195195        // reverse Hessian bool sparsity routine called by CppAD
    196196        virtual bool rev_sparse_hes(
     
    241241                return true;
    242242        }
    243 /* $$
     243/* %$$
    244244$head End Class Definition$$
    245 $codep */
     245$srccode%cpp% */
    246246}; // End of atomic_norm_sq class
    247247}  // End empty namespace
    248248
    249 /* $$
     249/* %$$
    250250$head Use Atomic Function$$
    251 $codep */
     251$srccode%cpp% */
    252252bool norm_sq(void)
    253253{       bool ok = true;
     
    255255        using CppAD::NearEqual;
    256256        double eps = 10. * CppAD::numeric_limits<double>::epsilon();
    257 /* $$
     257/* %$$
    258258$subhead Constructor$$
    259 $codep */
     259$srccode%cpp% */
    260260        // --------------------------------------------------------------------
    261261        // Create the atomic reciprocal object
    262262        atomic_norm_sq afun("atomic_norm_sq");
    263 /* $$
     263/* %$$
    264264$subhead Recording$$
    265 $codep */
     265$srccode%cpp% */
    266266        // Create the function f(x)
    267267        //
     
    287287        CppAD::ADFun<double> f;
    288288        f.Dependent (ax, ay);
    289 /* $$
     289/* %$$
    290290$subhead forward$$
    291 $codep */
     291$srccode%cpp% */
    292292        // check function value
    293293        double check = x0 * x0 + x1 * x1;
     
    311311        ok &= NearEqual(y_q[0] , check,  eps, eps);
    312312
    313 /* $$
     313/* %$$
    314314$subhead reverse$$
    315 $codep */
     315$srccode%cpp% */
    316316        // first order reverse mode
    317317        q     = 1;
     
    323323        check = 2.0 * x1;
    324324        ok &= NearEqual(dw[1] , check,  eps, eps);
    325 /* $$
     325/* %$$
    326326$subhead for_sparse_jac$$
    327 $codep */
     327$srccode%cpp% */
    328328        // forward mode sparstiy pattern
    329329        size_t p = n;
     
    335335        ok  &= s1[0] == true;  // f[0] depends on x[0]
    336336        ok  &= s1[1] == true;  // f[0] depends on x[1]
    337 /* $$
     337/* %$$
    338338$subhead rev_sparse_jac$$
    339 $codep */
     339$srccode%cpp% */
    340340        // reverse mode sparstiy pattern
    341341        q = m;
     
    346346        ok  &= r2[0] == true;  // f[0] depends on x[0]
    347347        ok  &= r2[1] == true;  // f[0] depends on x[1]
    348 /* $$
     348/* %$$
    349349$subhead rev_sparse_hes$$
    350 $codep */
     350$srccode%cpp% */
    351351        // Hessian sparsity (using previous ForSparseJac call)
    352352        CppAD::vectorBool s3(m), h(p * n);
     
    361361        return ok;
    362362}
    363 /* $$
     363/* %$$
    364364$$ $comment end nospell$$
    365365$end
  • trunk/example/atomic/reciprocal.cpp

    r3757 r3788  
    11// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    3232
    3333$head Start Class Definition$$
    34 $codep */
     34$srccode%cpp% */
    3535# include <cppad/cppad.hpp>
    3636namespace {           // isolate items below to this file
     
    5454//
    5555class atomic_reciprocal : public CppAD::atomic_base<double> {
    56 /* $$
     56/* %$$
    5757$head Constructor $$
    58 $codep */
     58$srccode%cpp% */
    5959        public:
    6060        // constructor (could use const char* for name)
     
    6464        { }
    6565        private:
    66 /* $$
     66/* %$$
    6767$head forward$$
    68 $codep */
     68$srccode%cpp% */
    6969        // forward mode routine called by CppAD
    7070        virtual bool forward(
     
    122122                return ok;
    123123        }
    124 /* $$
     124/* %$$
    125125$head reverse$$
    126 $codep */
     126$srccode%cpp% */
    127127        // reverse mode routine called by CppAD
    128128        virtual bool reverse(
     
    189189                return ok;
    190190        }
    191 /* $$
     191/* %$$
    192192$head for_sparse_jac$$
    193 $codep */
     193$srccode%cpp% */
    194194        // forward Jacobian set sparsity routine called by CppAD
    195195        virtual bool for_sparse_jac(
     
    208208                return true;
    209209        }
    210 /* $$
     210/* %$$
    211211$head rev_sparse_jac$$
    212 $codep */
     212$srccode%cpp% */
    213213        // reverse Jacobian set sparsity routine called by CppAD
    214214        virtual bool rev_sparse_jac(
     
    227227                return true;
    228228        }
    229 /* $$
     229/* %$$
    230230$head rev_sparse_hes$$
    231 $codep */
     231$srccode%cpp% */
    232232        // reverse Hessian set sparsity routine called by CppAD
    233233        virtual bool rev_sparse_hes(
     
    269269                return true;
    270270        }
    271 /* $$
     271/* %$$
    272272$head End Class Definition$$
    273 $codep */
     273$srccode%cpp% */
    274274}; // End of atomic_reciprocal class
    275275}  // End empty namespace
    276276
    277 /* $$
     277/* %$$
    278278$head Use Atomic Function$$
    279 $codep */
     279$srccode%cpp% */
    280280bool reciprocal(void)
    281281{       bool ok = true;
     
    283283        using CppAD::NearEqual;
    284284        double eps = 10. * CppAD::numeric_limits<double>::epsilon();
    285 /* $$
     285/* %$$
    286286$subhead Constructor$$
    287 $codep */
     287$srccode%cpp% */
    288288        // --------------------------------------------------------------------
    289289        // Create the atomic reciprocal object
    290290        atomic_reciprocal afun("atomic_reciprocal");
    291 /* $$
     291/* %$$
    292292$subhead Recording$$
    293 $codep */
     293$srccode%cpp% */
    294294        // Create the function f(x)
    295295        //
     
    317317        CppAD::ADFun<double> f;
    318318        f.Dependent (ax, ay);  // f(x) = x
    319 /* $$
     319/* %$$
    320320$subhead forward$$
    321 $codep */
     321$srccode%cpp% */
    322322        // check function value
    323323        double check = x0;
     
    345345        check  = 0.;
    346346        ok &= NearEqual(y_q[0] , check,  eps, eps);
    347 /* $$
     347/* %$$
    348348$subhead reverse$$
    349 $codep */
     349$srccode%cpp% */
    350350        // third order reverse mode
    351351        q     = 3;
     
    358358        ok &= NearEqual(dw[1] , check,  eps, eps);
    359359        ok &= NearEqual(dw[2] , check,  eps, eps);
    360 /* $$
     360/* %$$
    361361$subhead for_sparse_jac$$
    362 $codep */
     362$srccode%cpp% */
    363363        // forward mode sparstiy pattern
    364364        size_t p = n;
     
    368368        s1    = f.ForSparseJac(p, r1);
    369369        ok  &= s1[0] == true;  // f[0] depends on x[0]
    370 /* $$
     370/* %$$
    371371$subhead rev_sparse_jac$$
    372 $codep */
     372$srccode%cpp% */
    373373        // reverse mode sparstiy pattern
    374374        q = m;
     
    378378        r2    = f.RevSparseJac(q, s2);
    379379        ok  &= r2[0] == true;  // f[0] depends on x[0]
    380 /* $$
     380/* %$$
    381381$subhead rev_sparse_hes$$
    382 $codep */
     382$srccode%cpp% */
    383383        // Hessian sparsity (using previous ForSparseJac call)
    384384        CppAD::vectorBool s3(m), h(p * n);
     
    390390        return ok;
    391391}
    392 /* $$
     392/* %$$
    393393$$ $comment end nospell$$
    394394$end
  • trunk/example/atomic/sparsity.cpp

    r3717 r3788  
    11// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    3434
    3535$head Start Class Definition$$
    36 $codep */
     36$srccode%cpp% */
    3737# include <cppad/cppad.hpp>
    3838namespace {                 // isolate items below to this file
     
    4141//
    4242class atomic_sparsity : public CppAD::atomic_base<double> {
    43 /* $$
     43/* %$$
    4444$head Constructor $$
    45 $codep */
     45$srccode%cpp% */
    4646        public:
    4747        // constructor
     
    5151        { }
    5252        private:
    53 /* $$
     53/* %$$
    5454$head forward$$
    55 $codep */
     55$srccode%cpp% */
    5656        // forward
    5757        virtual bool forward(
     
    8888                return ok;
    8989        }
    90 /* $$
     90/* %$$
    9191$head for_sparse_jac$$
    92 $codep */
     92$srccode%cpp% */
    9393        // for_sparse_jac
    9494        virtual bool for_sparse_jac(
     
    110110                return true;
    111111        }
    112 /* $$
     112/* %$$
    113113$head rev_sparse_jac$$
    114 $codep */
     114$srccode%cpp% */
    115115        virtual bool rev_sparse_jac(
    116116                size_t                                p  ,
     
    133133                return true;
    134134        }
    135 /* $$
     135/* %$$
    136136$head rev_sparse_hes$$
    137 $codep */
     137$srccode%cpp% */
    138138        virtual bool rev_sparse_hes(
    139139                const vector<bool>&                   vx,
     
    185185                return true;
    186186        }
    187 /* $$
     187/* %$$
    188188$head End Class Definition$$
    189 $codep */
     189$srccode%cpp% */
    190190}; // End of atomic_sparsity class
    191191}  // End empty namespace
    192192
    193 /* $$
     193/* %$$
    194194$head Use Atomic Function$$
    195 $codep */
     195$srccode%cpp% */
    196196bool sparsity(void)
    197197{       bool ok = true;
     
    199199        using CppAD::NearEqual;
    200200        double eps = 10. * std::numeric_limits<double>::epsilon();
    201 /* $$
     201/* %$$
    202202$subhead Constructor$$
    203 $codep */
     203$srccode%cpp% */
    204204        // Create the atomic get_started object
    205205        atomic_sparsity afun("atomic_sparsity");
    206 /* $$
     206/* %$$
    207207$subhead Recording$$
    208 $codep */
     208$srccode%cpp% */
    209209        size_t n = 3;
    210210        size_t m = 2;
     
    227227        ok &= NearEqual(ay[1] , ax[0] * ax[1],  eps, eps);
    228228
    229 /* $$
     229/* %$$
    230230$subhead forsparse_jac and rev_sparse_jac$$
    231 $codep */
     231$srccode%cpp% */
    232232        for(size_t dir = 0; dir < 2; dir++)
    233233        {       size_t ell;
     
    258258                ok  &= s[1 * n + 2] == false;
    259259        }
    260 /* $$
     260/* %$$
    261261$subhead rev_sparse_hes$$
    262 $codep */
     262$srccode%cpp% */
    263263        vectorBool s(m), h(n * n);
    264264        s[0] = true;
     
    276276        return ok;
    277277}
    278 /* $$
     278/* %$$
    279279$$ $comment end nospell$$
    280280$end
  • trunk/example/atomic/tangent.cpp

    r3757 r3788  
    11// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    3232
    3333$head Start Class Definition$$
    34 $codep */
     34$srccode%cpp% */
    3535# include <cppad/cppad.hpp>
    3636namespace { // Begin empty namespace
     
    5454//
    5555class atomic_tangent : public CppAD::atomic_base<float> {
    56 /* $$
     56/* %$$
    5757$head Constructor $$
    58 $codep */
     58$srccode%cpp% */
    5959        private:
    6060        const bool hyperbolic_; // is this hyperbolic tangent
     
    6666        { }
    6767        private:
    68 /* $$
     68/* %$$
    6969$head forward$$
    70 $codep */
     70$srccode%cpp% */
    7171        // forward mode routine called by CppAD
    7272        bool forward(
     
    123123                return true;
    124124        }
    125 /* $$
     125/* %$$
    126126$head reverse$$
    127 $codep */
     127$srccode%cpp% */
    128128        // reverse mode routine called by CppAD
    129129        virtual bool reverse(
     
    179179                return true;
    180180        }
    181 /* $$
     181/* %$$
    182182$head for_sparse_jac$$
    183 $codep */
     183$srccode%cpp% */
    184184        // forward Jacobian sparsity routine called by CppAD
    185185        virtual bool for_sparse_jac(
     
    216216                return true;
    217217        }
    218 /* $$
     218/* %$$
    219219$head rev_sparse_jac$$
    220 $codep */
     220$srccode%cpp% */
    221221        // reverse Jacobian sparsity routine called by CppAD
    222222        virtual bool rev_sparse_jac(
     
    249249                return true;
    250250        }
    251 /* $$
     251/* %$$
    252252$head rev_sparse_hes$$
    253 $codep */
     253$srccode%cpp% */
    254254        // reverse Hessian sparsity routine called by CppAD
    255255        virtual bool rev_sparse_hes(
     
    335335                return true;
    336336        }
    337 /* $$
     337/* %$$
    338338$head End Class Definition$$
    339 $codep */
     339$srccode%cpp% */
    340340}; // End of atomic_tangent class
    341341}  // End empty namespace
    342342
    343 /* $$
     343/* %$$
    344344$head Use Atomic Function$$
    345 $codep */
     345$srccode%cpp% */
    346346bool tangent(void)
    347347{       bool ok = true;
     
    349349        using CppAD::NearEqual;
    350350        float eps = 10.f * CppAD::numeric_limits<float>::epsilon();
    351 /* $$
     351/* %$$
    352352$subhead Constructor$$
    353 $codep */
     353$srccode%cpp% */
    354354        // --------------------------------------------------------------------
    355355        // Creater a tan and tanh object
    356356        atomic_tangent my_tan("my_tan", false), my_tanh("my_tanh", true);
    357 /* $$
     357/* %$$
    358358$subhead Recording$$
    359 $codep */
     359$srccode%cpp% */
    360360        // domain space vector
    361361        size_t n  = 1;
     
    392392        CppAD::ADFun<float> F;
    393393        F.Dependent(ax, af);
    394 /* $$
     394/* %$$
    395395$subhead forward$$
    396 $codep */
     396$srccode%cpp% */
    397397        // check function value
    398398        float tan = std::tan(x0);
     
    412412        dx[0] = 1.;
    413413        df    = F.Forward(1, dx);
    414 /* $$
     414/* %$$
    415415$subhead reverse$$
    416 $codep */
     416$srccode%cpp% */
    417417        // compute derivative of tan - tanh using reverse mode
    418418        CppAD::vector<float> w(m), dw(n);
     
    450450        ok   &= NearEqual(ddw[0], w[0]*tanp  + w[1]*tanhp , eps, eps);
    451451        ok   &= NearEqual(ddw[1], w[0]*tanpp + w[1]*tanhpp, eps, eps);
    452 /* $$
     452/* %$$
    453453$subhead for_sparse_jac$$
    454 $codep */
     454$srccode%cpp% */
    455455        // Forward mode computation of sparsity pattern for F.
    456456        size_t p = n;
     
    462462        ok  &= (s1[1] == true);  // f[1] depends on x[0]
    463463        ok  &= (s1[2] == false); // f[2] does not depend on x[0]
    464 /* $$
     464/* %$$
    465465$subhead rev_sparse_jac$$
    466 $codep */
     466$srccode%cpp% */
    467467        // Reverse mode computation of sparsity pattern for F.
    468468        size_t q = m;
     
    478478        ok  &= (r2[1] == true);  // f[1] depends on x[0]
    479479        ok  &= (r2[2] == false); // f[2] does not depend on x[0]
    480 /* $$
     480/* %$$
    481481$subhead rev_sparse_hes$$
    482 $codep */
     482$srccode%cpp% */
    483483        // Hessian sparsity for f[0]
    484484        CppAD::vectorBool s3(m), h(p * n);
     
    494494        h    = F.RevSparseHes(p, s3);
    495495        ok  &= (h[0] == false);  // Hessian is zero
    496 /* $$
     496/* %$$
    497497$subhead Large x Values$$
    498 $codep */
     498$srccode%cpp% */
    499499        // check tanh results for a large value of x
    500500        x[0]  = std::numeric_limits<float>::max() / two;
     
    508508        return ok;
    509509}
    510 /* $$
     510/* %$$
    511511$$ $comment end nospell$$
    512512$end
  • trunk/example/azmul.cpp

    r3735 r3788  
    1 /* $Id$ */
     1// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    1919
    2020$code
    21 $verbatim%example/azmul.cpp%0%// BEGIN C++%// END C++%1%$$
     21$srcfile%example/azmul.cpp%0%// BEGIN C++%// END C++%1%$$
    2222$$
    2323
  • trunk/example/base_alloc.hpp

    r3783 r3788  
    6161This file uses some of the definitions in $cref base_require$$
    6262and $cref thread_alloc$$.
    63 $codep */
     63$srccode%cpp% */
    6464# include <cppad/base_require.hpp>
    6565# include <cppad/utility/thread_alloc.hpp>
    66 /* $$
     66/* %$$
    6767
    6868$head Computed Assignment Macro$$
     
    7474$code *=$$,
    7575$code /=$$.
    76 $codep */
     76$srccode%cpp% */
    7777# define BASE_ALLOC_ASSIGN_OPERATOR(op) \
    7878        void operator op (const base_alloc& x) \
    7979        {       *ptrdbl_ op *x.ptrdbl_; }
    80 /* $$
     80/* %$$
    8181
    8282$head Binary Operator Macro$$
     
    8888$code *$$,
    8989$code /$$.
    90 $codep */
     90$srccode%cpp% */
    9191# define BASE_ALLOC_BINARY_OPERATOR(op) const \
    9292        base_alloc operator op (const base_alloc& x) const \
     
    9797                return result; \
    9898        }
    99 /* $$
     99/* %$$
    100100
    101101$head Boolean Operator Macro$$
     
    110110$code >=$$, and
    111111$code >$$,
    112 $codep */
     112$srccode%cpp% */
    113113# define BASE_ALLOC_BOOL_OPERATOR(op) const \
    114114        bool operator op (const base_alloc& x) const \
     
    117117                return dbl op x_dbl; \
    118118        }
    119 /* $$
     119/* %$$
    120120
    121121$head Class Definition$$
     
    124124It is made more complicated by storing a pointer to a $code double$$
    125125instead of the $code double$$ value itself.
    126 $codep */
     126$srccode%cpp% */
    127127
    128128class base_alloc {
     
    174174        BASE_ALLOC_BOOL_OPERATOR(<=)
    175175};
    176 /* $$
     176/* %$$
    177177
    178178$head CondExpOp$$
    179179The type $code base_alloc$$ does not use $cref CondExp$$ operations.
    180180Hence its $code CondExpOp$$ function is defined by
    181 $codep */
     181$srccode%cpp% */
    182182namespace CppAD {
    183183        inline base_alloc CondExpOp(
     
    194194        }
    195195}
    196 /* $$
     196/* %$$
    197197
    198198$head CondExpRel$$
    199199The $cref/CPPAD_COND_EXP_REL/base_cond_exp/CondExpRel/$$ macro invocation
    200 $codep */
     200$srccode%cpp% */
    201201namespace CppAD {
    202202        CPPAD_COND_EXP_REL(base_alloc)
    203203}
    204 /* $$
     204/* %$$
    205205uses $code CondExpOp$$ above to
    206206define $codei%CondExp%Rel%$$ for $code base_alloc$$ arguments
     
    210210$head EqualOpSeq$$
    211211The type $code base_alloc$$ is simple (in this respect) and so we define
    212 $codep */
     212$srccode%cpp% */
    213213namespace CppAD {
    214214        inline bool EqualOpSeq(const base_alloc& x, const base_alloc& y)
    215215        {       return *x.ptrdbl_ == *y.ptrdbl_; }
    216216}
    217 /* $$
     217/* %$$
    218218
    219219$head Identical$$
    220220The type $code base_alloc$$ is simple (in this respect) and so we define
    221 $codep */
     221$srccode%cpp% */
    222222namespace CppAD {
    223223        inline bool IdenticalPar(const base_alloc& x)
     
    230230        {       return (*x.ptrdbl_ == *y.ptrdbl_); }
    231231}
    232 /* $$
     232/* %$$
    233233
    234234$head Output Operator$$
    235 $codep */
     235$srccode%cpp% */
    236236namespace CppAD {
    237237        std::ostream& operator << (std::ostream &os, const base_alloc& x)
     
    240240        }
    241241}
    242 /* $$
     242/* %$$
    243243
    244244$head Integer$$
    245 $codep */
     245$srccode%cpp% */
    246246namespace CppAD {
    247247        inline int Integer(const base_alloc& x)
    248248        {       return static_cast<int>(*x.ptrdbl_); }
    249249}
    250 /* $$
     250/* %$$
    251251
    252252$head azmul$$
    253 $codep */
     253$srccode%cpp% */
    254254namespace CppAD {
    255255        CPPAD_AZMUL( base_alloc )
    256256}
    257 /* $$
     257/* %$$
    258258
    259259$head Ordered$$
    260260The $code base_alloc$$ type supports ordered comparisons
    261 $codep */
     261$srccode%cpp% */
    262262namespace CppAD {
    263263        inline bool GreaterThanZero(const base_alloc& x)
     
    272272        {       return std::fabs(*x.ptrdbl_) >= std::fabs(*y.ptrdbl_); }
    273273}
    274 /* $$
     274/* %$$
    275275
    276276$head Unary Standard Math$$
     
    279279would not work with the type $code base_alloc$$ so we define
    280280a special macro for this type:
    281 $codep */
     281$srccode%cpp% */
    282282# define BASE_ALLOC_STD_MATH(fun) \
    283283        inline base_alloc fun (const base_alloc& x) \
    284284        { return   std::fun(*x.ptrdbl_); }
    285 /* $$
     285/* %$$
    286286The following invocations of the macro above define the
    287287$cref/unary standard math/base_std_math/Unary Standard Math/$$ functions
    288288(except for $code abs$$):
    289 $codep */
     289$srccode%cpp% */
    290290namespace CppAD {
    291291        BASE_ALLOC_STD_MATH(acos)
     
    303303        BASE_ALLOC_STD_MATH(tanh)
    304304}
    305 /* $$
     305/* %$$
    306306The absolute value function is special because its $code std$$ name is
    307307$code fabs$$
    308 $codep */
     308$srccode%cpp% */
    309309namespace CppAD {
    310310        inline base_alloc abs(const base_alloc& x)
    311311        {       return std::fabs(*x.ptrdbl_); }
    312312}
    313 /* $$
     313/* %$$
    314314
    315315$head erf, asinh, acosh, atanh, expm1, log1p$$
     
    320320/$$ functions
    321321required by $code AD<base_alloc>$$:
    322 $codep */
     322$srccode%cpp% */
    323323# if CPPAD_USE_CPLUSPLUS_2011
    324324        BASE_ALLOC_STD_MATH(erf)
     
    329329        BASE_ALLOC_STD_MATH(log1p)
    330330# endif
    331 /* $$
     331/* %$$
    332332
    333333$head sign$$
    334334The following defines the $code CppAD::sign$$ function that
    335335is required to use $code AD<base_alloc>$$:
    336 $codep */
     336$srccode%cpp% */
    337337namespace CppAD {
    338338        inline base_alloc sign(const base_alloc& x)
     
    344344        }
    345345}
    346 /* $$
     346/* %$$
    347347
    348348$head pow $$
    349349The following defines a $code CppAD::pow$$ function that
    350350is required to use $code AD<base_alloc>$$:
    351 $codep */
     351$srccode%cpp% */
    352352namespace CppAD {
    353353        inline base_alloc pow(const base_alloc& x, const base_alloc& y)
    354354        { return std::pow(*x.ptrdbl_, *y.ptrdbl_); }
    355355}
    356 /* $$
     356/* %$$
    357357
    358358$head numeric_limits$$
    359359The following defines the CppAD $cref numeric_limits$$
    360360for the type $code base_alloc$$:
    361 $codep */
     361$srccode%cpp% */
    362362namespace CppAD {
    363363        CPPAD_NUMERIC_LIMITS(double, base_alloc)
    364364}
    365 /* $$
     365/* %$$
    366366
    367367$head to_string$$
    368368The following defines the CppAD $cref to_string$$ function
    369369for the type $code base_alloc$$:
    370 $codep */
     370$srccode%cpp% */
    371371namespace CppAD {
    372372        CPPAD_TO_STRING(base_alloc)
    373373}
    374 /* $$
     374/* %$$
    375375
    376376$head hash_code$$
     
    378378not work well for this case because two different pointers can
    379379have the same value.
    380 $codep */
     380$srccode|cpp| */
    381381namespace CppAD {
    382382        inline unsigned short hash_code(const base_alloc& x)
     
    393393        }
    394394}
    395 /* $$
     395/* |$$
    396396$end
    397397*/
  • trunk/example/base_require.cpp

    r3757 r3788  
    11// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    2121
    2222$code
    23 $verbatim%example/base_require.cpp%0%// BEGIN C++%// END C++%1%$$
     23$srcfile%example/base_require.cpp%0%// BEGIN C++%// END C++%1%$$
    2424$$
    2525
  • trunk/example/bender_quad.cpp

    r3757 r3788  
    11// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    6060
    6161$code
    62 $verbatim%example/bender_quad.cpp%0%// BEGIN C++%// END C++%1%$$
     62$srcfile%example/bender_quad.cpp%0%// BEGIN C++%// END C++%1%$$
    6363$$
    6464
  • trunk/example/bool_fun.cpp

    r3757 r3788  
    11// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    2424
    2525$code
    26 $verbatim%example/bool_fun.cpp%0%// BEGIN C++%// END C++%1%$$
     26$srcfile%example/bool_fun.cpp%0%// BEGIN C++%// END C++%1%$$
    2727$$
    2828
  • trunk/example/bool_sparsity.cpp

    r3747 r3788  
    1 /* $Id$ */
     1// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    2323
    2424$code
    25 $verbatim%example/bool_sparsity.cpp%0%// BEGIN C++%// END C++%1%$$
     25$srcfile%example/bool_sparsity.cpp%0%// BEGIN C++%// END C++%1%$$
    2626$$
    2727
  • trunk/example/capacity_order.cpp

    r3757 r3788  
    11// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    2222
    2323$code
    24 $verbatim%example/capacity_order.cpp%0%// BEGIN C++%// END C++%1%$$
     24$srcfile%example/capacity_order.cpp%0%// BEGIN C++%// END C++%1%$$
    2525$$
    2626
  • trunk/example/check_for_nan.cpp

    r3753 r3788  
    1 /* $Id$ */
     1// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    1717
    1818$code
    19 $verbatim%example/check_for_nan.cpp%0%// BEGIN C++%// END C++%1%$$
     19$srcfile%example/check_for_nan.cpp%0%// BEGIN C++%// END C++%1%$$
    2020$$
    2121
  • trunk/example/check_numeric_type.cpp

    r3757 r3788  
    11// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    1818
    1919$code
    20 $verbatim%example/check_numeric_type.cpp%0%// BEGIN C++%// END C++%1%$$
     20$srcfile%example/check_numeric_type.cpp%0%// BEGIN C++%// END C++%1%$$
    2121$$
    2222
  • trunk/example/check_simple_vector.cpp

    r3757 r3788  
    11// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    1818
    1919$code
    20 $verbatim%example/check_simple_vector.cpp%0%// BEGIN C++%// END C++%1%$$
     20$srcfile%example/check_simple_vector.cpp%0%// BEGIN C++%// END C++%1%$$
    2121$$
    2222
  • trunk/example/colpack_hes.cpp

    r3757 r3788  
    11// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    2323
    2424$code
    25 $verbatim%example/colpack_hes.cpp%0%// BEGIN C++%// END C++%1%$$
     25$srcfile%example/colpack_hes.cpp%0%// BEGIN C++%// END C++%1%$$
    2626$$
    2727
  • trunk/example/colpack_jac.cpp

    r3757 r3788  
    11// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    2323
    2424$code
    25 $verbatim%example/colpack_jac.cpp%0%// BEGIN C++%// END C++%1%$$
     25$srcfile%example/colpack_jac.cpp%0%// BEGIN C++%// END C++%1%$$
    2626$$
    2727
  • trunk/example/compare.cpp

    r3757 r3788  
    11// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    2323
    2424$code
    25 $verbatim%example/compare.cpp%0%// BEGIN C++%// END C++%1%$$
     25$srcfile%example/compare.cpp%0%// BEGIN C++%// END C++%1%$$
    2626$$
    2727
  • trunk/example/compare_change.cpp

    r3757 r3788  
    11// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    2222
    2323$code
    24 $verbatim%example/compare_change.cpp%0%// BEGIN C++%// END C++%1%$$
     24$srcfile%example/compare_change.cpp%0%// BEGIN C++%// END C++%1%$$
    2525$$
    2626
  • trunk/example/complex_poly.cpp

    r3757 r3788  
    11// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    2525
    2626$code
    27 $verbatim%example/complex_poly.cpp%0%// BEGIN C++%// END C++%1%$$
     27$srcfile%example/complex_poly.cpp%0%// BEGIN C++%// END C++%1%$$
    2828$$
    2929
  • trunk/example/cond_exp.cpp

    r3757 r3788  
    11// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    3838
    3939$code
    40 $verbatim%example/cond_exp.cpp%0%// BEGIN C++%// END C++%1%$$
     40$srcfile%example/cond_exp.cpp%0%// BEGIN C++%// END C++%1%$$
    4141$$
    4242
  • trunk/example/conj_grad.cpp

    r3757 r3788  
    11// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    9292
    9393$code
    94 $verbatim%example/conj_grad.cpp%0%// BEGIN C++%// END C++%1%$$
     94$srcfile%example/conj_grad.cpp%0%// BEGIN C++%// END C++%1%$$
    9595$$
    9696
  • trunk/example/cos.cpp

    r3757 r3788  
    11// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    2121
    2222$code
    23 $verbatim%example/cos.cpp%0%// BEGIN C++%// END C++%1%$$
     23$srcfile%example/cos.cpp%0%// BEGIN C++%// END C++%1%$$
    2424$$
    2525
  • trunk/example/cosh.cpp

    r3757 r3788  
    11// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    2020
    2121$code
    22 $verbatim%example/cosh.cpp%0%// BEGIN C++%// END C++%1%$$
     22$srcfile%example/cosh.cpp%0%// BEGIN C++%// END C++%1%$$
    2323$$
    2424
  • trunk/example/cppad_vector.cpp

    r3757 r3788  
    11// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    2222
    2323$code
    24 $verbatim%example/cppad_vector.cpp%0%// BEGIN C++%// END C++%1%$$
     24$srcfile%example/cppad_vector.cpp%0%// BEGIN C++%// END C++%1%$$
    2525$$
    2626
  • trunk/example/dependency.cpp

    r3719 r3788  
    1 /* $Id$ */
     1// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    4848
    4949$code
    50 $verbatim%example/dependency.cpp%0%// BEGIN C++%// END C++%1%$$
     50$srcfile%example/dependency.cpp%0%// BEGIN C++%// END C++%1%$$
    5151$$
    5252
  • trunk/example/div.cpp

    r3757 r3788  
    11// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    1919
    2020$code
    21 $verbatim%example/div.cpp%0%// BEGIN C++%// END C++%1%$$
     21$srcfile%example/div.cpp%0%// BEGIN C++%// END C++%1%$$
    2222$$
    2323
  • trunk/example/div_eq.cpp

    r3757 r3788  
    11// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    2020
    2121$code
    22 $verbatim%example/div_eq.cpp%0%// BEGIN C++%// END C++%1%$$
     22$srcfile%example/div_eq.cpp%0%// BEGIN C++%// END C++%1%$$
    2323$$
    2424
  • trunk/example/eigen_array.cpp

    r3781 r3788  
    2222
    2323$code
    24 $verbatim%example/eigen_array.cpp%0%// BEGIN C++%// END C++%1%$$
     24$srcfile%example/eigen_array.cpp%0%// BEGIN C++%// END C++%1%$$
    2525$$
    2626
  • trunk/example/eigen_det.cpp

    r3757 r3788  
    11// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    2222
    2323$code
    24 $verbatim%example/eigen_det.cpp%0%// BEGIN C++%// END C++%1%$$
     24$srcfile%example/eigen_det.cpp%0%// BEGIN C++%// END C++%1%$$
    2525$$
    2626
  • trunk/example/equal_op_seq.cpp

    r3757 r3788  
    11// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    2222
    2323$code
    24 $verbatim%example/equal_op_seq.cpp%0%// BEGIN C++%// END C++%1%$$
     24$srcfile%example/equal_op_seq.cpp%0%// BEGIN C++%// END C++%1%$$
    2525$$
    2626
  • trunk/example/erf.cpp

    r3757 r3788  
    11// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    2222
    2323$code
    24 $verbatim%example/erf.cpp%0%// BEGIN C++%// END C++%1%$$
     24$srcfile%example/erf.cpp%0%// BEGIN C++%// END C++%1%$$
    2525$$
    2626
  • trunk/example/error_handler.cpp

    r3757 r3788  
    11// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    2121
    2222$code
    23 $verbatim%example/error_handler.cpp%0%// BEGIN C++%// END C++%1%$$
     23$srcfile%example/error_handler.cpp%0%// BEGIN C++%// END C++%1%$$
    2424$$
    2525
  • trunk/example/example.cpp

    r3768 r3788  
    11// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    2323
    2424$code
    25 $verbatim%example/example.cpp%0%// BEGIN C++%// END C++%1%$$
     25$srcfile%example/example.cpp%0%// BEGIN C++%// END C++%1%$$
    2626$$
    2727
  • trunk/example/exp.cpp

    r3683 r3788  
    1 /* $Id$ */
     1// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    2020
    2121$code
    22 $verbatim%example/exp.cpp%0%// BEGIN C++%// END C++%1%$$
     22$srcfile%example/exp.cpp%0%// BEGIN C++%// END C++%1%$$
    2323$$
    2424
  • trunk/example/expm1.cpp

    r3683 r3788  
    1 /* $Id$ */
     1// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    2020
    2121$code
    22 $verbatim%example/expm1.cpp%0%// BEGIN C++%// END C++%1%$$
     22$srcfile%example/expm1.cpp%0%// BEGIN C++%// END C++%1%$$
    2323$$
    2424
  • trunk/example/for_one.cpp

    r3757 r3788  
    11// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    2121
    2222$code
    23 $verbatim%example/for_one.cpp%0%// BEGIN C++%// END C++%1%$$
     23$srcfile%example/for_one.cpp%0%// BEGIN C++%// END C++%1%$$
    2424$$
    2525
  • trunk/example/for_sparse_jac.cpp

    r3757 r3788  
    11// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    2525
    2626$code
    27 $verbatim%example/for_sparse_jac.cpp%0%// BEGIN C++%// END C++%1%$$
     27$srcfile%example/for_sparse_jac.cpp%0%// BEGIN C++%// END C++%1%$$
    2828$$
    2929
  • trunk/example/for_two.cpp

    r3757 r3788  
    11// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    2222
    2323$code
    24 $verbatim%example/for_two.cpp%0%// BEGIN C++%// END C++%1%$$
     24$srcfile%example/for_two.cpp%0%// BEGIN C++%// END C++%1%$$
    2525$$
    2626
  • trunk/example/forward.cpp

    r3757 r3788  
    11// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    2020
    2121$code
    22 $verbatim%example/forward.cpp%0%// BEGIN C++%// END C++%1%$$
     22$srcfile%example/forward.cpp%0%// BEGIN C++%// END C++%1%$$
    2323$$
    2424
  • trunk/example/forward_dir.cpp

    r3757 r3788  
    11// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    2121
    2222$code
    23 $verbatim%example/forward_dir.cpp%0%// BEGIN C++%// END C++%1%$$
     23$srcfile%example/forward_dir.cpp%0%// BEGIN C++%// END C++%1%$$
    2424$$
    2525
  • trunk/example/forward_order.cpp

    r3757 r3788  
    11// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    2020
    2121$code
    22 $verbatim%example/forward_order.cpp%0%// BEGIN C++%// END C++%1%$$
     22$srcfile%example/forward_order.cpp%0%// BEGIN C++%// END C++%1%$$
    2323$$
    2424
  • trunk/example/fun_assign.cpp

    r3757 r3788  
    11// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    1919
    2020$code
    21 $verbatim%example/fun_assign.cpp%0%// BEGIN C++%// END C++%1%$$
     21$srcfile%example/fun_assign.cpp%0%// BEGIN C++%// END C++%1%$$
    2222$$
    2323
  • trunk/example/fun_check.cpp

    r3757 r3788  
    11// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    2525
    2626$code
    27 $verbatim%example/fun_check.cpp%0%// BEGIN C++%// END C++%1%$$
     27$srcfile%example/fun_check.cpp%0%// BEGIN C++%// END C++%1%$$
    2828$$
    2929
  • trunk/example/hes_lagrangian.cpp

    r3757 r3788  
    11// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    2424
    2525$code
    26 $verbatim%example/hes_lagrangian.cpp%0%// BEGIN C++%// END C++%1%$$
     26$srcfile%example/hes_lagrangian.cpp%0%// BEGIN C++%// END C++%1%$$
    2727$$
    2828
  • trunk/example/hes_lu_det.cpp

    r3757 r3788  
    11// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    2121
    2222$code
    23 $verbatim%example/hes_lu_det.cpp%0%// BEGIN C++%// END C++%1%$$
     23$srcfile%example/hes_lu_det.cpp%0%// BEGIN C++%// END C++%1%$$
    2424$$
    2525
  • trunk/example/hes_minor_det.cpp

    r3757 r3788  
    11// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    2121
    2222$code
    23 $verbatim%example/hes_minor_det.cpp%0%// BEGIN C++%// END C++%1%$$
     23$srcfile%example/hes_minor_det.cpp%0%// BEGIN C++%// END C++%1%$$
    2424$$
    2525
  • trunk/example/hes_times_dir.cpp

    r3757 r3788  
    11// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    2020
    2121$code
    22 $verbatim%example/hes_times_dir.cpp%0%// BEGIN C++%// END C++%1%$$
     22$srcfile%example/hes_times_dir.cpp%0%// BEGIN C++%// END C++%1%$$
    2323$$
    2424
  • trunk/example/hessian.cpp

    r3757 r3788  
    11// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    2323
    2424$code
    25 $verbatim%example/hessian.cpp%0%// BEGIN C++%// END C++%1%$$
     25$srcfile%example/hessian.cpp%0%// BEGIN C++%// END C++%1%$$
    2626$$
    2727
  • trunk/example/independent.cpp

    r3757 r3788  
    11// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    2020
    2121$code
    22 $verbatim%example/independent.cpp%0%// BEGIN C++%// END C++%1%$$
     22$srcfile%example/independent.cpp%0%// BEGIN C++%// END C++%1%$$
    2323$$
    2424
  • trunk/example/index_sort.cpp

    r3757 r3788  
    11// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    1919
    2020$code
    21 $verbatim%example/index_sort.cpp%0%// BEGIN C++%// END C++%1%$$
     21$srcfile%example/index_sort.cpp%0%// BEGIN C++%// END C++%1%$$
    2222$$
    2323
  • trunk/example/integer.cpp

    r3757 r3788  
    11// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    2323
    2424$code
    25 $verbatim%example/integer.cpp%0%// BEGIN C++%// END C++%1%$$
     25$srcfile%example/integer.cpp%0%// BEGIN C++%// END C++%1%$$
    2626$$
    2727
  • trunk/example/interface2c.cpp

    r3757 r3788  
    11// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    2020
    2121$code
    22 $verbatim%example/interface2c.cpp%0%// BEGIN C++%// END C++%1%$$
     22$srcfile%example/interface2c.cpp%0%// BEGIN C++%// END C++%1%$$
    2323$$
    2424
  • trunk/example/interp_onetape.cpp

    r3757 r3788  
    11// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    2828$$
    2929$code
    30 $verbatim%example/interp_onetape.cpp%0%// BEGIN C++%// END C++%1%$$
     30$srcfile%example/interp_onetape.cpp%0%// BEGIN C++%// END C++%1%$$
    3131$$
    3232
  • trunk/example/interp_retape.cpp

    r3757 r3788  
    11// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    2929$$
    3030$code
    31 $verbatim%example/interp_retape.cpp%0%// BEGIN C++%// END C++%1%$$
     31$srcfile%example/interp_retape.cpp%0%// BEGIN C++%// END C++%1%$$
    3232$$
    3333
  • trunk/example/ipopt_solve/CMakeLists.txt

    r3754 r3788  
    11# $Id$
    22# -----------------------------------------------------------------------------
    3 # CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44#
    55# CppAD is distributed under multiple licenses. This distribution is under
     
    4040# as determined by pkg-config for ipopt
    4141TARGET_LINK_LIBRARIES(example_ipopt_solve
    42         cppad_lib
     42        ${cppad_lib}
    4343        ${ipopt_LIBRARIES}
    4444        ${colpack_libs}
  • trunk/example/ipopt_solve/get_started.cpp

    r3757 r3788  
    11// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    4444
    4545$code
    46 $verbatim%example/ipopt_solve/get_started.cpp%0%// BEGIN C++%// END C++%1%$$
     46$srcfile%example/ipopt_solve/get_started.cpp%0%// BEGIN C++%// END C++%1%$$
    4747$$
    4848
  • trunk/example/ipopt_solve/ode_inverse.cpp

    r3757 r3788  
    11// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    174174implements the ODE inversion method proposed above:
    175175$code
    176 $verbatim%example/ipopt_solve/ode_inverse.cpp%0%// BEGIN C++%// END C++%1%$$
     176$srcfile%example/ipopt_solve/ode_inverse.cpp%0%// BEGIN C++%// END C++%1%$$
    177177$$
    178178
  • trunk/example/ipopt_solve/retape.cpp

    r3757 r3788  
    11// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    3030
    3131$code
    32 $verbatim%example/ipopt_solve/retape.cpp%0%// BEGIN C++%// END C++%1%$$
     32