Changeset 3833 for trunk/test_more


Ignore:
Timestamp:
Sep 29, 2016 10:31:50 AM (3 years ago)
Author:
bradbell
Message:

merge to branch: trunk
from repository: https://github.com/coin-or/CppAD
start hash code: d9bb35cfcbbf4a69640d4e20aa59422061e65891
end hash code: 96c804b50258c73501bb0ae7460038223c426edb

commit 96c804b50258c73501bb0ae7460038223c426edb
Author: Brad Bell <bradbell@…>
Date: Thu Sep 29 04:56:00 2016 -0700

  1. Add erf atomic operation to multiple directions version of forward.
  2. Improve comments about computation of z_4 in erf_op.hpp.
  3. Advance to version cppad-20160929.


erf_op.hpp: remove CPPAD_HAS_ERROR_FUNCTION (no longer used).
forward1sweep.hpp: remove 2DO that has been completed.
erf.cpp: increase accuracy in test.
erf.cpp: add another test, move '# if' to start of line.

commit 5fd4cc1e16f8393ad1f198654485bad6b828a233
Author: Brad Bell <bradbell@…>
Date: Tue Sep 27 10:46:07 2016 -0700

cholesky.omh: minor correction.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/test_more/erf.cpp

    r3685 r3833  
    1 /* $Id$ */
     1// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    1414
    1515namespace {
     16        // ---------------------------------------------------------------------
    1617        bool old_example(void)
    1718        {       bool ok = true;
     
    2021                using CppAD::exp;
    2122                using CppAD::sqrt;
    22         # if CPPAD_USE_CPLUSPLUS_2011
     23# if CPPAD_USE_CPLUSPLUS_2011
    2324                double eps = 100.0 * std::numeric_limits<double>::epsilon();
    24         # endif
     25# endif
    2526                // Construct function object corresponding to erf
    2627                CPPAD_TESTVECTOR(AD<double>) ax(1);
     
    5152                check = df.Forward(0, x0);
    5253                ok   &= NearEqual(check[0], y1[0], 0., 2e-3);
    53         # if CPPAD_USE_CPLUSPLUS_2011
     54# if CPPAD_USE_CPLUSPLUS_2011
    5455                ok   &= NearEqual(check[0], y1[0], eps, eps);
    55         # endif
     56# endif
    5657
    5758                // check second derivative
     
    6162                check = df.Forward(1, x1);
    6263                ok   &= NearEqual(check[0] / 2.0, y2[0], 0., 2e-3);
    63         # if CPPAD_USE_CPLUSPLUS_2011
     64# if CPPAD_USE_CPLUSPLUS_2011
    6465                ok   &= NearEqual(check[0] / 2.0, y2[0], eps, eps);
    65         # endif
     66# endif
    6667
    6768                // check third derivative
     
    7172                check = df.Forward(2, x2);
    7273                ok   &= NearEqual(check[0] / 3.0, y3[0], 0., 2e-3);
    73         # if CPPAD_USE_CPLUSPLUS_2011
     74# if CPPAD_USE_CPLUSPLUS_2011
    7475                ok   &= NearEqual(check[0] / 3.0, y3[0], eps, eps);
    75         # endif
     76# endif
    7677
    7778                // check 4-th order of reverse mode
     
    8384                //
    8485                ok  &= NearEqual(dy[0], y1[0], 0., 2e-3);
    85         # if CPPAD_USE_CPLUSPLUS_2011
     86# if CPPAD_USE_CPLUSPLUS_2011
    8687                ok  &= NearEqual(dy[0], y1[0], eps, eps);
    87         # endif
     88# endif
    8889                //
    8990                ok  &= NearEqual(dy[1], 2.0 * y2[0], 0., 2e-3);
    90         # if CPPAD_USE_CPLUSPLUS_2011
     91# if CPPAD_USE_CPLUSPLUS_2011
    9192                ok  &= NearEqual(dy[1], 2.0 * y2[0], eps, eps);
    92         # endif
     93# endif
    9394                //
    9495                ok  &= NearEqual(dy[2], 3.0 * y3[0], 0., 2e-3);
    95         # if CPPAD_USE_CPLUSPLUS_2011
     96# if CPPAD_USE_CPLUSPLUS_2011
    9697                ok  &= NearEqual(dy[2], 3.0 * y3[0], eps, eps);
    97         # endif
     98# endif
    9899                //
    99100                ok  &= NearEqual(dy[3], 4.0 * y4[0], 0., 2e-3);
    100         # if CPPAD_USE_CPLUSPLUS_2011
     101# if CPPAD_USE_CPLUSPLUS_2011
    101102                ok  &= NearEqual(dy[3], 4.0 * y4[0], eps, eps);
    102         # endif
     103# endif
    103104
    104105                return ok;
    105106        }
    106107# if CPPAD_USE_CPLUSPLUS_2011
     108        // ---------------------------------------------------------------------
    107109        bool hessian(void)
    108110        {       bool ok = true;
     
    147149                return ok;
    148150        }
     151        // ---------------------------------------------------------------------
     152        bool mul_dir(void)
     153        {       bool ok = true;
     154                using namespace CppAD;
     155                using CppAD::atan;
     156                using CppAD::exp;
     157                using CppAD::sqrt;
     158                double eps = 100.0 * std::numeric_limits<double>::epsilon();
     159
     160                // Construct function object corresponding to erf
     161                CPPAD_TESTVECTOR(AD<double>) ax(1);
     162                CPPAD_TESTVECTOR(AD<double>) ay(1);
     163                ax[0] = 0.;
     164                Independent(ax);
     165                ay[0] = erf(ax[0]);
     166                ADFun<double> f(ax, ay);
     167
     168                // Construct function object corresponding to derivative of erf
     169                Independent(ax);
     170                double pi = 4.0 * atan(1.0);
     171                ay[0] = exp( - ax[0] * ax[0] ) * 2.0 / sqrt(pi);
     172                ADFun<double> df(ax, ay);
     173
     174                // number of directions
     175                size_t r = 1;
     176
     177                // vectors to use with objects
     178                CPPAD_TESTVECTOR(double) x0(1), y0(1), x1(1), y1(1), y2(1), y3(1);
     179                CPPAD_TESTVECTOR(double) zero(1), check(1);
     180                CPPAD_TESTVECTOR(double) xq(r), yq(r), checkq(r), zeroq(r);
     181
     182                // check function value
     183                x0[0]      = 1.5;
     184                y0         = f.Forward(0, x0);
     185                check[0]   = 0.9661051464753108;
     186                double tmp = std::max(1e-15, eps);
     187                ok        &= NearEqual(check[0], y0[0], 0.0, tmp);
     188
     189                // check first order derivative
     190                x1[0] = 1.0;
     191                y1    = f.Forward(1, x1);
     192                check = df.Forward(0, x0);
     193                ok   &= NearEqual(check[0], y1[0], eps, eps);
     194                for(size_t ell = 0.0; ell < r; ell++)
     195                {       xq[ell]     = x1[ell] / (ell + 1.0);
     196                        zeroq[ell]  = 0.0;
     197                }
     198                yq    = f.Forward(1, r, xq);
     199                for(size_t ell = 0.0; ell < r; ell++)
     200                {       checkq[ell] = check[0] * xq[ell];
     201                        ok         &= NearEqual(checkq[ell], yq[ell], eps, eps);
     202                }
     203
     204                // check second order derivative
     205                zero[0]   = 0.0;
     206                y2        = f.Forward(2, zero);
     207                check     = df.Forward(1, x1);
     208                check[0] /= 2.0;
     209                ok       &= NearEqual(check[0], y2[0], eps, eps);
     210                yq        = f.Forward(2, r, zeroq);
     211                for(size_t ell = 0.0; ell < r; ell++)
     212                {       checkq[ell] = check[0] * xq[ell];
     213                        ok         &= NearEqual(checkq[ell], yq[ell], eps, eps);
     214                }
     215
     216                // check third order derivative
     217                zero[0]   = 0.0;
     218                y3        = f.Forward(3, zero);
     219                check     = df.Forward(2, zero);
     220                check[0] /= 3.0;
     221                ok       &= NearEqual(check[0], y3[0], eps, eps);
     222                yq        = f.Forward(3, r, zeroq);
     223                for(size_t ell = 0.0; ell < r; ell++)
     224                {       checkq[ell] = check[0] * xq[ell];
     225                        ok         &= NearEqual(checkq[ell], yq[ell], eps, eps);
     226                }
     227
     228                return ok;
     229        }
     230        // -------------------------------------------------------------------
    149231# endif
    150232}
     
    154236# if CPPAD_USE_CPLUSPLUS_2011
    155237        ok     &= hessian();
     238        ok     &= mul_dir();
    156239# endif
    157240        return ok;
Note: See TracChangeset for help on using the changeset viewer.