Changeset 3735


Ignore:
Timestamp:
Oct 1, 2015 9:43:46 AM (4 years ago)
Author:
bradbell
Message:

merge to branch: trunk
from repository: https://github.com/coin-or/CppAD
start hash code: 168c5fb40a332151168cbc8e928e28910d43665f
end hash code: 69b683827ee48d567284f38e6789503d74f2b2cd

commit 69b683827ee48d567284f38e6789503d74f2b2cd
Author: Brad Bell <bradbell@…>
Date: Wed Sep 30 19:35:39 2015 -0700

Fix NUMERIC_LIMIT_VAL.

commit 7ddf32b6651a3a9e2b55d4ff1819823222fc6b21
Author: Brad Bell <bradbell@…>
Date: Tue Sep 29 06:19:05 2015 -0700

numeric_limit.sh: implementation and test of numeric_limit specialization.

commit de19d19d2b5588032491f35bd05baaad89db4211
Author: Brad Bell <bradbell@…>
Date: Mon Sep 28 08:35:20 2015 -0700

sqrt_op.hpp: remove last abort on domain error.
whats_new_15.omh: more updates.
wish_list.omh: more updates.

commit 91628f1ba37c1700b5abfa159cf8f3f8bc28040f
Author: Brad Bell <bradbell@…>
Date: Mon Sep 28 07:39:34 2015 -0700

checkpoint.hpp: change default sparsity pattern to pack.
optimize.cpp: add test of pack sparsity patterns.

commit a4b711d12e82bbca6765093ed642ca9b82cd4e2e
Author: Brad Bell <bradbell@…>
Date: Mon Sep 28 06:38:05 2015 -0700

Documentation of change to optimize in previous commit.sh.

commit 3f0f994e73d68483c14b761f6744ba1e78435dbd
Author: Brad Bell <bradbell@…>
Date: Mon Sep 28 05:54:01 2015 -0700

Use pack, bool, or set depending on users atomic function option.

commit fc7f85ac010c483297beea04c8f388e41a220d43
Author: Brad Bell <bradbell@…>
Date: Sun Sep 27 15:53:10 2015 -0700

Document replacement of zdouble by azmul (now complete).

commit 48a4f8be30fc737add6ca86e0d575d47c44e4069
Author: Brad Bell <bradbell@…>
Date: Sun Sep 27 15:17:24 2015 -0700

Test multi-level reverse conditionals for atanh and azmul, fix atanh.
mul_cond_rev.cpp: test C++11 functions when compiling for C++98.

commit 7b17a9a470114d3e2b3fc78f2809147ae4b57a95
Author: Brad Bell <bradbell@…>
Date: Sun Sep 27 14:35:58 2015 -0700

Test and fix multi-level reverse conditionals with sqrt, tan. In addition,
allow for derivative of sqrt(0) because it may be ignored by a conditional.

commit f744786ef54be2f190efa9b53b661fde0db22264
Author: Brad Bell <bradbell@…>
Date: Sun Sep 27 14:04:52 2015 -0700

Test and fix multi-level reverse conditionals for sin and sinh.

commit 3b6712fd7e18529e4c5179b368198b353eb5ebb1
Author: Brad Bell <bradbell@…>
Date: Sun Sep 27 13:45:13 2015 -0700

Test and fix mult-level conditional reverse for log1p and mutiplication.

commit ce2fc1914c3b139d788fe923db14fbd07e27743f
Author: Brad Bell <bradbell@…>
Date: Sun Sep 27 11:11:10 2015 -0700

Test and fix multi-level condional reverse for expm1, exp, log.

commit a7996f99649f5d99d421ad5d42a904f7fdd685d8
Author: Brad Bell <bradbell@…>
Date: Sun Sep 27 08:46:30 2015 -0700

Test and fix multi-level conditional reverse for cos, cosh, and erf.

commit 9a380f4325247b22d6ca5adc3911efb86b36d64a
Author: Brad Bell <bradbell@…>
Date: Sun Sep 27 07:26:02 2015 -0700

Test and fix atanh mult-level conditional reverse.

commit 8c31b2b7fa30c8c459cd359611e41894c81a3ef7
Author: Brad Bell <bradbell@…>
Date: Sun Sep 27 06:46:53 2015 -0700

Test and fix asinh and atan operators with reverse multiple level conditionals.

commit 530cb4716a5fa7661956e471ecbe04c065bfdf22
Author: Brad Bell <bradbell@…>
Date: Sun Sep 27 05:57:52 2015 -0700

Fix asin_op for reverse with multi-level conditionals.
mul_cond_rev.cpp: check asinh (no need to do anything).

commit daf22b7ec9d726870af9dd98a51a075142d16cc1
Author: Brad Bell <bradbell@…>
Date: Sat Sep 26 15:36:57 2015 -0700

Test and fix acos with multi-level reverse mode conditionals.

commit 7d4ef23cc530168b4f8e953fcabe603e1f71dc2d
Author: Brad Bell <bradbell@…>
Date: Sat Sep 26 15:13:25 2015 -0700

Test and fix multi-level reverse mode with conditionals.

commit 2e232c21fa7221ba55e33e518e2dbd04a6793d03
Author: Brad Bell <bradbell@…>
Date: Sat Sep 26 14:05:12 2015 -0700

Move mul_cond to mul_cond_rev and include it in automated tests.

commit 5101952dde64bf0fbf8154b6baca2ef12dd70027
Author: Brad Bell <bradbell@…>
Date: Sat Sep 26 14:00:38 2015 -0700

  1. Extend Zmul operators to optimize and hash_code.


div_op.hpp: use azmul to fix multiple level conditional reverse.
mul_cond.cpp: test abs and add.
optimize.hpp: must handle azmul operators.

commit abff718daea05af6c66621dba4a7c8e6e335afdd
Author: Brad Bell <bradbell@…>
Date: Sat Sep 26 09:39:45 2015 -0700

Implement sparsity calculations for azmul operations.

commit 69ae407a034eb4cc5491708620f221df41f25cb3
Author: Brad Bell <bradbell@…>
Date: Sat Sep 26 08:46:58 2015 -0700

Complete and test multiple direction forward mode azmul operations.

commit c5e8b2e43559fc4b466d5bb270ff7441099d716e
Author: Brad Bell <bradbell@…>
Date: Sat Sep 26 08:13:42 2015 -0700

Complete and test reverse mode azmul operations.

commit bb483fb3c61d99c71f6548b80c2abbd71aa1e43f
Author: Brad Bell <bradbell@…>
Date: Sat Sep 26 07:21:27 2015 -0700

Test and fix first order forward mode for azmul.

commit 38fad03be59ba9b62ea6ad629cf5051ead8636d6
Author: Brad Bell <bradbell@…>
Date: Sat Sep 26 06:39:54 2015 -0700

Add multi-level testing of azmul.

commit 589cc54f64beba310e9f22b34e28cad09a681496
Author: Brad Bell <bradbell@…>
Date: Sat Sep 26 05:52:25 2015 -0700

Remove invisible white space.

commit 5793d9e70b91144a12690e9d7d03595610bfed6f
Author: Brad Bell <bradbell@…>
Date: Sat Sep 26 05:51:50 2015 -0700

Test and fix zero order forward mode azmul operations.


forward0sweep.hpp: alphabetize multiplication operators.
op_code.hpp: fix bug in tracing (introduced yesterday).
pow.cpp: improve variable names in example, use machine epsilon.

commit 031a05b1b00ff17478a86d1cc9b45223582f981d
Author: Brad Bell <bradbell@…>
Date: Sat Sep 26 04:05:34 2015 -0700

Add the operators for azmul.

commit e28ffe0e01219f1641460119ef7ca2d5b175f114
Author: Brad Bell <bradbell@…>
Date: Fri Sep 25 20:28:29 2015 -0700

zdouble.hpp: add azmul to this base type.

commit d92554e85b87f31354fd3fc09158d763f9c56742
Author: Brad Bell <bradbell@…>
Date: Fri Sep 25 19:34:22 2015 -0700

Define azmul for each of the base type.

commit 4f9e4e63919c6e134534aa4749544f78f21d5d02
Author: Brad Bell <bradbell@…>
Date: Fri Sep 25 10:13:29 2015 -0700

Document base requirement for support of azmul.


standard_math.hpp: include user API to azmul for AD types..

commit 250dd6251376986c20713f1e1fe1fcd2c642a723
Author: Brad Bell <bradbell@…>
Date: Fri Sep 25 08:35:11 2015 -0700

Remove invisible white space.

commit aa5e7988ccadb2fdff3b693110422efc903d8e8a
Author: Brad Bell <bradbell@…>
Date: Fri Sep 25 08:34:44 2015 -0700

ad_valued.hpp: include azmul.hpp.
azmul.hpp: design for azmul (not yet implemented).
op_code.hpp: include variable * parameter operator.
pow.hpp: minor correction to a comment.
standard_math.hpp: separate Purpose from Possible Types.
wish_list.omh: Mention deprecating nan.

commit 5674349e7b97b511f2d2c430761cb14b8d4c1a17
Author: Brad Bell <bradbell@…>
Date: Fri Sep 25 05:46:48 2015 -0700

Add Zmulpv and Zmulvv operators.


check_op_code.sh: adapt to comment added after NumberOp?.

Location:
trunk
Files:
6 added
1 deleted
67 edited

Legend:

Unmodified
Added
Removed
  • trunk/bin/check_op_code.sh

    r3730 r3735  
    1919# ---------------------------------------------------------------------------
    2020# check enum list of codes are in alphabetical order
    21 sed -n -e '/^enum/,/^\tNumberOp$/p' cppad/local/op_code.hpp | \
    22         sed -e '/^enum/d' -e '/^\tNumberOp$/d' \
    23                 -e 's/^[        ]*//' -e 's/Op[, ].*//' -e '/^\/\//d' > bin/op_code.1.$$
     21sed -n -e '/^enum/,/^\tNumberOp  /p' cppad/local/op_code.hpp | sed \
     22        -e '/^enum/d' \
     23        -e '/^\tNumberOp  /d' \
     24        -e 's/^[        ]*//' \
     25        -e 's/Op[, ].*//' \
     26        -e '/^\/\//d' > bin/op_code.1.$$
    2427#
    2528sort --ignore-case bin/op_code.1.$$ > bin/op_code.2.$$
  • trunk/cppad/base_require.hpp

    r3688 r3735  
    1717$begin base_require$$
    1818$spell
     19        azmul
    1920        ostream
    2021        alloc
     
    118119$cref/base_alloc/base_alloc.hpp/Integer/$$.
    119120
    120 $head Absolute Zero$$
    121 If this base type will be used with
    122 $cref/multiple levels of AD/mul_level/$$;
    123 e.g. $codei%AD< AD<%Base%> >%$$,
    124 and $cref/reverse mode/reverse/$$ calculations will be recorded,
    125 the type $icode Base$$ must have an
    126 $cref/absolute zero/zdouble/Absolute Zero/$$.
    127 
    128 $subhead Nan$$
    129 If the type $icode Base$$ has an absolute zero,
    130 the CppAD $cref nan$$ template function must be specialized
    131 because it assumes that zero divided by zero is $code nan$$.
    132 For example, here is the specialization defined by $cref zdouble$$
     121$head Absolute Zero, azmul$$
     122The type $code Base$$ must support the syntax
    133123$codei%
    134 namespace CppAD {%$$
    135 $code
    136 $verbatim%cppad/local/zdouble.hpp%4%// BEGIN nan%// END nan%$$
    137 $$
    138 $codei }$$
     124        %z% = azmul(%x%, %y%)
     125%$$
     126where see; $cref azmul$$.
     127The following preprocessor macro invocation suffice
     128$codei%
     129namespace CppAD {
     130        CPPAD_AZMUL(%Base%)
     131}
     132%$$
     133where the macro is defined by
     134$codep */
     135# define CPPAD_AZMUL(Base) \
     136    inline Base azmul(const Base& x, const Base& y) \
     137    {   Base zero(0.0);   \
     138        if( x == zero ) \
     139            return zero;  \
     140        return x * y;     \
     141    }
     142/* $$
    139143
    140144$childtable%
  • trunk/cppad/example/base_adolc.hpp

    r3724 r3735  
    1515$begin base_adolc.hpp$$
    1616$spell
     17        azmul
    1718        expm1
    1819        atanh
     
    194195/* $$
    195196
     197$head azmul$$
     198$codep */
     199namespace CppAD {
     200        CPPAD_AZMUL( adouble )
     201}
     202/* $$
     203
    196204$head Ordered$$
    197205$codep */
  • trunk/cppad/local/abs_op.hpp

    r3320 r3735  
    44
    55/* --------------------------------------------------------------------------
    6 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
     6CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
    77
    88CppAD is distributed under multiple licenses. This distribution is under
    9 the terms of the 
     9the terms of the
    1010                    Eclipse Public License Version 1.0.
    1111
     
    3737        size_t i_z         ,
    3838        size_t i_x         ,
    39         size_t cap_order   , 
     39        size_t cap_order   ,
    4040        Base*  taylor      )
    4141{
     
    7070        size_t i_z         ,
    7171        size_t i_x         ,
    72         size_t cap_order   , 
     72        size_t cap_order   ,
    7373        Base*  taylor      )
    7474{
     
    103103        size_t i_z         ,
    104104        size_t i_x         ,
    105         size_t cap_order   , 
     105        size_t cap_order   ,
    106106        Base*  taylor      )
    107107{
     
    134134        size_t      i_z          ,
    135135        size_t      i_x          ,
    136         size_t      cap_order    , 
     136        size_t      cap_order    ,
    137137        const Base* taylor       ,
    138138        size_t      nc_partial   ,
    139139        Base*       partial      )
    140 {       size_t j;       
     140{       size_t j;
    141141
    142142        // check assumptions
     
    153153        Base* pz       = partial +    i_z * nc_partial;
    154154
     155        // do not need azmul becasue sign is either +1, -1, or zero
    155156        for(j = 0; j <= d; j++)
    156157                px[j] += sign(x[0]) * pz[j];
  • trunk/cppad/local/acos_op.hpp

    r3667 r3735  
    219219        Base* pb       = pz - nc_partial;
    220220
    221         // If pz is zero, make sure this operation has no effect
    222         // (zero times infinity or nan would be non-zero).
    223         bool skip(true);
    224         for(size_t i_d = 0; i_d <= d; i_d++)
    225                 skip &= IdenticalZero(pz[i_d]);
    226         if( skip )
    227                 return;
     221        Base inv_b0 = Base(1) / b[0];
    228222
    229223        // number of indices to access
     
    233227        {
    234228                // scale partials w.r.t b[j] by 1 / b[0]
    235                 pb[j] /= b[0];
     229                pb[j]  = azmul(pb[j], inv_b0);
    236230
    237231                // scale partials w.r.t z[j] by 1 / b[0]
    238                 pz[j] /= b[0];
     232                pz[j]  = azmul(pz[j], inv_b0);
    239233
    240234                // update partials w.r.t b^0
    241                 pb[0] -= pz[j] * z[j] + pb[j] * b[j];
     235                pb[0] -= azmul(pz[j], z[j]) + azmul(pb[j], b[j]);
    242236
    243237                // update partial w.r.t. x^0
    244                 px[0] -= pb[j] * x[j];
     238                px[0] -= azmul(pb[j], x[j]);
    245239
    246240                // update partial w.r.t. x^j
    247                 px[j] -= pz[j] + pb[j] * x[0];
     241                px[j] -= pz[j] + azmul(pb[j], x[0]);
    248242
    249243                // further scale partial w.r.t. z[j] by 1 / j
     
    252246                for(k = 1; k < j; k++)
    253247                {       // update partials w.r.t b^(j-k)
    254                         pb[j-k] -= Base(k) * pz[j] * z[k] + pb[j] * b[k];
     248                        pb[j-k] -= Base(k) * azmul(pz[j], z[k]) + azmul(pb[j], b[k]);
    255249
    256250                        // update partials w.r.t. x^k
    257                         px[k]   -= pb[j] * x[j-k];
     251                        px[k]   -= azmul(pb[j], x[j-k]);
    258252
    259253                        // update partials w.r.t. z^k
    260                         pz[k]   -= pz[j] * Base(k) * b[j-k];
     254                        pz[k]   -= Base(k) * azmul(pz[j], b[j-k]);
    261255                }
    262256                --j;
     
    264258
    265259        // j == 0 case
    266         px[0] -= ( pz[0] + pb[0] * x[0]) / b[0];
     260        px[0] -= azmul( pz[0] + azmul(pb[0], x[0]), inv_b0);
    267261}
    268262
  • trunk/cppad/local/acosh_op.hpp

    r3685 r3735  
    220220        Base* pb       = pz - nc_partial;
    221221
    222         // If pz is zero, make sure this operation has no effect
    223         // (zero times infinity or nan would be non-zero).
    224         bool skip(true);
    225         for(size_t i_d = 0; i_d <= d; i_d++)
    226                 skip &= IdenticalZero(pz[i_d]);
    227         if( skip )
    228                 return;
     222        Base inv_b0 = Base(1) / b[0];
    229223
    230224        // number of indices to access
     
    234228        {
    235229                // scale partials w.r.t b[j] by 1 / b[0]
    236                 pb[j] /= b[0];
     230                pb[j]  = azmul(pb[j], inv_b0);
    237231
    238232                // scale partials w.r.t z[j] by 1 / b[0]
    239                 pz[j] /= b[0];
     233                pz[j]  = azmul(pz[j], inv_b0);
    240234
    241235                // update partials w.r.t b^0
    242                 pb[0] -= pz[j] * z[j] + pb[j] * b[j];
     236                pb[0] -= azmul(pz[j], z[j]) + azmul(pb[j], b[j]);
    243237
    244238                // update partial w.r.t. x^0
    245                 px[0] += pb[j] * x[j];
     239                px[0] += azmul(pb[j], x[j]);
    246240
    247241                // update partial w.r.t. x^j
    248                 px[j] += pz[j] + pb[j] * x[0];
     242                px[j] += pz[j] + azmul(pb[j], x[0]);
    249243
    250244                // further scale partial w.r.t. z[j] by 1 / j
     
    253247                for(k = 1; k < j; k++)
    254248                {       // update partials w.r.t b^(j-k)
    255                         pb[j-k] -= Base(k) * pz[j] * z[k] + pb[j] * b[k];
     249                        pb[j-k] -= Base(k) * azmul(pz[j], z[k]) + azmul(pb[j], b[k]);
    256250
    257251                        // update partials w.r.t. x^k
    258                         px[k]   += pb[j] * x[j-k];
     252                        px[k]   += azmul(pb[j], x[j-k]);
    259253
    260254                        // update partials w.r.t. z^k
    261                         pz[k]   -= pz[j] * Base(k) * b[j-k];
     255                        pz[k]   -= Base(k) * azmul(pz[j], b[j-k]);
    262256                }
    263257                --j;
     
    265259
    266260        // j == 0 case
    267         px[0] += ( pz[0] + pb[0] * x[0]) / b[0];
     261        px[0] += azmul(pz[0] + azmul(pb[0], x[0]),  inv_b0);
    268262}
    269263
  • trunk/cppad/local/ad.hpp

    r3685 r3735  
    5858        // power function
    5959        friend AD pow <Base>
     60                (const AD<Base> &x, const AD<Base> &y);
     61
     62        // azmul function
     63        friend AD azmul <Base>
    6064                (const AD<Base> &x, const AD<Base> &y);
    6165
  • trunk/cppad/local/ad_tape.hpp

    r3607 r3735  
    77
    88CppAD is distributed under multiple licenses. This distribution is under
    9 the terms of the 
     9the terms of the
    1010                    Eclipse Public License Version 1.0.
    1111
     
    4141                const AD<Base>&    flag   ,
    4242                const char*        before ,
    43                 const AD<Base>&    var    , 
     43                const AD<Base>&    var    ,
    4444                const char*        after
    4545        );
     
    4747        friend AD<Base> CondExpOp <Base> (
    4848                enum CompareOp  cop          ,
    49                 const AD<Base> &left         , 
    50                 const AD<Base> &right        , 
    51                 const AD<Base> &trueCase     , 
    52                 const AD<Base> &falseCase 
     49                const AD<Base> &left         ,
     50                const AD<Base> &right        ,
     51                const AD<Base> &trueCase     ,
     52                const AD<Base> &falseCase
    5353        );
    5454        // pow
    5555        friend AD<Base> pow <Base>
    5656                (const AD<Base> &x, const AD<Base> &y);
     57        // azmul
     58        friend AD<Base> azmul <Base>
     59                (const AD<Base> &x, const AD<Base> &y);
    5760        // Parameter
    58         friend bool Parameter     <Base> 
     61        friend bool Parameter     <Base>
    5962                (const AD<Base> &u);
    6063        // Variable
    61         friend bool Variable      <Base> 
     64        friend bool Variable      <Base>
    6265                (const AD<Base> &u);
    6366        // operators -----------------------------------------------------------
     
    9295        // private data
    9396        /*!
    94         Unique identifier for this tape.  It is always greater than 
    95         CPPAD_MAX_NUM_THREADS, and different for every tape (even ones that have 
    96         been deleted). In addition, id_ % CPPAD_MAX_NUM_THREADS is the thread 
     97        Unique identifier for this tape.  It is always greater than
     98        CPPAD_MAX_NUM_THREADS, and different for every tape (even ones that have
     99        been deleted). In addition, id_ % CPPAD_MAX_NUM_THREADS is the thread
    97100        number for this tape. Set by Independent and effectively const
    98101        */
     
    108111        // add a parameter to the tape
    109112        size_t RecordParOp(const Base &x);
    110        
     113
    111114        // see CondExp.h
    112115        void RecordCondExp(
     
    148151value of the parameter that we are placing in the tape.
    149152
    150 \return 
     153\return
    151154variable index (for this recording) correpsonding to the parameter.
    152155
     
    187190The values for these vector indices are the corresponding
    188191parameter indices in the tape for the initial value of the corresponding
    189 vec_ad element. 
     192vec_ad element.
    190193
    191194\par 2DO
     
    202205        size_t start = Rec_.PutVecInd(length);
    203206
    204         // store indices of the values in VecInd 
     207        // store indices of the values in VecInd
    205208        for(i = 0; i < length; i++)
    206209        {
     
    208211                Rec_.PutVecInd( value_index );
    209212        }
    210  
     213
    211214        // return the taddr of the length (where the vector starts)
    212215        return start;
  • trunk/cppad/local/ad_valued.hpp

    r3686 r3735  
    4141# include <cppad/local/arithmetic.hpp>
    4242# include <cppad/local/standard_math.hpp>
     43# include <cppad/local/azmul.hpp>
    4344# include <cppad/local/cond_exp.hpp>
    4445# include <cppad/local/discrete.hpp>
  • trunk/cppad/local/asin_op.hpp

    r3667 r3735  
    219219        Base* pb       = pz - nc_partial;
    220220
    221         // If pz is zero, make sure this operation has no effect
    222         // (zero times infinity or nan would be non-zero).
    223         bool skip(true);
    224         for(size_t i_d = 0; i_d <= d; i_d++)
    225                 skip &= IdenticalZero(pz[i_d]);
    226         if( skip )
    227                 return;
     221        Base inv_b0 = Base(1) / b[0];
    228222
    229223        // number of indices to access
     
    233227        {
    234228                // scale partials w.r.t b[j] by 1 / b[0]
    235                 pb[j] /= b[0];
     229                pb[j]  = azmul(pb[j], inv_b0);
    236230
    237231                // scale partials w.r.t z[j] by 1 / b[0]
    238                 pz[j] /= b[0];
     232                pz[j]  = azmul(pz[j], inv_b0);
    239233
    240234                // update partials w.r.t b^0
    241                 pb[0] -= pz[j] * z[j] + pb[j] * b[j];
     235                pb[0] -= azmul(pz[j], z[j]) + azmul(pb[j], b[j]);
    242236
    243237                // update partial w.r.t. x^0
    244                 px[0] -= pb[j] * x[j];
     238                px[0] -= azmul(pb[j], x[j]);
    245239
    246240                // update partial w.r.t. x^j
    247                 px[j] += pz[j] - pb[j] * x[0];
     241                px[j] += pz[j] - azmul(pb[j], x[0]);
    248242
    249243                // further scale partial w.r.t. z[j] by 1 / j
     
    252246                for(k = 1; k < j; k++)
    253247                {       // update partials w.r.t b^(j-k)
    254                         pb[j-k] -= Base(k) * pz[j] * z[k] + pb[j] * b[k];
     248                        pb[j-k] -= Base(k) * azmul(pz[j], z[k]) + azmul(pb[j], b[k]);
    255249
    256250                        // update partials w.r.t. x^k
    257                         px[k]   -= pb[j] * x[j-k];
     251                        px[k]   -= azmul(pb[j], x[j-k]);
    258252
    259253                        // update partials w.r.t. z^k
    260                         pz[k]   -= pz[j] * Base(k) * b[j-k];
     254                        pz[k]   -= Base(k) * azmul(pz[j], b[j-k]);
    261255                }
    262256                --j;
     
    264258
    265259        // j == 0 case
    266         px[0] += ( pz[0] - pb[0] * x[0]) / b[0];
     260        px[0] += azmul(pz[0] - azmul(pb[0], x[0]), inv_b0);
    267261}
    268262
  • trunk/cppad/local/asinh_op.hpp

    r3685 r3735  
    220220        Base* pb       = pz - nc_partial;
    221221
    222         // If pz is zero, make sure this operation has no effect
    223         // (zero times infinity or nan would be non-zero).
    224         bool skip(true);
    225         for(size_t i_d = 0; i_d <= d; i_d++)
    226                 skip &= IdenticalZero(pz[i_d]);
    227         if( skip )
    228                 return;
     222        Base inv_b0 = Base(1) / b[0];
    229223
    230224        // number of indices to access
     
    234228        {
    235229                // scale partials w.r.t b[j] by 1 / b[0]
    236                 pb[j] /= b[0];
     230                pb[j]  = azmul(pb[j], inv_b0);
    237231
    238232                // scale partials w.r.t z[j] by 1 / b[0]
    239                 pz[j] /= b[0];
     233                pz[j]  = azmul(pz[j], inv_b0);
    240234
    241235                // update partials w.r.t b^0
    242                 pb[0] -= pz[j] * z[j] + pb[j] * b[j];
     236                pb[0] -= azmul(pz[j], z[j]) + azmul(pb[j], b[j]);
    243237
    244238                // update partial w.r.t. x^0
    245                 px[0] += pb[j] * x[j];
     239                px[0] += azmul(pb[j], x[j]);
    246240
    247241                // update partial w.r.t. x^j
    248                 px[j] += pz[j] + pb[j] * x[0];
     242                px[j] += pz[j] + azmul(pb[j], x[0]);
    249243
    250244                // further scale partial w.r.t. z[j] by 1 / j
     
    253247                for(k = 1; k < j; k++)
    254248                {       // update partials w.r.t b^(j-k)
    255                         pb[j-k] -= Base(k) * pz[j] * z[k] + pb[j] * b[k];
     249                        pb[j-k] -= Base(k) * azmul(pz[j], z[k]) + azmul(pb[j], b[k]);
    256250
    257251                        // update partials w.r.t. x^k
    258                         px[k]   += pb[j] * x[j-k];
     252                        px[k]   += azmul(pb[j], x[j-k]);
    259253
    260254                        // update partials w.r.t. z^k
    261                         pz[k]   -= pz[j] * Base(k) * b[j-k];
     255                        pz[k]   -= Base(k) * azmul(pz[j], b[j-k]);
    262256                }
    263257                --j;
     
    265259
    266260        // j == 0 case
    267         px[0] += ( pz[0] + pb[0] * x[0]) / b[0];
     261        px[0] += azmul(pz[0] + azmul(pb[0], x[0]), inv_b0);
    268262}
    269263
  • trunk/cppad/local/atan_op.hpp

    r3667 r3735  
    206206        Base* pb       = pz - nc_partial;
    207207
    208         // If pz is zero, make sure this operation has no effect
    209         // (zero times infinity or nan would be non-zero).
    210         bool skip(true);
    211         for(size_t i_d = 0; i_d <= d; i_d++)
    212                 skip &= IdenticalZero(pz[i_d]);
    213         if( skip )
    214                 return;
     208        Base inv_b0 = Base(1) / b[0];
    215209
    216210        // number of indices to access
     
    219213        while(j)
    220214        {       // scale partials w.r.t z[j] and b[j]
    221                 pz[j] /= b[0];
     215                pz[j]  = azmul(pz[j], inv_b0);
    222216                pb[j] *= Base(2);
    223217
    224                 pb[0] -= pz[j] * z[j];
    225                 px[j] += pz[j] + pb[j] * x[0];
    226                 px[0] += pb[j] * x[j];
     218                pb[0] -= azmul(pz[j], z[j]);
     219                px[j] += pz[j] + azmul(pb[j], x[0]);
     220                px[0] += azmul(pb[j], x[j]);
    227221
    228222                // more scaling of partials w.r.t z[j]
     
    230224
    231225                for(k = 1; k < j; k++)
    232                 {       pb[j-k] -= pz[j] * Base(k) * z[k];
    233                         pz[k]   -= pz[j] * Base(k) * b[j-k];
    234                         px[k]   += pb[j] * x[j-k];
     226                {       pb[j-k] -= Base(k) * azmul(pz[j], z[k]);
     227                        pz[k]   -= Base(k) * azmul(pz[j], b[j-k]);
     228                        px[k]   += azmul(pb[j], x[j-k]);
    235229                }
    236230                --j;
    237231        }
    238         px[0] += pz[0] / b[0] + pb[0] * Base(2) * x[0];
     232        px[0] += azmul(pz[0], inv_b0) + Base(2) * azmul(pb[0], x[0]);
    239233}
    240234
  • trunk/cppad/local/atanh_op.hpp

    r3685 r3735  
    207207        Base* pb       = pz - nc_partial;
    208208
    209         // If pz is zero, make sure this operation has no effect
    210         // (zero times infinity or nan would be non-zero).
    211         bool skip(true);
    212         for(size_t i_d = 0; i_d <= d; i_d++)
    213                 skip &= IdenticalZero(pz[i_d]);
    214         if( skip )
    215                 return;
     209        Base inv_b0 = Base(1) / b[0];
    216210
    217211        // number of indices to access
     
    220214        while(j)
    221215        {       // scale partials w.r.t z[j] and b[j]
    222                 pz[j] /= b[0];
     216                pz[j]  = azmul(pz[j], inv_b0);
    223217                pb[j] *= Base(2);
    224218
    225                 pb[0] -= pz[j] * z[j];
    226                 px[j] += pz[j] - pb[j] * x[0];
    227                 px[0] -= pb[j] * x[j];
     219                pb[0] -= azmul(pz[j], z[j]);
     220                px[j] += pz[j] - azmul(pb[j], x[0]);
     221                px[0] -= azmul(pb[j], x[j]);
    228222
    229223                // more scaling of partials w.r.t z[j]
     
    231225
    232226                for(k = 1; k < j; k++)
    233                 {       pb[j-k] -= pz[j] * Base(k) * z[k];
    234                         pz[k]   -= pz[j] * Base(k) * b[j-k];
    235                         px[k]   -= pb[j] * x[j-k];
     227                {       pb[j-k] -= Base(k) * azmul(pz[j], z[k]);
     228                        pz[k]   -= Base(k) * azmul(pz[j], b[j-k]);
     229                        px[k]   -= azmul(pb[j], x[j-k]);
    236230                }
    237231                --j;
    238232        }
    239         px[0] += pz[0] / b[0] - pb[0] * Base(2) * x[0];
     233        px[0] += azmul(pz[0], inv_b0) - Base(2) * azmul(pb[0], x[0]);
    240234}
    241235
  • trunk/cppad/local/atomic_base.hpp

    r3724 r3735  
    272272
    273273$head atomic_sparsity$$
     274Note that, if you use $cref optimize$$, these sparsity patterns are used
     275to determine the $cref/dependency/dependency.cpp/$$ relationship between
     276argument and result variables.
    274277
    275278$subhead pack_sparsity_enum$$
  • trunk/cppad/local/base_complex.hpp

    r3685 r3735  
    2222$begin base_complex.hpp$$
    2323$spell
     24        azmul
    2425        expm1
    2526        atanh
     
    181182/* $$
    182183
     184$head azmul$$
     185$codep */
     186namespace CppAD {
     187        CPPAD_AZMUL( std::complex<double> )
     188}
     189/* $$
     190
    183191$head isnan$$
    184192The gcc 4.1.1 complier defines the function
  • trunk/cppad/local/base_double.hpp

    r3685 r3735  
    1818$begin base_double.hpp$$
    1919$spell
     20        azmul
    2021        expm1
    2122        atanh
     
    114115/* $$
    115116
     117$head azmul$$
     118$codep */
     119namespace CppAD {
     120        CPPAD_AZMUL( double )
     121}
     122/* $$
     123
    116124$head Ordered$$
    117125The $code double$$ type supports ordered comparisons
  • trunk/cppad/local/base_float.hpp

    r3685 r3735  
    1818$begin base_float.hpp$$
    1919$spell
     20        azmul
    2021        expm1
    2122        atanh
     
    114115/* $$
    115116
     117$head azmul$$
     118$codep */
     119namespace CppAD {
     120        CPPAD_AZMUL( float )
     121}
     122/* $$
     123
    116124$head Ordered$$
    117125The $code float$$ type supports ordered comparisons
  • trunk/cppad/local/checkpoint.hpp

    r3724 r3735  
    530530        \param sparsity [in]
    531531        what type of sparsity patterns are computed by this function,
    532         bool_sparsity_enum or set_sparsity_enum. Default value is unspecified.
     532        pack_sparsity_enum bool_sparsity_enum, or set_sparsity_enum.
     533        The default value is unspecified.
    533534        */
    534535        template <class Algo, class ADVector>
     
    539540                ADVector&                      ay       ,
    540541                option_enum                    sparsity =
    541                                 atomic_base<Base>::bool_sparsity_enum
     542                                atomic_base<Base>::pack_sparsity_enum
    542543        ) : atomic_base<Base>(name, sparsity)
    543544        {       CheckSimpleVector< CppAD::AD<Base> , ADVector>();
  • trunk/cppad/local/cos_op.hpp

    r3667 r3735  
    212212        Base* ps       = pc - nc_partial;
    213213
    214         // If pc is zero, make sure this operation has no effect
    215         // (zero times infinity or nan would be non-zero).
    216         bool skip(true);
    217         for(size_t i_d = 0; i_d <= d; i_d++)
    218                 skip &= IdenticalZero(pc[i_d]);
    219         if( skip )
    220                 return;
    221214
    222215        // rest of this routine is identical for the following cases:
     
    230223                for(k = 1; k <= j; k++)
    231224                {
    232                         px[k]   += ps[j] * Base(k) * c[j-k];
    233                         px[k]   -= pc[j] * Base(k) * s[j-k];
    234 
    235                         ps[j-k] -= pc[j] * Base(k) * x[k];
    236                         pc[j-k] += ps[j] * Base(k) * x[k];
     225                        px[k]   += Base(k) * azmul(ps[j], c[j-k]);
     226                        px[k]   -= Base(k) * azmul(pc[j], s[j-k]);
     227
     228                        ps[j-k] -= Base(k) * azmul(pc[j], x[k]);
     229                        pc[j-k] += Base(k) * azmul(ps[j], x[k]);
    237230
    238231                }
    239232                --j;
    240233        }
    241         px[0] += ps[0] * c[0];
    242         px[0] -= pc[0] * s[0];
     234        px[0] += azmul(ps[0], c[0]);
     235        px[0] -= azmul(pc[0], s[0]);
    243236}
    244237
  • trunk/cppad/local/cosh_op.hpp

    r3667 r3735  
    212212        Base* ps       = pc - nc_partial;
    213213
    214         // If pc is zero, make sure this operation has no effect
    215         // (zero times infinity or nan would be non-zero).
    216         bool skip(true);
    217         for(size_t i_d = 0; i_d <= d; i_d++)
    218                 skip &= IdenticalZero(pc[i_d]);
    219         if( skip )
    220                 return;
    221214
    222215        // rest of this routine is identical for the following cases:
     
    230223                for(k = 1; k <= j; k++)
    231224                {
    232                         px[k]   += ps[j] * Base(k) * c[j-k];
    233                         px[k]   += pc[j] * Base(k) * s[j-k];
    234 
    235                         ps[j-k] += pc[j] * Base(k) * x[k];
    236                         pc[j-k] += ps[j] * Base(k) * x[k];
     225                        px[k]   += Base(k) * azmul(ps[j], c[j-k]);
     226                        px[k]   += Base(k) * azmul(pc[j], s[j-k]);
     227
     228                        ps[j-k] += Base(k) * azmul(pc[j], x[k]);
     229                        pc[j-k] += Base(k) * azmul(ps[j], x[k]);
    237230
    238231                }
    239232                --j;
    240233        }
    241         px[0] += ps[0] * c[0];
    242         px[0] += pc[0] * s[0];
     234        px[0] += azmul(ps[0], c[0]);
     235        px[0] += azmul(pc[0], s[0]);
    243236}
    244237
  • trunk/cppad/local/declare_ad.hpp

    r3685 r3735  
    105105                const AD<Base> &x, const AD<Base> &y);
    106106
     107        // azmul
     108        template <class Base> AD<Base> azmul (
     109                const AD<Base> &x, const AD<Base> &y);
     110
    107111        // NearEqual
    108112        template <class Base> bool NearEqual(
  • trunk/cppad/local/div_op.hpp

    r3667 r3735  
    190190        Base* pz = partial + i_z    * nc_partial;
    191191
    192         // If pz is zero, make sure this operation has no effect
    193         // (zero times infinity or nan would be non-zero).
    194         bool skip(true);
    195         for(size_t i_d = 0; i_d <= d; i_d++)
    196                 skip &= IdenticalZero(pz[i_d]);
    197         if( skip )
    198                 return;
    199 
    200192        // Using CondExp, it can make sense to divide by zero
    201193        // so do not make it an error.
     194        Base inv_y0 = Base(1) / y[0];
    202195
    203196        size_t k;
     
    207200        {       --j;
    208201                // scale partial w.r.t. z[j]
    209                 pz[j] /= y[0];
     202                pz[j] = azmul(pz[j], inv_y0);
    210203
    211204                px[j] += pz[j];
    212205                for(k = 1; k <= j; k++)
    213                 {       pz[j-k] -= pz[j] * y[k];
    214                         py[k]   -= pz[j] * z[j-k];
     206                {       pz[j-k] -= azmul(pz[j], y[k]  );
     207                        py[k]   -= azmul(pz[j], z[j-k]);
    215208                }
    216                 py[0] -= pz[j] * z[j];
     209                py[0] -= azmul(pz[j], z[j]);
    217210        }
    218211}
     
    387380        Base* pz = partial + i_z    * nc_partial;
    388381
    389         // If pz is zero, make sure this operation has no effect
    390         // (zero times infinity or nan would be non-zero).
    391         bool skip(true);
    392         for(size_t i_d = 0; i_d <= d; i_d++)
    393                 skip &= IdenticalZero(pz[i_d]);
    394         if( skip )
    395                 return;
    396 
    397382        // Using CondExp, it can make sense to divide by zero so do not
    398383        // make it an error.
     384        Base inv_y0 = Base(1) / y[0];
    399385
    400386        size_t k;
     
    404390        {       --j;
    405391                // scale partial w.r.t z[j]
    406                 pz[j] /= y[0];
     392                pz[j] = azmul(pz[j], inv_y0);
    407393
    408394                for(k = 1; k <= j; k++)
    409                 {       pz[j-k] -= pz[j] * y[k];
    410                         py[k]   -= pz[j] * z[j-k];
     395                {       pz[j-k] -= azmul(pz[j], y[k]  );
     396                        py[k]   -= azmul(pz[j], z[j-k] );
    411397                }
    412                 py[0] -= pz[j] * z[j];
     398                py[0] -= azmul(pz[j], z[j]);
    413399        }
    414400}
     
    576562        // Using CondExp, it can make sense to divide by zero
    577563        // so do not make it an error.
     564        Base inv_y = Base(1) / y;
    578565
    579566        // number of indices to access
     
    581568        while(j)
    582569        {       --j;
    583                 px[j] += pz[j] / y;
     570                px[j] += azmul(pz[j], inv_y);
    584571        }
    585572}
  • trunk/cppad/local/erf_op.hpp

    r3685 r3735  
    389389        {       pz_4[j] /= Base(j);
    390390                for(size_t k = 1; k <= j; k++)
    391                 {       px[k]     += pz_4[j] * z_3[j-k] * Base(k);
    392                         pz_3[j-k] += pz_4[j] * x[k] * Base(k);
     391                {       px[k]     += azmul(pz_4[j], z_3[j-k]) * Base(k);
     392                        pz_3[j-k] += azmul(pz_4[j], x[k]) * Base(k);
    393393                }
    394394                j--;
    395395        }
    396         px[0] += pz_4[0] * z_3[0];
     396        px[0] += azmul(pz_4[0], z_3[0]);
    397397
    398398        // z_3 = (2 / sqrt(pi)) * exp( - x * x )
  • trunk/cppad/local/exp_op.hpp

    r3667 r3735  
    184184
    185185                for(k = 1; k <= j; k++)
    186                 {       px[k]   += pz[j] * Base(k) * z[j-k];
    187                         pz[j-k] += pz[j] * Base(k) * x[k];
     186                {       px[k]   += Base(k) * azmul(pz[j], z[j-k]);
     187                        pz[j-k] += Base(k) * azmul(pz[j], x[k]);
    188188                }
    189189                --j;
    190190        }
    191         px[0] += pz[0] * z[0];
     191        px[0] += azmul(pz[0], z[0]);
    192192}
    193193
  • trunk/cppad/local/expm1_op.hpp

    r3685 r3735  
    189189
    190190                for(k = 1; k <= j; k++)
    191                 {       px[k]   += pz[j] * Base(k) * z[j-k];
    192                         pz[j-k] += pz[j] * Base(k) * x[k];
     191                {       px[k]   += Base(k) * azmul(pz[j], z[j-k]);
     192                        pz[j-k] += Base(k) * azmul(pz[j], x[k]);
    193193                }
    194194                --j;
    195195        }
    196         px[0] += pz[0] + pz[0] * z[0];
     196        px[0] += pz[0] + azmul(pz[0], z[0]);
    197197}
    198198
  • trunk/cppad/local/for_jac_sweep.hpp

    r3719 r3735  
    476476                        // -------------------------------------------------
    477477
     478                        case MulpvOp:
     479                        CPPAD_ASSERT_NARG_NRES(op, 2, 1);
     480                        forward_sparse_jacobian_unary_op(
     481                                i_var, arg[1], var_sparsity
     482                        );
     483                        break;
     484                        // -------------------------------------------------
     485
    478486                        case MulvvOp:
    479487                        CPPAD_ASSERT_NARG_NRES(op, 2, 1);
    480488                        forward_sparse_jacobian_binary_op(
    481489                                i_var, arg, var_sparsity
    482                         );
    483                         break;
    484                         // -------------------------------------------------
    485 
    486                         case MulpvOp:
    487                         CPPAD_ASSERT_NARG_NRES(op, 2, 1);
    488                         forward_sparse_jacobian_unary_op(
    489                                 i_var, arg[1], var_sparsity
    490490                        );
    491491                        break;
     
    820820                        // -------------------------------------------------
    821821
     822                        case ZmulpvOp:
     823                        CPPAD_ASSERT_NARG_NRES(op, 2, 1);
     824                        forward_sparse_jacobian_unary_op(
     825                                i_var, arg[1], var_sparsity
     826                        );
     827                        break;
     828                        // -------------------------------------------------
     829
     830                        case ZmulvpOp:
     831                        CPPAD_ASSERT_NARG_NRES(op, 2, 1);
     832                        forward_sparse_jacobian_unary_op(
     833                                i_var, arg[0], var_sparsity
     834                        );
     835                        break;
     836                        // -------------------------------------------------
     837
     838                        case ZmulvvOp:
     839                        CPPAD_ASSERT_NARG_NRES(op, 2, 1);
     840                        forward_sparse_jacobian_binary_op(
     841                                i_var, arg, var_sparsity
     842                        );
     843                        break;
     844                        // -------------------------------------------------
     845
    822846                        default:
    823847                        CPPAD_ASSERT_UNKNOWN(0);
  • trunk/cppad/local/forward0sweep.hpp

    r3685 r3735  
    278278                        // if( op == CSkipOp )
    279279                        // {    // CSkip has a variable number of arguments
    280                         //      play->forward_cskip(op, arg, i_op, i_var);
     280                        //      play->forward_cskip(op, arg, i_op, i_var);
    281281                        // }
    282282                        play->forward_next(op, arg, i_op, i_var);
     
    450450# if CPPAD_USE_CPLUSPLUS_2011
    451451                        case ErfOp:
    452                         CPPAD_ASSERT_UNKNOWN( CPPAD_USE_CPLUSPLUS_2011 );
    453                         // 2DO: implement zero order version of this function
    454452                        forward_erf_op_0(i_var, arg, parameter, J, taylor);
    455453                        break;
     
    588586                        // -------------------------------------------------
    589587
    590                         case MulvvOp:
    591                         forward_mulvv_op_0(i_var, arg, parameter, J, taylor);
    592                         break;
    593                         // -------------------------------------------------
    594 
    595588                        case MulpvOp:
    596589                        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
    597590                        forward_mulpv_op_0(i_var, arg, parameter, J, taylor);
     591                        break;
     592                        // -------------------------------------------------
     593
     594                        case MulvvOp:
     595                        forward_mulvv_op_0(i_var, arg, parameter, J, taylor);
    598596                        break;
    599597                        // -------------------------------------------------
     
    872870                        // -------------------------------------------------
    873871
     872                        case ZmulpvOp:
     873                        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
     874                        forward_zmulpv_op_0(i_var, arg, parameter, J, taylor);
     875                        break;
     876                        // -------------------------------------------------
     877
     878                        case ZmulvpOp:
     879                        CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < num_par );
     880                        forward_zmulvp_op_0(i_var, arg, parameter, J, taylor);
     881                        break;
     882                        // -------------------------------------------------
     883
     884                        case ZmulvvOp:
     885                        forward_zmulvv_op_0(i_var, arg, parameter, J, taylor);
     886                        break;
     887                        // -------------------------------------------------
     888
    874889                        default:
    875890                        CPPAD_ASSERT_UNKNOWN(false);
  • trunk/cppad/local/forward1sweep.hpp

    r3685 r3735  
    328328                        // if( op == CSkipOp )
    329329                        // {    // CSkip has a variable number of arguments
    330                         //      play->forward_cskip(op, arg, i_op, i_var);
     330                        //      play->forward_cskip(op, arg, i_op, i_var);
    331331                        // }
    332332                        play->forward_next(op, arg, i_op, i_var);
     
    680680                        // -------------------------------------------------
    681681
    682                         case MulvvOp:
    683                         forward_mulvv_op(p, q, i_var, arg, parameter, J, taylor);
    684                         break;
    685                         // -------------------------------------------------
    686 
    687682                        case MulpvOp:
    688683                        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
    689684                        forward_mulpv_op(p, q, i_var, arg, parameter, J, taylor);
     685                        break;
     686                        // -------------------------------------------------
     687
     688                        case MulvvOp:
     689                        forward_mulvv_op(p, q, i_var, arg, parameter, J, taylor);
    690690                        break;
    691691                        // -------------------------------------------------
     
    978978                        if( user_i == user_m )
    979979                                user_state = user_end;
     980                        break;
     981                        // -------------------------------------------------
     982
     983                        case ZmulpvOp:
     984                        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
     985                        forward_zmulpv_op(p, q, i_var, arg, parameter, J, taylor);
     986                        break;
     987                        // -------------------------------------------------
     988
     989                        case ZmulvpOp:
     990                        CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < num_par );
     991                        forward_zmulvp_op(p, q, i_var, arg, parameter, J, taylor);
     992                        break;
     993                        // -------------------------------------------------
     994
     995                        case ZmulvvOp:
     996                        forward_zmulvv_op(p, q, i_var, arg, parameter, J, taylor);
    980997                        break;
    981998                        // -------------------------------------------------
  • trunk/cppad/local/forward2sweep.hpp

    r3685 r3735  
    237237                        // if( op == CSkipOp )
    238238                        // {    // CSkip has a variable number of arguments
    239                         //      play->forward_cskip(op, arg, i_op, i_var);
     239                        //      play->forward_cskip(op, arg, i_op, i_var);
    240240                        // }
    241241                        play->forward_next(op, arg, i_op, i_var);
     
    439439                        // ---------------------------------------------------
    440440
    441                         case MulvvOp:
    442                         forward_mulvv_op_dir(q, r, i_var, arg, parameter, J, taylor);
    443                         break;
    444                         // -------------------------------------------------
    445 
    446441                        case MulpvOp:
    447442                        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
    448443                        forward_mulpv_op_dir(q, r, i_var, arg, parameter, J, taylor);
     444                        break;
     445                        // -------------------------------------------------
     446
     447                        case MulvvOp:
     448                        forward_mulvv_op_dir(q, r, i_var, arg, parameter, J, taylor);
    449449                        break;
    450450                        // -------------------------------------------------
     
    698698                        if( user_i == user_m )
    699699                                user_state = user_end;
     700                        break;
     701                        // -------------------------------------------------
     702
     703                        case ZmulpvOp:
     704                        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
     705                        forward_zmulpv_op_dir(q, r, i_var, arg, parameter, J, taylor);
     706                        break;
     707                        // -------------------------------------------------
     708
     709                        case ZmulvpOp:
     710                        CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < num_par );
     711                        forward_zmulvp_op_dir(q, r, i_var, arg, parameter, J, taylor);
     712                        break;
     713                        // -------------------------------------------------
     714
     715                        case ZmulvvOp:
     716                        forward_zmulvv_op_dir(q, r, i_var, arg, parameter, J, taylor);
    700717                        break;
    701718                        // -------------------------------------------------
  • trunk/cppad/local/hash_code.hpp

    r3684 r3735  
    8484
    8585\li binary operators where first argument is a parameter:
    86 AddpvOp, DivpvOp, MulpvOp, PowpvOp, SubpvOp,
     86AddpvOp, DivpvOp, MulpvOp, PowpvOp, SubpvOp, ZmulpvOp
    8787
    8888\li binary operators where second argument is a parameter:
    89 DivvpOp, PowvpOp, SubvpOp
     89DivvpOp, PowvpOp, SubvpOp, Zmulvp
    9090
    9191\li binary operators where first is an index and second is a variable:
     
    9393
    9494\li binary operators where both arguments are variables:
    95 AddvvOp, DivvvOp, MulvvOp, PowvvOp, SubvvOp
     95AddvvOp, DivvvOp, MulvvOp, PowvvOp, SubvvOp, ZmulvvOp
    9696
    9797\param arg
     
    168168                case PowpvOp:
    169169                case SubpvOp:
     170                case ZmulpvOp:
    170171                CPPAD_ASSERT_UNKNOWN( NumArg(op) == 2 );
    171172                v = reinterpret_cast<const unsigned short*>(par + arg[0]);
     
    189190                case PowvvOp:
    190191                case SubvvOp:
     192                case ZmulvvOp:
    191193                CPPAD_ASSERT_UNKNOWN( NumArg(op) == 2 );
    192194                v = reinterpret_cast<const unsigned short*>(arg + 0);
     
    200202                case PowvpOp:
    201203                case SubvpOp:
     204                case ZmulvpOp:
    202205                CPPAD_ASSERT_UNKNOWN( NumArg(op) == 2 );
    203206                v = reinterpret_cast<const unsigned short*>(arg + 0);
  • trunk/cppad/local/log1p_op.hpp

    r3685 r3735  
    179179        Base* pz       = partial + i_z * nc_partial;
    180180
    181         // If pz is zero, make sure this operation has no effect
    182         // (zero times infinity or nan would be non-zero).
    183         bool skip(true);
    184         for(size_t i_d = 0; i_d <= d; i_d++)
    185                 skip &= IdenticalZero(pz[i_d]);
    186         if( skip )
    187                 return;
     181        Base inv_1px0 = Base(1) / (Base(1) + x[0]);
    188182
    189183        j = d;
    190184        while(j)
    191185        {       // scale partial w.r.t z[j]
    192                 pz[j]   /= (Base(1) + x[0]);
    193 
    194                 px[0]   -= pz[j] * z[j];
     186                pz[j]   = azmul(pz[j]   , inv_1px0);
     187
     188                px[0]   -= azmul(pz[j], z[j]);
    195189                px[j]   += pz[j];
    196190
     
    199193
    200194                for(k = 1; k < j; k++)
    201                 {       pz[k]   -= pz[j] * Base(k) * x[j-k];
    202                         px[j-k] -= pz[j] * Base(k) * z[k];
     195                {       pz[k]   -= Base(k) * azmul(pz[j], x[j-k]);
     196                        px[j-k] -= Base(k) * azmul(pz[j], z[k]);
    203197                }
    204198                --j;
    205199        }
    206         px[0] += pz[0] / (Base(1) + x[0]);
     200        px[0] += azmul(pz[0], inv_1px0);
    207201}
    208202
  • trunk/cppad/local/log_op.hpp

    r3667 r3735  
    178178        Base* pz       = partial + i_z * nc_partial;
    179179
    180         // If pz is zero, make sure this operation has no effect
    181         // (zero times infinity or nan would be non-zero).
    182         bool skip(true);
    183         for(size_t i_d = 0; i_d <= d; i_d++)
    184                 skip &= IdenticalZero(pz[i_d]);
    185         if( skip )
    186                 return;
     180        Base inv_x0 = Base(1) / x[0];
    187181
    188182        j = d;
    189183        while(j)
    190184        {       // scale partial w.r.t z[j]
    191                 pz[j]   /= x[0];
    192 
    193                 px[0]   -= pz[j] * z[j];
     185                pz[j]   = azmul(pz[j]   , inv_x0);
     186
     187                px[0]   -= azmul(pz[j], z[j]);
    194188                px[j]   += pz[j];
    195189
     
    198192
    199193                for(k = 1; k < j; k++)
    200                 {       pz[k]   -= pz[j] * Base(k) * x[j-k];
    201                         px[j-k] -= pz[j] * Base(k) * z[k];
     194                {       pz[k]   -= Base(k) * azmul(pz[j], x[j-k]);
     195                        px[j-k] -= Base(k) * azmul(pz[j], z[k]);
    202196                }
    203197                --j;
    204198        }
    205         px[0] += pz[0] / x[0];
     199        px[0] += azmul(pz[0], inv_x0);
    206200}
    207201
  • trunk/cppad/local/mul_op.hpp

    r3667 r3735  
    182182        Base* pz = partial + i_z    * nc_partial;
    183183
    184         // If pz is zero, make sure this operation has no effect
    185         // (zero times infinity or nan would be non-zero).
    186         bool skip(true);
    187         for(size_t i_d = 0; i_d <= d; i_d++)
    188                 skip &= IdenticalZero(pz[i_d]);
    189         if( skip )
    190                 return;
    191184
    192185        // number of indices to access
     
    197190                for(k = 0; k <= j; k++)
    198191                {
    199                         px[j-k] += pz[j] * y[k];
    200                         py[k]   += pz[j] * x[j-k];
     192                        px[j-k] += azmul(pz[j], y[k]);
     193                        py[k]   += azmul(pz[j], x[j-k]);
    201194                }
    202195        }
     
    359352        while(j)
    360353        {       --j;
    361                 py[j] += pz[j] * x;
     354                py[j] += azmul(pz[j], x);
    362355        }
    363356}
  • trunk/cppad/local/op.hpp

    r3686 r3735  
    5555# include <cppad/local/tan_op.hpp>
    5656# include <cppad/local/tanh_op.hpp>
     57# include <cppad/local/zmul_op.hpp>
    5758
    5859
  • trunk/cppad/local/op_code.hpp

    r3730 r3735  
    4848// alphabetical order is checked by bin/check_op_code.sh
    4949enum OpCode {
    50         AbsOp,    //  abs(variable)
     50        AbsOp,    // abs(variable)
    5151        AcosOp,   // acos(variable)
    5252        AcoshOp,  // acosh(variable)
    53         AddpvOp,  //      parameter  + variable
    54         AddvvOp,  //      variable   + variable
     53        AddpvOp,  // parameter  + variable
     54        AddvvOp,  // variable   + variable
    5555        AsinOp,   // asin(variable)
    5656        AsinhOp,  // asinh(variable)
     
    6868        // arg[4]     = index correspoding to trueCase
    6969        // arg[5]     = index correspoding to falseCase
    70         CosOp,    //  cos(variable)
     70        CosOp,    // cos(variable)
    7171        CoshOp,   // cosh(variable)
    7272        CSkipOp,  // Conditional skip
     
    8888        // arg[3+arg[0]] -> arg[2+arg[0]+arg[1]] = index for minus variables
    8989        // arg[3+arg[0]+arg[1]] = arg[0] + arg[1]
    90         DisOp,    //  discrete::eval(index, variable)
    91         DivpvOp,  //  parameter  / variable
    92         DivvpOp,  //  variable   / parameter
    93         DivvvOp,  //  variable   / variable
    94         EndOp,    //  used to mark the end of the tape
    95         EqpvOp,   //  parameter  == variable
    96         EqvvOp,   //  variable   == variable
    97         ErfOp,    //  erf(variable)
    98         ExpOp,    //  exp(variable)
    99         Expm1Op,  //  expm1(variable)
    100         InvOp,    //  independent variable
    101         LdpOp,    //  z[parameter]
    102         LdvOp,    //  z[variable]
    103         LepvOp,   //  parameter <= variable
    104         LevpOp,   //  variable  <= parameter
    105         LevvOp,   //  variable  <= variable
    106         LogOp,    //  log(variable)
    107         Log1pOp,  //  log1p(variable)
    108         LtpvOp,   //  parameter < variable
    109         LtvpOp,   //  variable  < parameter
    110         LtvvOp,   //  variable  < variable
    111         MulpvOp,  //  parameter  * variable
    112         MulvvOp,  //  variable   * variable
    113         NepvOp,   //  parameter  != variable
    114         NevvOp,   //  variable   != variable
    115         ParOp,    //  parameter
    116         PowpvOp,  //  pow(parameter,   variable)
    117         PowvpOp,  //  pow(variable,    parameter)
    118         PowvvOp,  //  pow(variable,    variable)
    119         PriOp,    //  PrintFor(text, parameter or variable, parameter or variable)
    120         SignOp,   //  sign(variable)
    121         SinOp,    //  sin(variable)
    122         SinhOp,   //  sinh(variable)
    123         SqrtOp,   //  sqrt(variable)
    124         StppOp,   //  z[parameter] = parameter
    125         StpvOp,   //  z[parameter] = variable
    126         StvpOp,   //  z[variable]  = parameter
    127         StvvOp,   //  z[variable]  = variable
    128         SubpvOp,  //  parameter  - variable
    129         SubvpOp,  //  variable   - parameter
    130         SubvvOp,  //  variable   - variable
    131         TanOp,    //  tan(variable)
    132         TanhOp,   //  tan(variable)
     90        DisOp,    // discrete::eval(index, variable)
     91        DivpvOp,  // parameter  / variable
     92        DivvpOp,  // variable   / parameter
     93        DivvvOp,  // variable   / variable
     94        EndOp,    // used to mark the end of the tape
     95        EqpvOp,   // parameter  == variable
     96        EqvvOp,   // variable   == variable
     97        ErfOp,    // erf(variable)
     98        ExpOp,    // exp(variable)
     99        Expm1Op,  // expm1(variable)
     100        InvOp,    // independent variable
     101        LdpOp,    // z[parameter]
     102        LdvOp,    // z[variable]
     103        LepvOp,   // parameter <= variable
     104        LevpOp,   // variable  <= parameter
     105        LevvOp,   // variable  <= variable
     106        LogOp,    // log(variable)
     107        Log1pOp,  // log1p(variable)
     108        LtpvOp,   // parameter < variable
     109        LtvpOp,   // variable  < parameter
     110        LtvvOp,   // variable  < variable
     111        MulpvOp,  // parameter  * variable
     112        MulvvOp,  // variable   * variable
     113        NepvOp,   // parameter  != variable
     114        NevvOp,   // variable   != variable
     115        ParOp,    // parameter
     116        PowpvOp,  // pow(parameter,   variable)
     117        PowvpOp,  // pow(variable,    parameter)
     118        PowvvOp,  // pow(variable,    variable)
     119        PriOp,    // PrintFor(text, parameter or variable, parameter or variable)
     120        SignOp,   // sign(variable)
     121        SinOp,    // sin(variable)
     122        SinhOp,   // sinh(variable)
     123        SqrtOp,   // sqrt(variable)
     124        StppOp,   // z[parameter] = parameter
     125        StpvOp,   // z[parameter] = variable
     126        StvpOp,   // z[variable]  = parameter
     127        StvvOp,   // z[variable]  = variable
     128        SubpvOp,  // parameter  - variable
     129        SubvpOp,  // variable   - parameter
     130        SubvvOp,  // variable   - variable
     131        TanOp,    // tan(variable)
     132        TanhOp,   // tan(variable)
    133133        // user atomic operation codes
    134         UserOp,   //  start of a user atomic operaiton
     134        UserOp,   // start of a user atomic operaiton
    135135        // arg[0] = index of the operation if atomic_base<Base> class
    136136        // arg[1] = extra information passed trough by deprecated old atomic class
    137137        // arg[2] = number of arguments to this atomic function
    138138        // arg[3] = number of results for this atomic function
    139         UsrapOp,  //  this user atomic argument is a parameter
    140         UsravOp,  //  this user atomic argument is a variable
    141         UsrrpOp,  //  this user atomic result is a parameter
    142         UsrrvOp,  //  this user atomic result is a variable
    143         NumberOp
     139        UsrapOp,  // this user atomic argument is a parameter
     140        UsravOp,  // this user atomic argument is a variable
     141        UsrrpOp,  // this user atomic result is a parameter
     142        UsrrvOp,  // this user atomic result is a variable
     143        ZmulpvOp, // azmul(parameter, variable)
     144        ZmulvpOp, // azmul(variabe,  parameter)
     145        ZmulvvOp, // azmul(variable, variable)
     146        NumberOp  // number of operator codes (not an operator)
    144147};
    145148// Note that bin/check_op_code.sh assumes the pattern '^\tNumberOp$' occurs
     
    235238                1, // UsrrpOp
    236239                0, // UsrrvOp
     240                2, // ZmulpvOp
     241                2, // ZmulvpOp
     242                2, // ZmulvvOp
    237243                0  // NumberOp not used
    238244        };
     
    341347                0, // UsrrpOp
    342348                1, // UsrrvOp
     349                1, // ZmulpvOp
     350                1, // ZmulvpOp
     351                1, // ZmulvvOp
    343352                0  // NumberOp not used and avoids g++ 4.3.2 warn when pycppad builds
    344353        };
     
    429438                "Usrrp" ,
    430439                "Usrrv" ,
     440                "Zmulpv",
     441                "Zmulvp",
     442                "Zmulvv",
    431443                "Number"  // not used
    432444        };
    433445        // check ensuring conversion to size_t is as expected
    434446        CPPAD_ASSERT_UNKNOWN(
    435                 size_t(NumberOp) == sizeof(OpNameTable)/sizeof(OpNameTable[0])
     447                size_t(NumberOp) + 1 == sizeof(OpNameTable)/sizeof(OpNameTable[0])
    436448        );
    437449        // this test ensures that all indices are within the table
     
    671683                case PowvvOp:
    672684                case SubvvOp:
     685                case ZmulvvOp:
    673686                CPPAD_ASSERT_UNKNOWN( NumArg(op) == 2 );
    674687                printOpField(os, " vl=", ind[0], ncol);
     
    685698                case MulpvOp:
    686699                case PowpvOp:
     700                case ZmulpvOp:
    687701                CPPAD_ASSERT_UNKNOWN( NumArg(op) == 2 );
    688702                printOpField(os, " pl=", play->GetPar(ind[0]), ncol);
     
    695709                case PowvpOp:
    696710                case SubvpOp:
     711                case ZmulvpOp:
    697712                CPPAD_ASSERT_UNKNOWN( NumArg(op) == 2 );
    698713                printOpField(os, " vl=", ind[0], ncol);
     
    950965                case MulvvOp:
    951966                case SubvvOp:
     967                case ZmulvvOp:
    952968                CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < result );
    953969                CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < result );
     
    957973                case DivvpOp:
    958974                case SubvpOp:
     975                case ZmulvpOp:
    959976                CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < result );
    960977                break;
     
    966983                case MulpvOp:
    967984                case SubpvOp:
     985                case ZmulpvOp:
    968986                CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < result );
    969987                break;
  • trunk/cppad/local/optimize.hpp

    r3733 r3735  
    1717$begin optimize$$
    1818$spell
     19        enum
    1920        jac
    2021        bool
     
    9697The $cref atomic_rev_sparse_jac$$ function is be used to determine
    9798which components of $icode u$$ affect the dependent variables of $icode f$$.
    98 The current setting of the
    99 $cref/atomic_sparsity/atomic_option/atomic_sparsity/$$ pattern for each
    100 atomic function is used to determine if the $code bool$$ or
    101 $code std::set<size_t>$$ version of $cref atomic_rev_sparse_jac$$ is used.
     99For each atomic operation, the current
     100$cref/atomic_sparsity/atomic_option/atomic_sparsity/$$ setting is used
     101to determine if $code pack_sparsity_enum$$, $code bool_sparsity_enum$$,
     102or $code set_sparsity_enum$$ is used to determine dependency relations
     103between argument and result variables.
    102104
    103105$subhead nan$$
     
    736738                case PowpvOp:
    737739                case SubpvOp:
     740                case ZmulpvOp:
    738741                // arg[0]
    739742                parameter[0] = true;
     
    750753                case PowvpOp:
    751754                case SubvpOp:
     755                case ZmulvpOp:
    752756                // arg[0]
    753757                parameter[0] = false;
     
    766770                case PowvvOp:
    767771                case SubvvOp:
     772                case ZmulvvOp:
    768773                // arg[0]
    769774                parameter[0] = false;
     
    896901\param op
    897902is the operator that we are recording which must be one of the following:
    898 AddpvOp, DivpvOp, MulpvOp, PowvpOp, SubpvOp.
     903AddpvOp, DivpvOp, MulpvOp, PowpvOp, SubpvOp, ZmulpvOp.
    899904
    900905\param arg
     
    922927                case PowpvOp:
    923928                case SubpvOp:
     929                case ZmulpvOp:
    924930                break;
    925931
     
    9981004\param op
    9991005is the operator that we are recording which must be one of the following:
    1000 DivvpOp, PowvpOp, SubvpOp.
     1006DivvpOp, PowvpOp, SubvpOp, ZmulvpOp.
    10011007
    10021008\param arg
     
    10221028                case PowvpOp:
    10231029                case SubvpOp:
     1030                case ZmulvpOp:
    10241031                break;
    10251032
     
    10971104\param op
    10981105is the operator that we are recording which must be one of the following:
    1099 AddvvOp, DivvvOp, MulvvOp, PowvpOp, SubvvOp.
     1106AddvvOp, DivvvOp, MulvvOp, PowvvOp, SubvvOp, ZmulvvOp.
    11001107
    11011108\param arg
     
    11231130                case PowvvOp:
    11241131                case SubvvOp:
     1132                case ZmulvvOp:
    11251133                break;
    11261134
     
    14921500        // work space used by UserOp.
    14931501        typedef std::set<size_t> size_set;
     1502        //
    14941503        vector<size_set> user_r_set;   // set sparsity pattern for result
    14951504        vector<size_set> user_s_set;   // set sparisty pattern for argument
     1505        //
    14961506        vector<bool>     user_r_bool;  // bool sparsity pattern for result
    14971507        vector<bool>     user_s_bool;  // bool sparisty pattern for argument
     1508        //
     1509        vectorBool       user_r_pack;  // pack sparsity pattern for result
     1510        vectorBool       user_s_pack;  // pack sparisty pattern for argument
    14981511        //
    14991512        size_t user_q     = 0;       // column dimension for sparsity patterns
     
    15061519        //
    15071520        atomic_base<Base>* user_atom = CPPAD_NULL; // current user atomic function
    1508         bool               user_set  = true;       // use set sparsity (or bool)
     1521        bool               user_pack = false;      // sparsity pattern type is pack
     1522        bool               user_bool = false;      // sparsity pattern type is bool
     1523        bool               user_set  = false;      // sparsity pattern type is set
    15091524
    15101525        // next expected operator in a UserOp sequence
     
    15691584                        case TanOp:
    15701585                        case TanhOp:
     1586                        case ZmulvpOp:
    15711587                        switch( connect_type )
    15721588                        {       case not_connected:
     
    16031619                        case MulpvOp:
    16041620                        case PowpvOp:
     1621                        case ZmulpvOp:
    16051622                        switch( connect_type )
    16061623                        {       case not_connected:
     
    17511768                        case MulvvOp:
    17521769                        case PowvvOp:
     1770                        case ZmulvvOp:
    17531771                        for(i = 0; i < 2; i++) switch( connect_type )
    17541772                        {       case not_connected:
     
    19251943                                user_q     = 1;
    19261944                                user_atom  = atomic_base<Base>::class_object(user_index);
     1945                                if( user_atom == CPPAD_NULL )
     1946                                {       std::string msg =
     1947                                                atomic_base<Base>::class_name(user_index)
     1948                                                + ": atomic_base function has been deleted";
     1949                                        CPPAD_ASSERT_KNOWN(false, msg.c_str() );
     1950                                }
     1951                                user_pack  = user_atom->sparsity() ==
     1952                                                        atomic_base<Base>::pack_sparsity_enum;
     1953                                user_bool  = user_atom->sparsity() ==
     1954                                                        atomic_base<Base>::bool_sparsity_enum;
     1955                                user_set   = user_atom->sparsity() ==
     1956                                                        atomic_base<Base>::set_sparsity_enum;
     1957                                CPPAD_ASSERT_UNKNOWN( user_pack || user_bool || user_set );
     1958
    19271959                                user_set   = user_atom->sparsity() ==
    19281960                                        atomic_base<Base>::set_sparsity_enum;
    19291961                                //
    1930                                 if(user_s_set.size() != user_n )
    1931                                         user_s_set.resize(user_n);
    1932                                 if(user_r_set.size() != user_m )
    1933                                         user_r_set.resize(user_m);
    1934                                 //
    19351962                                // Note user_q is 1, but use it for clarity of code
    1936                                 if(user_s_bool.size() != user_n * user_q )
    1937                                         user_s_bool.resize(user_n * user_q);
    1938                                 if(user_r_bool.size() != user_m * user_q )
    1939                                         user_r_bool.resize(user_m * user_q);
     1963                                if( user_pack )
     1964                                {       if( user_r_pack.size() != user_m * user_q )
     1965                                                user_r_pack.resize( user_m * user_q );
     1966                                        if( user_s_pack.size() != user_n * user_q )
     1967                                                user_s_pack.resize( user_n * user_q );
     1968                                        for(i = 0; i < user_m; i++)
     1969                                                for(j = 0; j < user_q; j++)
     1970                                                        user_r_pack[ i * user_q + j] = false;
     1971                                }
     1972                                if( user_bool )
     1973                                {       if( user_r_bool.size() != user_m * user_q )
     1974                                                user_r_bool.resize( user_m * user_q );
     1975                                        if( user_s_bool.size() != user_n * user_q )
     1976                                                user_s_bool.resize( user_n * user_q );
     1977                                        for(i = 0; i < user_m; i++)
     1978                                                for(j = 0; j < user_q; j++)
     1979                                                        user_r_bool[ i * user_q + j] = false;
     1980                                }
     1981                                if( user_set )
     1982                                {       if(user_s_set.size() != user_n )
     1983                                                user_s_set.resize(user_n);
     1984                                        if(user_r_set.size() != user_m )
     1985                                                user_r_set.resize(user_m);
     1986                                                for(i = 0; i < user_m; i++)
     1987                                                        user_r_set[i].clear();
     1988                                }
    19401989                                //
    19411990                                user_j     = user_n;
     
    19872036                                                user_info[user_curr].connect_type;
    19882037                        }
    1989                         else
     2038                        if( user_bool )
    19902039                        {       if( user_s_bool[user_j] )
     2040                                        tape[arg[0]].connect_type =
     2041                                                user_info[user_curr].connect_type;
     2042                        }
     2043                        if( user_pack )
     2044                        {       if( user_s_pack[user_j] )
    19912045                                        tape[arg[0]].connect_type =
    19922046                                                user_info[user_curr].connect_type;
     
    20012055                        CPPAD_ASSERT_UNKNOWN( 0 < user_i && user_i <= user_m );
    20022056                        --user_i;
    2003                         user_r_set[user_i].clear();
    2004                         user_r_bool[user_i] = false;
    20052057                        switch( connect_type )
    20062058                        {       case not_connected:
     
    20112063                                case csum_connected:
    20122064                                user_info[user_curr].connect_type = yes_connected;
    2013                                 user_r_set[user_i].insert(0);
    2014                                 user_r_bool[user_i] = true;
     2065                                if( user_set )
     2066                                        user_r_set[user_i].insert(0);
     2067                                if( user_bool )
     2068                                        user_r_bool[user_i] = true;
     2069                                if( user_pack )
     2070                                        user_r_pack[user_i] = true;
    20152071                                break;
    20162072
     
    20272083                                }
    20282084                                else    user_info[user_curr].connect_type = yes_connected;
    2029                                 user_r_set[user_i].insert(0);
    2030                                 user_r_bool[user_i] = true;
     2085                                if( user_set )
     2086                                        user_r_set[user_i].insert(0);
     2087                                if( user_bool )
     2088                                        user_r_bool[user_i] = true;
     2089                                if( user_pack )
     2090                                        user_r_pack[user_i] = true;
    20312091                                break;
    20322092
     
    20452105                                CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
    20462106                                --user_i;
    2047                                 user_r_set[user_i].clear();
    2048                                 user_r_bool[user_i] = false;
    20492107                        }
    20502108                        if( user_i == 0 )
    20512109                        {       // call users function for this operation
    20522110                                user_atom->set_id(user_id);
    2053 # ifdef NDEBUG
    2054                                 if( user_set )
    2055                                 {       user_atom->
    2056                                                 rev_sparse_jac(user_q, user_r_set, user_s_set);
    2057                                 }
    2058                                 else
    2059                                 {       user_atom->
    2060                                                 rev_sparse_jac(user_q, user_r_bool, user_s_bool);
    2061                                 }
    2062 # else
    2063                                 bool flag;
     2111                                bool flag = false;
    20642112                                if( user_set )
    20652113                                {       flag = user_atom->
    20662114                                                rev_sparse_jac(user_q, user_r_set, user_s_set);
    20672115                                }
    2068                                 else
     2116                                if( user_bool )
    20692117                                {       flag = user_atom->
    20702118                                                rev_sparse_jac(user_q, user_r_bool, user_s_bool);
     2119                                }
     2120                                if( user_pack )
     2121                                {       flag = user_atom->
     2122                                                rev_sparse_jac(user_q, user_r_pack, user_s_pack);
    20712123                                }
    20722124                                if( ! flag )
     
    20782130                                        //
    20792131                                        if( user_set )
    2080                                                 s += " std::set\nand std::set";
    2081                                         else    s += " bool\nand bool";
     2132                                                s += "set_sparsity_enum.\n";
     2133                                        if( user_bool )
     2134                                                s += "bool_sparsity_enum.\n";
     2135                                        if( user_pack )
     2136                                                s += "pack_sparsity_enum.\n";
    20822137                                        //
    2083                                         s += " version of rev_sparse_jac returned false";
     2138                                        s += "This version of rev_sparse_jac returned false";
    20842139                                        CPPAD_ASSERT_KNOWN(false, s.c_str() );
    20852140                                }
    2086 # endif
    20872141                                user_state = user_arg;
    20882142                        }
     
    23902444                        case DivvpOp:
    23912445                        case PowvpOp:
     2446                        case ZmulvpOp:
    23922447                        match_var = binary_match(
    23932448                                tape                ,  // inputs
     
    24722527                        case MulpvOp:
    24732528                        case PowpvOp:
     2529                        case ZmulpvOp:
    24742530                        match_var = binary_match(
    24752531                                tape                ,  // inputs
     
    25262582                        case MulvvOp:
    25272583                        case PowvvOp:
     2584                        case ZmulvvOp:
    25282585                        match_var = binary_match(
    25292586                                tape                ,  // inputs
  • trunk/cppad/local/pow.hpp

    r2939 r3735  
    44
    55/* --------------------------------------------------------------------------
    6 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
     6CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
    77
    88CppAD is distributed under multiple licenses. This distribution is under
    9 the terms of the 
     9the terms of the
    1010                    Eclipse Public License Version 1.0.
    1111
     
    4444logarithms and exponentiation to compute derivatives.
    4545This will not work if $icode x$$ is less than or equal zero.
    46 If the value of $icode y$$ is an integer, 
    47 the $cref pow_int$$ function is used to compute this value 
    48 using only multiplication (and division if $icode y$$ is negative). 
     46If the value of $icode y$$ is an integer,
     47the $cref pow_int$$ function is used to compute this value
     48using only multiplication (and division if $icode y$$ is negative).
    4949(This will work even if $icode x$$ is less than or equal zero.)
    5050
     
    8686The file
    8787$cref pow.cpp$$
    88 is an examples and tests of this function.   
     88is an examples and tests of this function.
    8989It returns true if it succeeds and false otherwise.
    9090
     
    9595//  BEGIN CppAD namespace
    9696namespace CppAD {
    97  
     97
    9898// case where x and y are AD<Base> -----------------------------------------
    99 template <class Base> AD<Base> 
     99template <class Base> AD<Base>
    100100pow(const AD<Base>& x, const AD<Base>& y)
    101101{
     
    135135                }
    136136                else
    137                 {       // result = variable^parameter 
     137                {       // result = variable^parameter
    138138                        CPPAD_ASSERT_UNKNOWN( NumRes(PowvpOp) == 3 );
    139139                        CPPAD_ASSERT_UNKNOWN( NumArg(PowvpOp) == 2 );
     
    152152        else if( var_y )
    153153        {       if( IdenticalZero(x.value_) )
    154                 {       // result = 0^variable 
     154                {       // result = 0^variable
    155155                }
    156156                else
    157                 {       // result = variable^parameter
     157                {       // result = parameter^variable
    158158                        CPPAD_ASSERT_UNKNOWN( NumRes(PowpvOp) == 3 );
    159159                        CPPAD_ASSERT_UNKNOWN( NumArg(PowpvOp) == 2 );
     
    181181{       return pow(x, y.ADBase()); }
    182182
    183 template <class Base> AD<Base> 
    184 pow(const VecAD_reference<Base>& x, const VecAD_reference<Base>& y) 
     183template <class Base> AD<Base>
     184pow(const VecAD_reference<Base>& x, const VecAD_reference<Base>& y)
    185185{       return pow(x.ADBase(), y.ADBase()); }
    186186
     
    244244
    245245// =========================================================================
    246 // Fold operations for the cases where x is an int, 
     246// Fold operations for the cases where x is an int,
    247247// but let cppad/pow_int.hpp handle the cases where y is an int.
    248248// -------------------------------------------------------------------------
     
    257257} // END CppAD namespace
    258258
    259 # endif 
     259# endif
  • trunk/cppad/local/rev_hes_sweep.hpp

    r3721 r3735  
    487487                        // -------------------------------------------------
    488488
     489                        case MulpvOp:
     490                        CPPAD_ASSERT_NARG_NRES(op, 2, 1)
     491                        reverse_sparse_hessian_linear_unary_op(
     492                        i_var, arg[1], RevJac, for_jac_sparse, rev_hes_sparse
     493                        );
     494                        break;
     495                        // -------------------------------------------------
     496
    489497                        case MulvvOp:
    490498                        CPPAD_ASSERT_NARG_NRES(op, 2, 1)
    491499                        reverse_sparse_hessian_mul_op(
    492500                        i_var, arg, RevJac, for_jac_sparse, rev_hes_sparse
    493                         );
    494                         break;
    495                         // -------------------------------------------------
    496 
    497                         case MulpvOp:
    498                         CPPAD_ASSERT_NARG_NRES(op, 2, 1)
    499                         reverse_sparse_hessian_linear_unary_op(
    500                         i_var, arg[1], RevJac, for_jac_sparse, rev_hes_sparse
    501501                        );
    502502                        break;
     
    887887                                user_state = user_arg;
    888888                        break;
     889                        // -------------------------------------------------
     890
     891                        case ZmulpvOp:
     892                        CPPAD_ASSERT_NARG_NRES(op, 2, 1)
     893                        reverse_sparse_hessian_linear_unary_op(
     894                        i_var, arg[1], RevJac, for_jac_sparse, rev_hes_sparse
     895                        );
     896                        break;
     897                        // -------------------------------------------------
     898
     899                        case ZmulvpOp:
     900                        CPPAD_ASSERT_NARG_NRES(op, 2, 1)
     901                        reverse_sparse_hessian_linear_unary_op(
     902                        i_var, arg[0], RevJac, for_jac_sparse, rev_hes_sparse
     903                        );
     904                        break;
     905                        // -------------------------------------------------
     906
     907                        case ZmulvvOp:
     908                        CPPAD_ASSERT_NARG_NRES(op, 2, 1)
     909                        reverse_sparse_hessian_mul_op(
     910                        i_var, arg, RevJac, for_jac_sparse, rev_hes_sparse
     911                        );
     912                        break;
    889913
    890914                        // -------------------------------------------------
  • trunk/cppad/local/rev_jac_sweep.hpp

    r3719 r3735  
    475475                        // -------------------------------------------------
    476476
     477                        case MulpvOp:
     478                        CPPAD_ASSERT_NARG_NRES(op, 2, 1);
     479                        reverse_sparse_jacobian_unary_op(
     480                                i_var, arg[1], var_sparsity
     481                        );
     482                        break;
     483                        // -------------------------------------------------
     484
    477485                        case MulvvOp:
    478486                        CPPAD_ASSERT_NARG_NRES(op, 2, 1);
    479487                        reverse_sparse_jacobian_binary_op(
    480488                                i_var, arg, var_sparsity
    481                         );
    482                         break;
    483                         // -------------------------------------------------
    484 
    485                         case MulpvOp:
    486                         CPPAD_ASSERT_NARG_NRES(op, 2, 1);
    487                         reverse_sparse_jacobian_unary_op(
    488                                 i_var, arg[1], var_sparsity
    489489                        );
    490490                        break;
     
    819819                        // -------------------------------------------------
    820820
     821                        case ZmulpvOp:
     822                        CPPAD_ASSERT_NARG_NRES(op, 2, 1);
     823                        reverse_sparse_jacobian_unary_op(
     824                                i_var, arg[1], var_sparsity
     825                        );
     826                        break;
     827                        // -------------------------------------------------
     828
     829                        case ZmulvpOp:
     830                        CPPAD_ASSERT_NARG_NRES(op, 2, 1);
     831                        reverse_sparse_jacobian_unary_op(
     832                                i_var, arg[0], var_sparsity
     833                        );
     834                        break;
     835                        // -------------------------------------------------
     836
     837                        case ZmulvvOp:
     838                        CPPAD_ASSERT_NARG_NRES(op, 2, 1);
     839                        reverse_sparse_jacobian_binary_op(
     840                                i_var, arg, var_sparsity
     841                        );
     842                        break;
     843                        // -------------------------------------------------
     844
    821845                        default:
    822846                        CPPAD_ASSERT_UNKNOWN(0);
  • trunk/cppad/local/reverse_sweep.hpp

    r3685 r3735  
    254254                        // if( op == CSkipOp )
    255255                        // {    // CSkip has a variable number of arguments
    256                         //      play->reverse_cskip(op, arg, i_op, i_var);
     256                        //      play->reverse_cskip(op, arg, i_op, i_var);
    257257                        // }
    258258                        CPPAD_ASSERT_UNKNOWN( i_op < play->num_op_rec() );
     
    537537                        // --------------------------------------------------
    538538
    539                         case MulvvOp:
    540                         reverse_mulvv_op(
    541                                 d, i_var, arg, parameter, J, Taylor, K, Partial
    542                         );
    543                         break;
    544                         // --------------------------------------------------
    545 
    546539                        case MulpvOp:
    547540                        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
    548541                        reverse_mulpv_op(
     542                                d, i_var, arg, parameter, J, Taylor, K, Partial
     543                        );
     544                        break;
     545                        // --------------------------------------------------
     546
     547                        case MulvvOp:
     548                        reverse_mulvv_op(
    549549                                d, i_var, arg, parameter, J, Taylor, K, Partial
    550550                        );
     
    794794                        // ------------------------------------------------------------
    795795
     796                        case ZmulpvOp:
     797                        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
     798                        reverse_zmulpv_op(
     799                                d, i_var, arg, parameter, J, Taylor, K, Partial
     800                        );
     801                        break;
     802                        // --------------------------------------------------
     803
     804                        case ZmulvpOp:
     805                        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
     806                        reverse_zmulvp_op(
     807                                d, i_var, arg, parameter, J, Taylor, K, Partial
     808                        );
     809                        break;
     810                        // --------------------------------------------------
     811
     812                        case ZmulvvOp:
     813                        reverse_zmulvv_op(
     814                                d, i_var, arg, parameter, J, Taylor, K, Partial
     815                        );
     816                        break;
     817                        // --------------------------------------------------
     818
    796819                        default:
    797820                        CPPAD_ASSERT_UNKNOWN(false);
  • trunk/cppad/local/sin_op.hpp

    r3667 r3735  
    214214        Base* pc       = ps - nc_partial;
    215215
    216         // If ps is zero, make sure this operation has no effect
    217         // (zero times infinity or nan would be non-zero).
    218         bool skip(true);
    219         for(size_t i_d = 0; i_d <= d; i_d++)
    220                 skip &= IdenticalZero(ps[i_d]);
    221         if( skip )
    222                 return;
    223216
    224217        // rest of this routine is identical for the following cases:
     
    232225                for(k = 1; k <= j; k++)
    233226                {
    234                         px[k]   += ps[j] * Base(k) * c[j-k];
    235                         px[k]   -= pc[j] * Base(k) * s[j-k];
    236 
    237                         ps[j-k] -= pc[j] * Base(k) * x[k];
    238                         pc[j-k] += ps[j] * Base(k) * x[k];
     227                        px[k]   += Base(k) * azmul(ps[j], c[j-k]);
     228                        px[k]   -= Base(k) * azmul(pc[j], s[j-k]);
     229
     230                        ps[j-k] -= Base(k) * azmul(pc[j], x[k]);
     231                        pc[j-k] += Base(k) * azmul(ps[j], x[k]);
    239232
    240233                }
    241234                --j;
    242235        }
    243         px[0] += ps[0] * c[0];
    244         px[0] -= pc[0] * s[0];
     236        px[0] += azmul(ps[0], c[0]);
     237        px[0] -= azmul(pc[0], s[0]);
    245238}
    246239
  • trunk/cppad/local/sinh_op.hpp

    r3667 r3735  
    213213        Base* pc       = ps - nc_partial;
    214214
    215         // If ps is zero, make sure this operation has no effect
    216         // (zero times infinity or nan would be non-zero).
    217         bool skip(true);
    218         for(size_t i_d = 0; i_d <= d; i_d++)
    219                 skip &= IdenticalZero(ps[i_d]);
    220         if( skip )
    221                 return;
    222215
    223216        // rest of this routine is identical for the following cases:
     
    231224                for(k = 1; k <= j; k++)
    232225                {
    233                         px[k]   += ps[j] * Base(k) * c[j-k];
    234                         px[k]   += pc[j] * Base(k) * s[j-k];
    235 
    236                         ps[j-k] += pc[j] * Base(k) * x[k];
    237                         pc[j-k] += ps[j] * Base(k) * x[k];
     226                        px[k]   += Base(k) * azmul(ps[j], c[j-k]);
     227                        px[k]   += Base(k) * azmul(pc[j], s[j-k]);
     228
     229                        ps[j-k] += Base(k) * azmul(pc[j], x[k]);
     230                        pc[j-k] += Base(k) * azmul(ps[j], x[k]);
    238231
    239232                }
    240233                --j;
    241234        }
    242         px[0] += ps[0] * c[0];
    243         px[0] += pc[0] * s[0];
     235        px[0] += azmul(ps[0], c[0]);
     236        px[0] += azmul(pc[0], s[0]);
    244237}
    245238
  • trunk/cppad/local/sqrt_op.hpp

    r3667 r3735  
    5858        for(size_t j = p; j <= q; j++)
    5959        {
    60                 CPPAD_ASSERT_KNOWN(
    61                         x[0] != Base(0),
    62                         "Forward: attempt to take derivatve of square root of zero"
    63                 )
    6460                z[j] = Base(0);
    6561                for(k = 1; k < j; k++)
     
    10096        Base* z = taylor + i_z * num_taylor_per_var;
    10197        Base* x = taylor + i_x * num_taylor_per_var;
    102         CPPAD_ASSERT_KNOWN(
    103                 x[0] != Base(0),
    104                 "Forward: attempt to take derivatve of square root of zero"
    105         )
    10698
    10799        size_t m = (q-1) * r + 1;
     
    178170        Base* pz       = partial + i_z * nc_partial;
    179171
    180         // If pz is zero, make sure this operation has no effect
    181         // (zero times infinity or nan would be non-zero).
    182         bool skip(true);
    183         for(size_t i_d = 0; i_d <= d; i_d++)
    184                 skip &= IdenticalZero(pz[i_d]);
    185         if( skip )
    186                 return;
    187172
    188         CPPAD_ASSERT_KNOWN(
    189                 z[0] != Base(0),
    190                 "Reverse: attempt to take derivatve of square root of zero"
    191         )
     173        Base inv_z0 = Base(1) / z[0];
    192174
    193175        // number of indices to access
     
    198180
    199181                // scale partial w.r.t. z[j]
    200                 pz[j]   /= z[0];
     182                pz[j]    = azmul(pz[j], inv_z0);
    201183
    202                 pz[0]   -= pz[j] * z[j];
     184                pz[0]   -= azmul(pz[j], z[j]);
    203185                px[j]   += pz[j] / Base(2);
    204186                for(k = 1; k < j; k++)
    205                         pz[k]   -= pz[j] * z[j-k];
     187                        pz[k]   -= azmul(pz[j], z[j-k]);
    206188                --j;
    207189        }
    208         px[0] += pz[0] / (Base(2) * z[0]);
     190        px[0] += azmul(pz[0], inv_z0) / Base(2);
    209191}
    210192
  • trunk/cppad/local/standard_math.hpp

    r3686 r3735  
    2525
    2626$head Syntax$$
    27 $icode%y% = %fun%(%x%)
    28 %$$
     27$icode%y% = %fun%(%x%)%$$
     28
     29$head Purpose$$
     30Evaluates the standard math function $icode fun$$.
    2931
    3032$head Possible Types$$
    31 Evaluates the standard math function $icode fun$$
    32 for any of the possible types listed below:
    3333
    34 $head Base$$
     34$subhead Base$$
    3535If $icode Base$$ satisfies the
    3636$cref/base type requirements/base_require/$$
     
    4444%$$
    4545
    46 $head AD<Base>$$
     46$subhead AD<Base>$$
    4747If the argument $icode x$$ has prototype
    4848$codei%
     
    5454%$$
    5555
    56 $head VecAD<Base>$$
     56$subhead VecAD<Base>$$
    5757If the argument $icode x$$ has prototype
    5858$codei%
     
    117117
    118118/*
    119 $begin binary_standard_math$$
     119$begin binary_math$$
    120120
    121 $section The Binary Standard Math Functions$$
     121$section The Binary Math Functions$$
    122122
    123123$childtable%cppad/local/atan2.hpp
    124124        %cppad/local/pow.hpp
     125        %cppad/local/azmul.hpp
    125126%$$
    126127
  • trunk/cppad/local/tan_op.hpp

    r3667 r3735  
    209209        Base* py       = pz - nc_partial;
    210210
    211         // If pz is zero, make sure this operation has no effect
    212         // (zero times infinity or nan would be non-zero).
    213         bool skip(true);
    214         for(size_t i_d = 0; i_d <= d; i_d++)
    215                 skip &= IdenticalZero(pz[i_d]);
    216         if( skip )
    217                 return;
    218211
    219212        size_t j = d;
     
    225218                pz[j]   /= Base(j);
    226219                for(k = 1; k <= j; k++)
    227                 {       px[k]   += pz[j] * y[j-k] * Base(k);
    228                         py[j-k] += pz[j] * x[k] * Base(k);
     220                {       px[k]   += azmul(pz[j], y[j-k]) * Base(k);
     221                        py[j-k] += azmul(pz[j], x[k]) * Base(k);
    229222                }
    230223                for(k = 0; k < j; k++)
    231                         pz[k] += py[j-1] * z[j-k-1] * base_two;
     224                        pz[k] += azmul(py[j-1], z[j-k-1]) * base_two;
    232225
    233226                --j;
    234227        }
    235         px[0] += pz[0] * (Base(1) + y[0]);
     228        px[0] += azmul(pz[0], Base(1) + y[0]);
    236229}
    237230
  • trunk/cppad/local/tanh_op.hpp

    r3667 r3735  
    208208        Base* py       = pz - nc_partial;
    209209
    210         // If pz is zero, make sure this operation has no effect
    211         // (zero times infinity or nan would be non-zero).
    212         bool skip(true);
    213         for(size_t i_d = 0; i_d <= d; i_d++)
    214                 skip &= IdenticalZero(pz[i_d]);
    215         if( skip )
    216                 return;
    217210
    218211        size_t j = d;
     
    224217                pz[j]   /= Base(j);
    225218                for(k = 1; k <= j; k++)
    226                 {       px[k]   -= pz[j] * y[j-k] * Base(k);
    227                         py[j-k] -= pz[j] * x[k] * Base(k);
     219                {       px[k]   -= azmul(pz[j], y[j-k]) * Base(k);
     220                        py[j-k] -= azmul(pz[j], x[k]) * Base(k);
    228221                }
    229222                for(k = 0; k < j; k++)
    230                         pz[k] += py[j-1] * z[j-k-1] * base_two;
     223                        pz[k] += azmul(py[j-1], z[j-k-1]) * base_two;
    231224
    232225                --j;
    233226        }
    234         px[0] += pz[0] * (Base(1) - y[0]);
     227        px[0] += azmul(pz[0], Base(1) - y[0]);
    235228}
    236229
  • trunk/cppad/local/undef.hpp

    r3685 r3735  
    6161# undef CPPAD_ASSERT_NOT_PARALLEL
    6262# undef CPPAD_ASSERT_ARG_BEFORE_RESULT
     63# undef CPPAD_AZMUL
    6364# undef CPPAD_BOOSTVECTOR
    6465# undef CPPAD_COND_EXP
  • trunk/cppad/local/zdouble.hpp

    r3705 r3735  
    2222$$
    2323$section zdouble: An AD Base Type With Absolute Zero$$
     24
     25$head Deprecated 2015-09-26$$
     26Use the function $cref azmul$$ instead.
    2427
    2528$head Absolute Zero$$
     
    442445{       return static_cast<int>(x.dbl_); }
    443446
     447/// Base type requirement: azmul
     448inline zdouble azmul(const zdouble& x, const zdouble& y)
     449{       return x * y; }
     450
    444451/// Base type requirement: Ordered
    445452inline bool GreaterThanZero(const zdouble& x)
  • trunk/example/CMakeLists.txt

    r3733 r3735  
    9191        atanh.cpp
    9292        atan2.cpp
     93        azmul.cpp
    9394        base_alloc.hpp
    9495        base_require.cpp
  • trunk/example/base_alloc.hpp

    r3724 r3735  
    1515$begin base_alloc.hpp$$
    1616$spell
     17        azmul
    1718        expm1
    1819        atanh
     
    249250/* $$
    250251
     252$head azmul$$
     253$codep */
     254namespace CppAD {
     255        CPPAD_AZMUL( base_alloc )
     256}
     257/* $$
     258
    251259$head Ordered$$
    252260The $code base_alloc$$ type supports ordered comparisons
  • trunk/example/example.cpp

    r3733 r3735  
    6262extern bool atanh(void);
    6363extern bool atan2(void);
     64extern bool azmul(void);
    6465extern bool base_require(void);
    6566extern bool BenderQuad(void);
     
    142143extern bool ParVar(void);
    143144extern bool Poly(void);
    144 extern bool Pow(void);
     145extern bool pow(void);
    145146extern bool pow_int(void);
    146147extern bool print_for(void);
     
    233234        ok &= Run( atanh,             "atanh"            );
    234235        ok &= Run( atan2,             "atan2"            );
     236        ok &= Run( azmul,             "azmul"            );
    235237        ok &= Run( BenderQuad,        "BenderQuad"       );
    236238        ok &= Run( BoolFun,           "BoolFun"          );
     
    305307        ok &= Run( optimize,          "optimize"         );
    306308        ok &= Run( ParVar,            "ParVar"           );
    307         ok &= Run( Pow,               "Poly"             );
    308         ok &= Run( Pow,               "Pow"              );
     309        ok &= Run( Poly,              "Poly"             );
     310        ok &= Run( pow,               "pow"              );
    309311        ok &= Run( pow_int,           "pow_int"          );
    310312        ok &= Run( reverse_any,       "reverse_any"      );
  • trunk/example/makefile.am

    r3733 r3735  
    9797        atanh.cpp \
    9898        atan2.cpp \
     99        azmul.cpp \
    99100        base_alloc.hpp \
    100101        base_require.cpp \
  • trunk/example/makefile.in

    r3733 r3735  
    115115        add.cpp add_eq.cpp ad_assign.cpp ad_ctor.cpp ad_fun.cpp \
    116116        ad_in_c.cpp ad_input.cpp ad_output.cpp asin.cpp asinh.cpp \
    117         atan.cpp atanh.cpp atan2.cpp base_alloc.hpp base_require.cpp \
    118         bender_quad.cpp bool_fun.cpp capacity_order.cpp \
    119         change_param.cpp check_for_nan.cpp check_numeric_type.cpp \
    120         check_simple_vector.cpp compare.cpp compare_change.cpp \
    121         complex_poly.cpp cond_exp.cpp conj_grad.cpp cos.cpp cosh.cpp \
    122         cppad_vector.cpp dependency.cpp div.cpp div_eq.cpp \
    123         equal_op_seq.cpp erf.cpp error_handler.cpp exp.cpp expm1.cpp \
    124         for_one.cpp for_two.cpp forward.cpp forward_dir.cpp \
     117        atan.cpp atanh.cpp atan2.cpp azmul.cpp base_alloc.hpp \
     118        base_require.cpp bender_quad.cpp bool_fun.cpp \
     119        capacity_order.cpp change_param.cpp check_for_nan.cpp \
     120        check_numeric_type.cpp check_simple_vector.cpp compare.cpp \
     121        compare_change.cpp complex_poly.cpp cond_exp.cpp conj_grad.cpp \
     122        cos.cpp cosh.cpp cppad_vector.cpp dependency.cpp div.cpp \
     123        div_eq.cpp equal_op_seq.cpp erf.cpp error_handler.cpp exp.cpp \
     124        expm1.cpp for_one.cpp for_two.cpp forward.cpp forward_dir.cpp \
    125125        forward_order.cpp for_sparse_jac.cpp fun_assign.cpp \
    126126        fun_check.cpp hes_lagrangian.cpp hes_lu_det.cpp \
     
    154154        ad_in_c.$(OBJEXT) ad_input.$(OBJEXT) ad_output.$(OBJEXT) \
    155155        asin.$(OBJEXT) asinh.$(OBJEXT) atan.$(OBJEXT) atanh.$(OBJEXT) \
    156         atan2.$(OBJEXT) base_require.$(OBJEXT) bender_quad.$(OBJEXT) \
    157         bool_fun.$(OBJEXT) capacity_order.$(OBJEXT) \
    158         change_param.$(OBJEXT) check_for_nan.$(OBJEXT) \
    159         check_numeric_type.$(OBJEXT) check_simple_vector.$(OBJEXT) \
    160         compare.$(OBJEXT) compare_change.$(OBJEXT) \
    161         complex_poly.$(OBJEXT) cond_exp.$(OBJEXT) conj_grad.$(OBJEXT) \
    162         cos.$(OBJEXT) cosh.$(OBJEXT) cppad_vector.$(OBJEXT) \
    163         dependency.$(OBJEXT) div.$(OBJEXT) div_eq.$(OBJEXT) \
    164         equal_op_seq.$(OBJEXT) erf.$(OBJEXT) error_handler.$(OBJEXT) \
    165         exp.$(OBJEXT) expm1.$(OBJEXT) for_one.$(OBJEXT) \
    166         for_two.$(OBJEXT) forward.$(OBJEXT) forward_dir.$(OBJEXT) \
     156        atan2.$(OBJEXT) azmul.$(OBJEXT) base_require.$(OBJEXT) \
     157        bender_quad.$(OBJEXT) bool_fun.$(OBJEXT) \
     158        capacity_order.$(OBJEXT) change_param.$(OBJEXT) \
     159        check_for_nan.$(OBJEXT) check_numeric_type.$(OBJEXT) \
     160        check_simple_vector.$(OBJEXT) compare.$(OBJEXT) \
     161        compare_change.$(OBJEXT) complex_poly.$(OBJEXT) \
     162        cond_exp.$(OBJEXT) conj_grad.$(OBJEXT) cos.$(OBJEXT) \
     163        cosh.$(OBJEXT) cppad_vector.$(OBJEXT) dependency.$(OBJEXT) \
     164        div.$(OBJEXT) div_eq.$(OBJEXT) equal_op_seq.$(OBJEXT) \
     165        erf.$(OBJEXT) error_handler.$(OBJEXT) exp.$(OBJEXT) \
     166        expm1.$(OBJEXT) for_one.$(OBJEXT) for_two.$(OBJEXT) \
     167        forward.$(OBJEXT) forward_dir.$(OBJEXT) \
    167168        forward_order.$(OBJEXT) for_sparse_jac.$(OBJEXT) \
    168169        fun_assign.$(OBJEXT) fun_check.$(OBJEXT) \
     
    526527        atanh.cpp \
    527528        atan2.cpp \
     529        azmul.cpp \
    528530        base_alloc.hpp \
    529531        base_require.cpp \
     
    719721@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/atan2.Po@am__quote@
    720722@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/atanh.Po@am__quote@
     723@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/azmul.Po@am__quote@
    721724@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/base_require.Po@am__quote@
    722725@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/bender_quad.Po@am__quote@
  • trunk/example/mul_level.cpp

    r3688 r3735  
    1414$begin mul_level.cpp$$
    1515$spell
    16         zdouble
    1716        Adolc
    1817        adouble
     
    2423
    2524$head Purpose$$
    26 In this example, we use $code AD< AD<zdouble> >$$ (level two taping),
     25In this example, we use $code AD< AD<double> >$$ (level two taping),
    2726the compute values of the function $latex f : \B{R}^n \rightarrow \B{R}$$ where
    2827$latex \[
    2928        f(x) = \frac{1}{2} \left( x_0^2 + \cdots + x_{n-1}^2 \right)
    3029\] $$
    31 We then use $code AD<zdouble>$$ (level one taping) to compute
     30We then use $code AD<double>$$ (level one taping) to compute
    3231the directional derivative
    3332$latex \[
     
    3534\] $$.
    3635where $latex v \in \B{R}^n$$.
    37 We then use $cref zdouble$$ (no taping) to compute
     36We then use $code double$$ (no taping) to compute
    3837$latex \[
    3938\frac{d}{dx} \left[ f^{(1)} (x) * v \right] = v
     
    7877{       bool ok = true;                          // initialize test result
    7978
    80         using CppAD::zdouble;                   // double with absolute zero
    81         typedef CppAD::AD<zdouble>   a1type;    // for one level of taping
     79        typedef CppAD::AD<double>   a1type;    // for one level of taping
    8280        typedef CppAD::AD<a1type>    a2type;    // for two levels of taping
    8381        size_t n = 5;                           // dimension for example
     
    8583
    8684        // 10 times machine epsilon
    87         zdouble eps = 10. * std::numeric_limits<double>::epsilon();
     85        double eps = 10. * std::numeric_limits<double>::epsilon();
    8886
    89         CPPAD_TESTVECTOR(zdouble) x(n);
     87        CPPAD_TESTVECTOR(double) x(n);
    9088        CPPAD_TESTVECTOR(a1type)  a1x(n), a1v(n), a1dy(1) ;
    9189        CPPAD_TESTVECTOR(a2type)  a2x(n), a2y(1);
     
    9391        // Values for the independent variables while taping the function f(x)
    9492        for(j = 0; j < n; j++)
    95                 a2x[j] = a1x[j] = x[j] = zdouble(j);
     93                a2x[j] = a1x[j] = x[j] = double(j);
    9694        // Declare the independent variable for taping f(x)
    9795        CppAD::Independent(a2x);
    9896
    99         // Use AD< AD<zdouble> > to tape the evaluation of f(x)
     97        // Use AD< AD<double> > to tape the evaluation of f(x)
    10098        a2y[0] = f(a2x);
    10199
    102         // Declare a1f as the corresponding ADFun< AD<zdouble> >
     100        // Declare a1f as the corresponding ADFun< AD<double> >
    103101        // (make sure we do not run zero order forward during constructor)
    104102        CppAD::ADFun<a1type> a1f;
     
    114112        // compute f'(x) * v
    115113        for(j = 0; j < n; j++)
    116                 a1v[j] = zdouble(n - j);
     114                a1v[j] = double(n - j);
    117115        a1dy = a1f.Forward(1, a1v);
    118116
    119         // declare g as ADFun<zdouble> function corresponding to f'(x) * v
    120         CppAD::ADFun<zdouble> g;
     117        // declare g as ADFun<double> function corresponding to f'(x) * v
     118        CppAD::ADFun<double> g;
    121119        g.Dependent(a1x, a1dy);
    122120
     
    128126
    129127        // compute the d/dx of f'(x) * v = f''(x) * v = v
    130         CPPAD_TESTVECTOR(zdouble) w(1);
    131         CPPAD_TESTVECTOR(zdouble) dw(n);
     128        CPPAD_TESTVECTOR(double) w(1);
     129        CPPAD_TESTVECTOR(double) dw(n);
    132130        w[0] = 1.;
    133131        dw   = g.Reverse(1, w);
  • trunk/example/pow.cpp

    r2506 r3735  
    11/* $Id$ */
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
    6 the terms of the 
     6the terms of the
    77                    Eclipse Public License Version 1.0.
    88
     
    1818$section The AD Power Function: Example and Test$$
    1919
    20 $index pow, AD example$$
    21 $index example, AD pow$$
    22 $index test, AD pow$$
    23 
    2420$code
    2521$verbatim%example/pow.cpp%0%// BEGIN C++%// END C++%1%$$
     
    3329# include <cmath>
    3430
    35 bool Pow(void)
     31bool pow(void)
    3632{       bool ok = true;
    3733
    3834        using CppAD::AD;
    3935        using CppAD::NearEqual;
     36        double eps = 10. * std::numeric_limits<double>::epsilon();
    4037
    4138        // domain space vector
     
    4340        double x = 0.5;
    4441        double y = 2.;
    45         CPPAD_TESTVECTOR(AD<double>) XY(n);
    46         XY[0]      = x;
    47         XY[1]      = y;
     42        CPPAD_TESTVECTOR(AD<double>) axy(n);
     43        axy[0]      = x;
     44        axy[1]      = y;
    4845
    4946        // declare independent variables and start tape recording
    50         CppAD::Independent(XY);
     47        CppAD::Independent(axy);
    5148
    52         // range space vector 
     49        // range space vector
    5350        size_t m = 3;
    54         CPPAD_TESTVECTOR(AD<double>) Z(m);
    55         Z[0] = CppAD::pow(XY[0], XY[1]); // pow(variable, variable)
    56         Z[1] = CppAD::pow(XY[0], y);      // pow(variable, parameter)
    57         Z[2] = CppAD::pow(x,     XY[1]);  // pow(parameter, variable)
     51        CPPAD_TESTVECTOR(AD<double>) az(m);
     52        az[0] = CppAD::pow(axy[0], axy[1]); // pow(variable, variable)
     53        az[1] = CppAD::pow(axy[0], y);      // pow(variable, parameter)
     54        az[2] = CppAD::pow(x,     axy[1]);  // pow(parameter, variable)
    5855
    59         // create f: XY -> Z and stop tape recording
    60         CppAD::ADFun<double> f(XY, Z);
     56        // create f: axy -> az and stop tape recording
     57        CppAD::ADFun<double> f(axy, az);
    6158
    62         // check value 
     59        // check value
    6360        double check = std::pow(x, y);
    6461        size_t i;
    6562        for(i = 0; i < m; i++)
    66                 ok &= NearEqual(Z[i] , check,  1e-10 , 1e-10);
     63                ok &= NearEqual(az[i] , check,  eps, eps);
    6764
    6865        // forward computation of first partial w.r.t. x
     
    7370        dz    = f.Forward(1, dxy);
    7471        check = y * std::pow(x, y-1.);
    75         ok   &= NearEqual(dz[0], check, 1e-10, 1e-10);
    76         ok   &= NearEqual(dz[1], check, 1e-10, 1e-10);
    77         ok   &= NearEqual(dz[2],    0., 1e-10, 1e-10);
     72        ok   &= NearEqual(dz[0], check, eps, eps);
     73        ok   &= NearEqual(dz[1], check, eps, eps);
     74        ok   &= NearEqual(dz[2],    0., eps, eps);
    7875
    7976        // forward computation of first partial w.r.t. y
     
    8279        dz    = f.Forward(1, dxy);
    8380        check = std::log(x) * std::pow(x, y);
    84         ok   &= NearEqual(dz[0], check, 1e-10, 1e-10);
    85         ok   &= NearEqual(dz[1],    0., 1e-10, 1e-10);
    86         ok   &= NearEqual(dz[2], check, 1e-10, 1e-10);
     81        ok   &= NearEqual(dz[0], check, eps, eps);
     82        ok   &= NearEqual(dz[1],    0., eps, eps);
     83        ok   &= NearEqual(dz[2], check, eps, eps);
    8784
    8885        // reverse computation of derivative of z[0] + z[1] + z[2]
     
    9491        dw    = f.Reverse(1, w);
    9592        check = y * std::pow(x, y-1.);
    96         ok   &= NearEqual(dw[0], 2. * check, 1e-10, 1e-10);
     93        ok   &= NearEqual(dw[0], 2. * check, eps, eps);
    9794        check = std::log(x) * std::pow(x, y);
    98         ok   &= NearEqual(dw[1], 2. * check, 1e-10, 1e-10);
     95        ok   &= NearEqual(dw[1], 2. * check, eps, eps);
    9996
    10097        // use a VecAD<Base>::reference object with pow
     
    10299        AD<double> zero(0);
    103100        AD<double> one(1);
    104         v[zero]           = XY[0];
    105         v[one]            = XY[1];
     101        v[zero]           = axy[0];
     102        v[one]            = axy[1];
    106103        AD<double> result = CppAD::pow(v[zero], v[one]);
    107         ok               &= NearEqual(result, Z[0], 1e-10, 1e-10);
     104        ok               &= NearEqual(result, az[0], eps, eps);
    108105
    109106        return ok;
  • trunk/example/zdouble.cpp

    r3700 r3735  
    7575                Independent(a1x);
    7676                af1.Forward(0, a1x);
    77                 if( is_double )
    78                 {       // if Base is double, this would generate an assert
    79                         af1.check_for_nan(false);
    80                 }
    8177                a1z = af1.Reverse(1, a1w);
    8278                CppAD::ADFun<Base> g;
    83                 if( is_double )
    84                 {       // if Base is double, this would generate an assert
    85                                 g.check_for_nan(false);
    86                 }
    8779                g.Dependent(a1x, a1z);
    8880
     
    9284                x[1] = 0.0;
    9385                z    = g.Forward(0, x);
    94                 if( is_double )
    95                         ok &= CppAD::isnan(z[1]);
    96                 else
    97                 {       ok &= z[0] == 0.0;
    98                         ok &= z[1] == 0.0;
    99                 }
     86                ok &= z[0] == 0.0;
     87                ok &= z[1] == 0.0;
    10088
    10189                // check result for a case where f(x) = 1.0;
     
    112100                ok &= CppAD::NearEqual(z[0], 1.0/x[1], eps, eps);
    113101                ok &= CppAD::NearEqual(z[1], - x[0]/(x[1]*x[1]), eps, eps);
    114 
    115                 // check that nan works
    116                 ok &= CppAD::isnan( CppAD::nan( Base(0.0) ) );
    117102
    118103                return ok;
  • trunk/makefile.am

    r3688 r3735  
    148148        cppad/local/atanh_op.hpp \
    149149        cppad/local/atomic_base.hpp \
     150        cppad/local/azmul.hpp \
    150151        cppad/local/base_complex.hpp \
    151152        cppad/local/base_cond_exp.hpp \
     
    276277        cppad/local/vec_ad.hpp \
    277278        cppad/local/zdouble.hpp \
     279        cppad/local/zmul_op.hpp \
    278280        cppad/lu_factor.hpp \
    279281        cppad/lu_invert.hpp \
  • trunk/makefile.in

    r3705 r3735  
    539539        cppad/local/atanh_op.hpp \
    540540        cppad/local/atomic_base.hpp \
     541        cppad/local/azmul.hpp \
    541542        cppad/local/base_complex.hpp \
    542543        cppad/local/base_cond_exp.hpp \
     
    667668        cppad/local/vec_ad.hpp \
    668669        cppad/local/zdouble.hpp \
     670        cppad/local/zmul_op.hpp \
    669671        cppad/lu_factor.hpp \
    670672        cppad/lu_invert.hpp \
  • trunk/omh/example_list.omh

    r3733 r3735  
    106106$cref atomic_sparsity.cpp$$
    107107$cref atomic_tangent.cpp$$
     108$cref azmul.cpp$$
    108109$rref base_adolc.hpp$$
    109110$rref base_alloc.hpp$$
  • trunk/omh/mul_level.omh

    r3688 r3735  
    1313$begin mul_level$$
    1414$spell
    15         zdouble
    1615        Taylor
    1716        fout
     
    3938
    4039$head Motivation$$
    41 Suppose that you uses derivatives of one or more inner functions
     40Suppose that you use derivatives of one or more inner functions
    4241as part of the operations
    4342needed to compute an outer function.
     
    5554The function defining the
    5655differential equation could be calculated using the class
    57 $codei AD< AD<zdouble> >$$; see $cref zdouble$$.
     56$codei AD< AD<double> >$$.
    5857
    5958$lnext
    6059The operations during the calculation of Taylor's method
    61 could be done using the $codei AD<zdouble>$$ class.
     60could be done using the $codei AD<double>$$ class.
    6261
    6362$lnext
    6463Derivatives of the solution of the differential equation
    65 could then be calculated using the $cref zdouble$$ class.
     64could then be calculated using the $code double$$ class.
    6665
    6766$lend
     
    6968$head Procedure$$
    7069
    71 $subhead Double Record AD< AD<zdouble> >$$
     70$subhead First Start AD<double>$$
    7271If some of the $cref/parameters/glossary/Parameter/$$
    73 in the $codei AD< AD<zdouble> >$$ recording depend on the
     72in the $codei AD< AD<double> >$$ recording depend on the
    7473$cref/variables/glossary/Variable/$$
    75 in the $codei AD<zdouble>$$ recording,
     74in the $codei AD<double>$$ recording,
    7675we must first declaring these variables; i.e.,
    7776$codei%
     
    7978%$$
    8079where $icode a1x$$ is
    81 a $cref SimpleVector$$ with elements of type $codei AD<zdouble>$$.
     80a $cref SimpleVector$$ with elements of type $codei AD<double>$$.
    8281This will start recording a new tape of
    83 operations performed using $codei AD<zdouble>$$ class objects.
     82operations performed using $codei AD<double>$$ class objects.
    8483
    85 $subhead Start AD< AD<zdouble> > Recording$$
     84$subhead Start AD< AD<double> > Recording$$
    8685The next step is to declare the independent variables using
    8786$codei%
     
    9089where $icode a2x$$ is
    9190a $cref SimpleVector$$ with elements of type
    92 $codei AD< AD<zdouble> >$$.
     91$codei AD< AD<double> >$$.
    9392This will start recording a new tape of
    94 operations performed using $codei AD< AD<zdouble> >$$ class objects.
     93operations performed using $codei AD< AD<double> >$$ class objects.
    9594
    9695$subhead Inner Function$$
    9796The next step is to calculation the inner function
    98 using $codei AD< AD<zdouble> >$$ class objects.
     97using $codei AD< AD<double> >$$ class objects.
    9998We then stop the recording using
    10099$codei%
     
    103102where $icode a2y$$ is
    104103a $cref SimpleVector$$ with elements of type
    105 $codei AD< AD<zdouble> >$$
    106 and $icode a1f$$ is an $codei%ADFun< AD<zdouble> >%$$ object.
     104$codei AD< AD<double> >$$
     105and $icode a1f$$ is an $codei%ADFun< AD<double> >%$$ object.
    107106
    108 $subhead Single Record AD< AD<zdouble> >$$
     107$subhead Second Start AD< AD<double> >$$
    109108If none of the $cref/parameters/glossary/Parameter/$$
    110 in the $codei AD< AD<zdouble> >$$ recording depend on the
     109in the $codei AD< AD<double> >$$ recording depend on the
    111110$cref/variables/glossary/Variable/$$
    112 in the $codei AD<zdouble>$$ recording,
     111in the $codei AD<double>$$ recording,
    113112it is preferred to delay declaring these variables to this point; i.e.,
    114113$codei%
     
    116115%$$
    117116where $icode a1x$$ is
    118 a $cref SimpleVector$$ with elements of type $codei AD<zdouble>$$.
     117a $cref SimpleVector$$ with elements of type $codei AD<double>$$.
    119118This will start recording a new tape of
    120 operations performed using $codei AD<zdouble>$$ class objects.
     119operations performed using $codei AD<double>$$ class objects.
    121120
    122121$subhead Outer Function$$
    123122The next step is to calculation the outer function
    124 using $codei AD<zdouble>$$ class objects.
     123using $codei AD<double>$$ class objects.
    125124Note that derivatives of the inner function can be included
    126125in the calculation of the outer function using $icode a1f$$.
    127 We then stop the recording of $codei AD<zdouble>$$ operations using
     126We then stop the recording of $codei AD<double>$$ operations using
    128127$codei%
    129128        %g%.Dependent(%a1x%, %a1y%)
     
    131130where $icode a1y$$ is
    132131a $cref SimpleVector$$ with elements of type
    133 $codei AD<zdouble>$$
    134 and $icode g$$ is an $codei%ADFun<zdouble>%$$ object.
     132$codei AD<double>$$
     133and $icode g$$ is an $codei%ADFun<double>%$$ object.
    135134
    136135$subhead Derivatives of Outer Function$$
  • trunk/omh/whats_new/whats_new_15.omh

    r3731 r3735  
    1414$dollar @$$
    1515$spell
     16        enum
    1617        ctor
    1718        dimensioned
     
    7172assist you in learning about changes between various versions of CppAD.
    7273
     74$head 09-28$$
     75$list number$$
     76Use the current $cref atomic_option$$ setting to determine
     77which type of sparsity patterns to use for
     78$cref/dependency/dependency.cpp/$$ calculations during
     79$cref optimize$$ procedure.
     80It used to be that the
     81$cref/bool_sparsity_enum/atomic_option/atomic_sparsity/bool_sparsity_enum/$$
     82was used when
     83$cref/pack_sparsity_enum/atomic_option/atomic_sparsity/pack_sparsity_enum/$$
     84was specified.
     85$lnext
     86It is not longer an error to take the derivative of the square root function,
     87because the result may be the part of a
     88$cref/conditional expression/CondExp/$$ that is not used.
     89$lnext
     90Update the $cref WishList$$ section.
     91$lend
     92
     93
     94$head 09-27$$
     95$list number$$
     96It is no longer necessary to use the $cref zdouble$$ class when
     97computing with $cref/multiple levels of AD/mul_level/$$
     98$cref/conditional expressions/CondExp/$$ and
     99$cref/reverse mode/reverse/$$.
     100$lnext
     101The $code zdouble$$ class has been deprecated.
     102Use the $cref azmul$$ function for absolute zero (when it is needed).
     103$lend
     104
     105$head 09-25$$
     106Warning:
     107$cref/absolute zero multiplication/base_require/Absolute Zero, azmul/$$
     108is now required for user defined base types.
     109This makes it possible to combine
     110$cref/conditional expression/CondExp/$$,
     111$cref/multiple levels/mul_level/$$,
     112$cref/reverse/Reverse/$$, and
     113a base type that has standard ieee multiplication; e.g., $code double$$.
     114In other words, not all multiplications will need to have an
     115absolute zero (as is the case with the $cref zdouble$$ base class.
     116
    73117$head 09-24$$
    74118Fix some Visual Studio 2013 C++ level four $code /W4$$ warnings
     
    288332
    289333$head 06-09$$
    290 Add $cref/abort_op_index/WishList/abort_op_index/$$ to the wish list.
     334Add an $cref/abort_op_index/Independent/abort_op_index/$$
     335item to the wish list. It has since been removed
     336(domain errors may not affect the results due to
     337$cref/conditional expressions/CondExp/$$).
     338
    291339
    292340$head 06-07$$
    293 Add $cref/absolute zero/WishList/Absolute Zero/$$
     341Add
     342$cref/absolute zero/base_require/Absolute Zero, azmul/$$
    294343and $cref/numeric_limits/WishList/Numeric Limits/$$ items to the wish list.
     344(The absolute zero item has been completed.)
    295345Remove the multiple directions with list item.
    296346
     
    339389$lnext
    340390The base type requirements were modified to include mention of
    341 $cref/absolute zero/base_require/Absolute Zero/$$.
     391$cref/absolute zero/base_require/Absolute Zero, azmul/$$.
    342392In addition, the base type requirements
    343393$cref/warning/base_require/Warning/$$ is now more informative.
  • trunk/omh/wish_list.omh

    r3724 r3735  
    4444$section The CppAD Wish List$$
    4545
    46 $head Optimize Atomic Operations$$
    47 Use the current $cref atomic_option$$ setting to determine
    48 which type of sparsity patterns to use for
    49 $cref/dependency/dependency.cpp/$$ calculations during
    50 $cref optimize$$ procedure.
    51 In addition, use forward mode, instead of reverse, when it is more efficient
    52 for the dependency calculations.
    53 
    54 $head checkpoint$$
    55 There should be some examples and tests for both speed and memory use
    56 that demonstrate that checkpointing is useful.
    57 
    58 $head abort_op_index$$
    59 When a known error is detected during $cref forward$$ or $cref reverse$$ mode,
    60 include the operator index in the output error message. (For example,
    61 when taking the derivative of the square root function at zero.)
    62 The syntax
    63 $codei%
    64         Independent(%x%, %abort_op_index%)
    65 %$$
    66 could then be used to find the corresponding user source code; see
    67 $cref/abort_op_index/Independent/abort_op_index/$$.
    68 
    69 $head Absolute Zero$$
    70 Currently, one must use the $cref zdouble$$ class for
    71 $cref mul_level$$ AD that uses $cref/conditional expressions/CondExp/$$
    72 and $cref reverse$$ mode.
    73 Perhaps it would be better to use special functions; e.g.,
    74 $code abs_zero_mul$$ and $code abs_zero_div$$,
    75 so that not all multiplies and divides would need to check for zero
    76 (in the multiple level AD with conditional expressions and reverse mode case).
    77 
    7846$head Numeric Limits$$
    7947Define a specialization for
     
    8149        std::numeric_limits< CppAD::AD<%Base%> >
    8250%$$
     51
     52$subhead Rationale$$
    8353This seems to be OK according to the following paragraph from Section
    845417.6.4.2.1 of the C++11 standard (Document number N3336)
     
    8757user-defined type and the instantiation meets the
    8858standard library requirements for the original template.'
     59
     60$subhead nan$$
     61Once this is done, the $cref nan$$ function should can be deprecated
     62because it generates compiler warnings about dividing by zero.
     63
     64$head checkpoint$$
     65There should be some examples and tests for both speed and memory use
     66that demonstrate that checkpointing is useful.
    8967
    9068$head Machine Epsilon in Examples$$
  • trunk/test_more/CMakeLists.txt

    r3733 r3735  
    7878        atanh.cpp
    7979        atan2.cpp
     80        azmul.cpp
    8081        base_alloc.cpp
    8182        check_simple_vector.cpp
     
    113114        mul_eq.cpp
    114115        mul_level.cpp
     116        mul_cond_rev.cpp
    115117        mul_zdouble.cpp
    116118        mul_zero_one.cpp
  • trunk/test_more/makefile.am

    r3733 r3735  
    103103        atanh.cpp \
    104104        atan2.cpp \
     105        azmul.cpp \
    105106        base_alloc.cpp \
    106107        check_simple_vector.cpp \
     
    139140        mul_eq.cpp \
    140141        mul_level.cpp \
     142        mul_cond_rev.cpp \
    141143        mul_zdouble.cpp \
    142144        mul_zero_one.cpp \
  • trunk/test_more/makefile.in

    r3733 r3735  
    114114        alloc_openmp.cpp test_more.cpp abs.cpp acos.cpp acosh.cpp \
    115115        adfun_copy.cpp asin.cpp asinh.cpp assign.cpp add.cpp \
    116         add_eq.cpp add_zero.cpp atan.cpp atanh.cpp atan2.cpp \
     116        add_eq.cpp add_zero.cpp atan.cpp atanh.cpp atan2.cpp azmul.cpp \
    117117        base_alloc.cpp check_simple_vector.cpp checkpoint.cpp \
    118118        compare.cpp compare_change.cpp cond_exp.cpp cond_exp_ad.cpp \
     
    123123        forward_order.cpp from_base.cpp fun_check.cpp jacobian.cpp \
    124124        limits.cpp log.cpp log1p.cpp log10.cpp mul.cpp mul_cskip.cpp \
    125         mul_eq.cpp mul_level.cpp mul_zdouble.cpp mul_zero_one.cpp \
    126         near_equal_ext.cpp neg.cpp ode_err_control.cpp omp_alloc.cpp \
    127         optimize.cpp parameter.cpp poly.cpp pow.cpp pow_int.cpp \
    128         print_for.cpp romberg_one.cpp rosen_34.cpp runge_45.cpp \
    129         reverse.cpp rev_sparse_hes.cpp rev_sparse_jac.cpp rev_two.cpp \
    130         simple_vector.cpp sin.cpp sin_cos.cpp sinh.cpp \
    131         sparse_hessian.cpp sparse_jacobian.cpp sparse_vec_ad.cpp \
    132         sqrt.cpp std_math.cpp sub.cpp sub_eq.cpp sub_zero.cpp tan.cpp \
    133         test_vector.cpp track_new_del.cpp value.cpp vec_ad.cpp \
    134         vec_ad_par.cpp vec_unary.cpp
     125        mul_eq.cpp mul_level.cpp mul_cond_rev.cpp mul_zdouble.cpp \
     126        mul_zero_one.cpp near_equal_ext.cpp neg.cpp \
     127        ode_err_control.cpp omp_alloc.cpp optimize.cpp parameter.cpp \
     128        poly.cpp pow.cpp pow_int.cpp print_for.cpp romberg_one.cpp \
     129        rosen_34.cpp runge_45.cpp reverse.cpp rev_sparse_hes.cpp \
     130        rev_sparse_jac.cpp rev_two.cpp simple_vector.cpp sin.cpp \
     131        sin_cos.cpp sinh.cpp sparse_hessian.cpp sparse_jacobian.cpp \
     132        sparse_vec_ad.cpp sqrt.cpp std_math.cpp sub.cpp sub_eq.cpp \
     133        sub_zero.cpp tan.cpp test_vector.cpp track_new_del.cpp \
     134        value.cpp vec_ad.cpp vec_ad_par.cpp vec_unary.cpp
    135135@CppAD_ADOLC_TRUE@am__objects_1 = base_adolc.$(OBJEXT)
    136136@CppAD_IPOPT_TRUE@am__objects_2 = ipopt_solve.$(OBJEXT)
     
    141141        asin.$(OBJEXT) asinh.$(OBJEXT) assign.$(OBJEXT) add.$(OBJEXT) \
    142142        add_eq.$(OBJEXT) add_zero.$(OBJEXT) atan.$(OBJEXT) \
    143         atanh.$(OBJEXT) atan2.$(OBJEXT) base_alloc.$(OBJEXT) \
    144         check_simple_vector.$(OBJEXT) checkpoint.$(OBJEXT) \
    145         compare.$(OBJEXT) compare_change.$(OBJEXT) cond_exp.$(OBJEXT) \
     143        atanh.$(OBJEXT) atan2.$(OBJEXT) azmul.$(OBJEXT) \
     144        base_alloc.$(OBJEXT) check_simple_vector.$(OBJEXT) \
     145        checkpoint.$(OBJEXT) compare.$(OBJEXT) \
     146        compare_change.$(OBJEXT) cond_exp.$(OBJEXT) \
    146147        cond_exp_ad.$(OBJEXT) cond_exp_rev.$(OBJEXT) copy.$(OBJEXT) \
    147148        cos.$(OBJEXT) cosh.$(OBJEXT) dbl_epsilon.$(OBJEXT) \
     
    154155        limits.$(OBJEXT) log.$(OBJEXT) log1p.$(OBJEXT) log10.$(OBJEXT) \
    155156        mul.$(OBJEXT) mul_cskip.$(OBJEXT) mul_eq.$(OBJEXT) \
    156         mul_level.$(OBJEXT) mul_zdouble.$(OBJEXT) \
    157         mul_zero_one.$(OBJEXT) near_equal_ext.$(OBJEXT) neg.$(OBJEXT) \
     157        mul_level.$(OBJEXT) mul_cond_rev.$(OBJEXT) \
     158        mul_zdouble.$(OBJEXT) mul_zero_one.$(OBJEXT) \
     159        near_equal_ext.$(OBJEXT) neg.$(OBJEXT) \
    158160        ode_err_control.$(OBJEXT) omp_alloc.$(OBJEXT) \
    159161        optimize.$(OBJEXT) parameter.$(OBJEXT) poly.$(OBJEXT) \
     
    505507        atanh.cpp \
    506508        atan2.cpp \
     509        azmul.cpp \
    507510        base_alloc.cpp \
    508511        check_simple_vector.cpp \
     
    541544        mul_eq.cpp \
    542545        mul_level.cpp \
     546        mul_cond_rev.cpp \
    543547        mul_zdouble.cpp \
    544548        mul_zero_one.cpp \
     
    651655@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/atan2.Po@am__quote@
    652656@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/atanh.Po@am__quote@
     657@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/azmul.Po@am__quote@
    653658@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/base_adolc.Po@am__quote@
    654659@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/base_alloc.Po@am__quote@
     
    686691@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/log1p.Po@am__quote@
    687692@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/mul.Po@am__quote@
     693@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/mul_cond_rev.Po@am__quote@
    688694@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/mul_cskip.Po@am__quote@
    689695@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/mul_eq.Po@am__quote@
  • trunk/test_more/optimize.cpp

    r3732 r3735  
    2525
    2626        // note this enum type is not part of the API (but its values are)
    27         CppAD::atomic_base<double>::option_enum atomic_sparsity_option;
     27        CppAD::atomic_base<double>::option_enum atomic_sparsity_option_;
    2828        //
    2929        // ----------------------------------------------------------------
     
    124124
    125125                // now optimize the operation sequence
    126                 j_check.option( atomic_sparsity_option );
     126                j_check.option( atomic_sparsity_option_ );
    127127                if( conditional_skip_ )
    128128                        f.optimize();
     
    192192
    193193                // before optimize
    194                 k_check.option( atomic_sparsity_option );
    195                 h_check.option( atomic_sparsity_option );
     194                k_check.option( atomic_sparsity_option_ );
     195                h_check.option( atomic_sparsity_option_ );
    196196                ok  &= f.number_skip() == 0;
    197197
     
    260260
    261261                // now optimize the operation sequence
    262                 g_check.option( atomic_sparsity_option );
     262                g_check.option( atomic_sparsity_option_ );
    263263                if( conditional_skip_ )
    264264                        f.optimize();
     
    307307
    308308                // now optimize f so that the calculation of au[1] is removed
    309                 g_check.option( atomic_sparsity_option );
     309                g_check.option( atomic_sparsity_option_ );
    310310                if( conditional_skip_ )
    311311                        f.optimize();
     
    17751775bool optimize(void)
    17761776{       bool ok = true;
    1777         atomic_sparsity_option = CppAD::atomic_base<double>::bool_sparsity_enum;
    1778         conditional_skip_      = true;
     1777        conditional_skip_       = true;
     1778        atomic_sparsity_option_ = CppAD::atomic_base<double>::bool_sparsity_enum;
    17791779
    17801780        // atomic sparsity loop
    1781         for(size_t i = 0; i < 2; i++)
    1782         {       // check conditional expression sparsity pattern
     1781        for(size_t i = 0; i < 3; i++)
     1782        {       if( i == 0 ) atomic_sparsity_option_ =
     1783                        CppAD::atomic_base<double>::pack_sparsity_enum;
     1784                else if( i == 1 ) atomic_sparsity_option_ =
     1785                        CppAD::atomic_base<double>::bool_sparsity_enum;
     1786                else if( i == 2 ) atomic_sparsity_option_ =
     1787                        CppAD::atomic_base<double>::set_sparsity_enum;
     1788                else
     1789                        ok &= false;
     1790                //
     1791                // check conditional expression sparsity pattern
    17831792                // (used to optimize calls to atomic functions).
    17841793                ok     &= atomic_cond_exp_sparsity();
     
    17881797                ok     &= atomic_no_used();
    17891798                ok     &= atomic_arguments();
    1790                 atomic_sparsity_option =
    1791                         CppAD::atomic_base<double>::set_sparsity_enum;
    17921799        }
    17931800
    17941801        // conditional skip loop
    17951802        for(size_t i = 0; i < 2; i++)
    1796         {       // check nested conditional expressions
     1803        {       conditional_skip_ = i == 0;
     1804                //
     1805                // check nested conditional expressions
    17971806                ok     &= nested_cond_exp();
    17981807                // check reverse dependency analysis optimization
     
    18321841                // check case where an expresion needed by both true and false case
    18331842                ok     &=  cond_exp_both_true_and_false();
    1834                 //
    1835                 conditional_skip_ = false;
    18361843        }
    18371844        //
  • trunk/test_more/test_more.cpp

    r3733 r3735  
    3232extern bool atanh(void);
    3333extern bool atan2(void);
     34extern bool azmul(void);
    3435extern bool base_adolc(void);
    3536extern bool base_alloc_test(void);
     
    6768extern bool Mul(void);
    6869extern bool mul_level(void);
    69 extern bool mul_cond(void);
     70extern bool mul_cond_rev(void);
    7071extern bool mul_cskip(void);
    7172extern bool MulEq(void);
     
    155156        ok &= Run( atanh,           "atanh"          );
    156157        ok &= Run( atan2,           "atan2"          );
     158        ok &= Run( azmul,           "azmul"          );
    157159        ok &= Run( check_simple_vector, "check_simple_vector" );
    158160        ok &= Run( checkpoint,      "checkpoint"     );
     
    186188        ok &= Run( Mul,             "Mul"            );
    187189        ok &= Run( mul_level,       "mul_level"      );
     190        ok &= Run( mul_cond_rev,    "mul_cond_rev"   );
    188191        ok &= Run( mul_cskip,       "Mul_cskip"      );
    189192        ok &= Run( MulEq,           "MulEq"          );
Note: See TracChangeset for help on using the changeset viewer.