Changeset 3646 for trunk/test_more


Ignore:
Timestamp:
Feb 14, 2015 12:40:20 PM (5 years ago)
Author:
bradbell
Message:

merge to branch: trunk
from repository: https://github.com/coin-or/CppAD
start hash code: ee39862aa18207f6085df3cfacf8353d7a0682c3
end hash code: 3f5fa151b81804904c22324641fd65caed4c9e9c

commit 3f5fa151b81804904c22324641fd65caed4c9e9c
Author: Brad Bell <bradbell@…>
Date: Sat Feb 14 10:34:57 2015 -0700

Remove trailing white space.

commit dbf45da3c1710959c925d8b3b9b5fdbf719edaf7
Author: Brad Bell <bradbell@…>
Date: Sat Feb 14 10:34:04 2015 -0700

Fix bug in C++11 version of error function derivatives.


erf_op.hpp: The bug was missing parenthesis here.
mul_op.hpp: Fix operator name used in assert.
erf.cpp: add a version of bug/erf.sh to this test.
test_more.cpp: Change name from Erf to erf.

commit 6565ef9ad2a4e176b88ca3e37d12c29a4ce56ca2
Author: Brad Bell <bradbell@…>
Date: Sat Feb 14 06:48:39 2015 -0700

erf.sh: add an independent check of the correct hessian value.

commit 211cea5706adbefe766ab2feb5b17b84a083ec58
Author: Brad Bell <bradbell@…>
Date: Sat Feb 14 06:28:21 2015 -0700

erf.sh: Minor simplifactions.

commit 558b4f677a7f4a862525be7b52ff8465196f4f46
Author: Brad Bell <bradbell@…>
Date: Sat Feb 14 06:14:05 2015 -0700

Branch: master
erf.sh: Add description and automatic error detection.

commit bf88559df87654cfffa78dd9175d28cf92e50de4
Author: Brad Bell <bradbell@…>
Date: Sat Feb 14 06:07:36 2015 -0700

erf.sh: new errof function bug report.

commit c0cc7b4ebc228c421859fd8c2ccc173ddbdf24c8
Author: Brad Bell <bradbell@…>
Date: Fri Feb 13 19:47:40 2015 -0700

atomic.sh: fix bug in example (not a bug in CppAD).

commit effcba68e21c62413d736ed485ab66a9e050a62d
Author: Brad Bell <bradbell@…>
Date: Fri Feb 13 06:01:48 2015 -0700

atomic.sh: add checkpoint version of computation.

commit b750243ac1652443dfbeed382dfa9464aab184fe
Author: Brad Bell <bradbell@…>
Date: Fri Feb 13 04:42:25 2015 -0700

atomic.sh: remove all use of eigen from bug report.

commit 2da71b69713543135cd126a45582acf1a0810308
Author: Brad Bell <bradbell@…>
Date: Fri Feb 13 04:37:59 2015 -0700

atomic.sh: Convert VectorXd? and VectorXA to use CppAD::vector.

commit a8df465a0dd30112167dbb836d1103d1ee8bb4e4
Author: Brad Bell <bradbell@…>
Date: Thu Feb 12 18:26:31 2015 -0700

atomic.sh: convert hess from matrix to vector.

commit 3d9f194dc898e2fd9e8099b811569bd157b10505
Author: Brad Bell <bradbell@…>
Date: Thu Feb 12 18:14:15 2015 -0700

atomic.sh: remove trailing white space.

commit 2b3cd275b1cbf1e300d13b26020f42d2701fb101
Author: Brad Bell <bradbell@…>
Date: Thu Feb 12 18:12:42 2015 -0700

atomic.sh: convert some more matrices to vectors.

commit c1749be19c50e257dca55496230bf3cca7ba641e
Author: Brad Bell <bradbell@…>
Date: Thu Feb 12 17:51:09 2015 -0700

atomic.sh: convert dy from matrix to vector.

commit d95335506b22245ecc1d9781e04bf03299245a55
Author: Brad Bell <bradbell@…>
Date: Thu Feb 12 06:51:38 2015 -0700

atomic.sh: initilaize y[2], remove use of eigen dot product.

commit 8f6a83d96784149124b415b7c260d79cfeb96a09
Author: Brad Bell <bradbell@…>
Date: Thu Feb 12 06:32:12 2015 -0700

atomic.sh: remove use of the matrix x.

Location:
trunk/test_more
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • trunk/test_more/erf.cpp

    r3501 r3646  
    11/* $Id$ */
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 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
     
    1111-------------------------------------------------------------------------- */
    1212
    13 /*
    14 Old example now just used for validation testing
    15 */
    16 
    1713# include <cppad/cppad.hpp>
    1814
    19 bool Erf(void)
     15namespace {
     16        bool old_example(void)
     17        {       bool ok = true;
     18                using namespace CppAD;
     19                using CppAD::atan;
     20                using CppAD::exp;
     21                using CppAD::sqrt;
     22        # if CPPAD_COMPILER_HAS_ERF
     23                double eps = 100.0 * std::numeric_limits<double>::epsilon();
     24        # endif
     25                // Construct function object corresponding to erf
     26                CPPAD_TESTVECTOR(AD<double>) ax(1);
     27                CPPAD_TESTVECTOR(AD<double>) ay(1);
     28                ax[0] = 0.;
     29                Independent(ax);
     30                ay[0] = erf(ax[0]);
     31                ADFun<double> f(ax, ay);
     32
     33                // Construct function object corresponding to derivative of erf
     34                Independent(ax);
     35                double pi = 4.0 * atan(1.0);
     36                ay[0] = exp( - ax[0] * ax[0] ) * 2.0 / sqrt(pi);
     37                ADFun<double> df(ax, ay);
     38
     39                // vectors to use with function object
     40                CPPAD_TESTVECTOR(double) x0(1), y0(1), x1(1), y1(1), check(1);
     41
     42                // check value at zero
     43                x0[0]    = 1.5;
     44                y0       = f.Forward(0, x0);
     45                check[0] = 0.96611;
     46                ok      &= std::fabs(check[0] - y0[0]) <= 4e-4;
     47
     48                // check the derivative of error function
     49                x1[0] = 1.0;
     50                y1    = f.Forward(1, x1);
     51                check = df.Forward(0, x0);
     52                ok   &= NearEqual(check[0], y1[0], 0., 2e-3);
     53        # if CPPAD_COMPILER_HAS_ERF
     54                ok   &= NearEqual(check[0], y1[0], eps, eps);
     55        # endif
     56
     57                // check second derivative
     58                CPPAD_TESTVECTOR(double) x2(1), y2(1);
     59                x2[0] = 0.0;
     60                y2    = f.Forward(2, x2);
     61                check = df.Forward(1, x1);
     62                ok   &= NearEqual(check[0] / 2.0, y2[0], 0., 2e-3);
     63        # if CPPAD_COMPILER_HAS_ERF
     64                ok   &= NearEqual(check[0] / 2.0, y2[0], eps, eps);
     65        # endif
     66
     67                // check third derivative
     68                CPPAD_TESTVECTOR(double) x3(1), y3(1);
     69                x3[0] = 0.0;
     70                y3    = f.Forward(3, x3);
     71                check = df.Forward(2, x2);
     72                ok   &= NearEqual(check[0] / 3.0, y3[0], 0., 2e-3);
     73        # if CPPAD_COMPILER_HAS_ERF
     74                ok   &= NearEqual(check[0] / 3.0, y3[0], eps, eps);
     75        # endif
     76
     77                // check 4-th order of reverse mode
     78                CPPAD_TESTVECTOR(double) w(1), dy(4), x4(1), y4(1);
     79                x4[0] = 0.0;
     80                w[0]  = 1.0;
     81                dy    = f.Reverse(4, w);
     82                y4    = f.Forward(4, x4);
     83                //
     84                ok  &= NearEqual(dy[0], y1[0], 0., 2e-3);
     85        # if CPPAD_COMPILER_HAS_ERF
     86                ok  &= NearEqual(dy[0], y1[0], eps, eps);
     87        # endif
     88                //
     89                ok  &= NearEqual(dy[1], 2.0 * y2[0], 0., 2e-3);
     90        # if CPPAD_COMPILER_HAS_ERF
     91                ok  &= NearEqual(dy[1], 2.0 * y2[0], eps, eps);
     92        # endif
     93                //
     94                ok  &= NearEqual(dy[2], 3.0 * y3[0], 0., 2e-3);
     95        # if CPPAD_COMPILER_HAS_ERF
     96                ok  &= NearEqual(dy[2], 3.0 * y3[0], eps, eps);
     97        # endif
     98                //
     99                ok  &= NearEqual(dy[3], 4.0 * y4[0], 0., 2e-3);
     100        # if CPPAD_COMPILER_HAS_ERF
     101                ok  &= NearEqual(dy[3], 4.0 * y4[0], eps, eps);
     102        # endif
     103
     104                return ok;
     105        }
     106        bool hessian(void)
     107        {       bool ok = true;
     108                double eps = 1.0 * std::numeric_limits<double>::epsilon();
     109                using CppAD::vector;
     110                using CppAD::AD;
     111
     112                size_t n = 2;
     113                size_t m = 1;
     114                vector<double> x(n), w(m);
     115                w[0] = 1.0;
     116                vector< AD<double> > ax(n), ay(m);
     117                ax[0] = x[0] = 0.5;
     118                ax[1] = x[1] = 0.0;
     119
     120                // construct function
     121                CppAD::Independent(ax);
     122                ay[0] = erf( 2.0 * ax[0] );
     123                CppAD::ADFun<double> f(ax, ay);
     124
     125                // dense hessian
     126                vector<double> dense_hess = f.Hessian(x, 0);
     127
     128                // sparse_hessian
     129                vector<double> sparse_hess = f.SparseHessian(x, w);
     130
     131                // Define g(u) = erf(2 * u)
     132                // g'(u)   = 2 * erf'(2 * u)
     133                //         = 2 * exp( - 2 * u * 2 * u ) * 2 / sqrt(pi)
     134                //         = exp( - 4 * u * u ) * 4 / sqrt(pi)
     135                // g''(u)  = - exp( - 4 * u * u ) * 32 * u / sqrt(pi)
     136                double root_pi = std::sqrt( 4.0 * atan(1.0) );
     137                double check   = -std::exp(-4.0 * x[0] * x[0]) * 32.0 * x[0] / root_pi;
     138
     139                ok &= CppAD::NearEqual(dense_hess[0], check, eps, eps);
     140                ok &= CppAD::NearEqual(sparse_hess[0], check, eps, eps);
     141
     142                for(size_t k = 1; k < n * n; k++)
     143                {       ok &= CppAD::NearEqual(dense_hess[k], 0.0, eps, eps);
     144                        ok &= CppAD::NearEqual(sparse_hess[k], 0.0, eps, eps);
     145                }
     146                return ok;
     147        }
     148}
     149bool erf(void)
    20150{       bool ok = true;
    21         using namespace CppAD;
    22         using CppAD::atan;
    23         using CppAD::exp;
    24         using CppAD::sqrt;
     151        ok     &= old_example();
    25152# if CPPAD_COMPILER_HAS_ERF
    26         double eps = 100.0 * std::numeric_limits<double>::epsilon();
     153        ok     &= hessian();
    27154# endif
    28         // Construct function object corresponding to erf
    29         CPPAD_TESTVECTOR(AD<double>) ax(1);
    30         CPPAD_TESTVECTOR(AD<double>) ay(1);
    31         ax[0] = 0.;
    32         Independent(ax);
    33         ay[0] = erf(ax[0]);
    34         ADFun<double> f(ax, ay);
    35 
    36         // Construct function object corresponding to derivative of erf
    37         Independent(ax);
    38         double pi = 4.0 * atan(1.0);
    39         ay[0] = exp( - ax[0] * ax[0] ) * 2.0 / sqrt(pi);
    40         ADFun<double> df(ax, ay);
    41 
    42         // vectors to use with function object
    43         CPPAD_TESTVECTOR(double) x0(1), y0(1), x1(1), y1(1), check(1);
    44 
    45         // check value at zero
    46         x0[0]    = 1.5;
    47         y0       = f.Forward(0, x0);   
    48         check[0] = 0.96611;
    49         ok      &= std::fabs(check[0] - y0[0]) <= 4e-4;
    50 
    51         // check the derivative of error function
    52         x1[0] = 1.0;
    53         y1    = f.Forward(1, x1);
    54         check = df.Forward(0, x0);
    55         ok   &= NearEqual(check[0], y1[0], 0., 2e-3);
    56 # if CPPAD_COMPILER_HAS_ERF
    57         ok   &= NearEqual(check[0], y1[0], eps, eps);
    58 # endif
    59 
    60         // check second derivative
    61         CPPAD_TESTVECTOR(double) x2(1), y2(1);
    62         x2[0] = 0.0;
    63         y2    = f.Forward(2, x2);
    64         check = df.Forward(1, x1);
    65         ok   &= NearEqual(check[0] / 2.0, y2[0], 0., 2e-3);
    66 # if CPPAD_COMPILER_HAS_ERF
    67         ok   &= NearEqual(check[0] / 2.0, y2[0], eps, eps);
    68 # endif
    69 
    70         // check third derivative
    71         CPPAD_TESTVECTOR(double) x3(1), y3(1);
    72         x3[0] = 0.0;
    73         y3    = f.Forward(3, x3);
    74         check = df.Forward(2, x2);
    75         ok   &= NearEqual(check[0] / 3.0, y3[0], 0., 2e-3);
    76 # if CPPAD_COMPILER_HAS_ERF
    77         ok   &= NearEqual(check[0] / 3.0, y3[0], eps, eps);
    78 # endif
    79 
    80         // check 4-th order of reverse mode
    81         CPPAD_TESTVECTOR(double) w(1), dy(4), x4(1), y4(1);
    82         x4[0] = 0.0;
    83         w[0]  = 1.0;
    84         dy    = f.Reverse(4, w);
    85         y4    = f.Forward(4, x4);
    86         //
    87         ok  &= NearEqual(dy[0], y1[0], 0., 2e-3);
    88 # if CPPAD_COMPILER_HAS_ERF
    89         ok  &= NearEqual(dy[0], y1[0], eps, eps);
    90 # endif
    91         //
    92         ok  &= NearEqual(dy[1], 2.0 * y2[0], 0., 2e-3);
    93 # if CPPAD_COMPILER_HAS_ERF
    94         ok  &= NearEqual(dy[1], 2.0 * y2[0], eps, eps);
    95 # endif
    96         //
    97         ok  &= NearEqual(dy[2], 3.0 * y3[0], 0., 2e-3);
    98 # if CPPAD_COMPILER_HAS_ERF
    99         ok  &= NearEqual(dy[2], 3.0 * y3[0], eps, eps);
    100 # endif
    101         //
    102         ok  &= NearEqual(dy[3], 4.0 * y4[0], 0., 2e-3);
    103 # if CPPAD_COMPILER_HAS_ERF
    104         ok  &= NearEqual(dy[3], 4.0 * y4[0], eps, eps);
    105 # endif
    106 
    107155        return ok;
    108156}
  • trunk/test_more/test_more.cpp

    r3607 r3646  
    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
     
    4545extern bool DivEq(void);
    4646extern bool DivZeroOne(void);
    47 extern bool Erf(void);
     47extern bool erf(void);
    4848extern bool Exp(void);
    4949extern bool ForHess(void);
     
    105105        bool Run(bool TestOk(void), std::string name)
    106106        {       bool ok               = true;
    107                 std::streamsize width =  20;         
     107                std::streamsize width =  20;
    108108                std::cout.width( width );
    109109                std::cout.setf( std::ios_base::left );
     
    129129        using namespace std;
    130130
    131         // This line is used by test_one.sh 
     131        // This line is used by test_one.sh
    132132
    133133        // run external compiled tests (this line expected by bin/new_test.sh)
     
    155155        ok &= Run( DivEq,           "DivEq"          );
    156156        ok &= Run( DivZeroOne,      "DivZeroOne"     );
    157         ok &= Run( Erf,             "Erf"            );
     157        ok &= Run( erf,             "erf"            );
    158158        ok &= Run( Exp,             "Exp"            );
    159159        ok &= Run( ForHess,         "ForHess"        );
Note: See TracChangeset for help on using the changeset viewer.