Changeset 2031 for trunk/test_more


Ignore:
Timestamp:
Jul 27, 2011 10:37:25 AM (9 years ago)
Author:
bradbell
Message:

Implement the tanh function as an atomic operation.

Location:
trunk/test_more
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • trunk/test_more/mul_level.cpp

    r1697 r2031  
    11/* $Id$ */
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-10 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-11 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    154154# ifdef CPPAD_ADOLC_TEST
    155155
    156 bool Three(void)
     156bool adolc(void)
    157157{       bool ok = true;                   // initialize test result
    158158
     
    221221# endif // CPPAD_ADOLC_TEST
    222222
     223bool std_math(void)
     224{       bool ok = true;
     225        using CppAD::AD;
     226        using CppAD::Independent;
     227        using CppAD::ADFun;
     228        double eps = std::numeric_limits<double>::epsilon();
     229
     230
     231        typedef AD<double>      ADdouble; // for first level of taping
     232        typedef AD<ADdouble>   ADDdouble; // for second level of taping
     233        size_t n = 1;         // number independent variables
     234        size_t m = 1;         // number dependent and independent variables
     235
     236        CPPAD_TEST_VECTOR<double>       x(n),   y(m);
     237        CPPAD_TEST_VECTOR<ADdouble>    ax(n),  ay(m);
     238        CPPAD_TEST_VECTOR<ADDdouble>  aax(n), aay(m);
     239
     240        // create af(x) = tanh(x)
     241        aax[0] = 1.;
     242        Independent( aax );
     243        aay[0] = tanh(aax[0]);
     244        ADFun<ADdouble> af(aax, aay);
     245
     246        // create g(x) = af(x)
     247        ax[0] = 1.;
     248        Independent( ax );
     249        ay = af.Forward(0, ax);
     250        ADFun<double> g(ax, ay);
     251
     252        // evaluate h(x) = g(x)
     253        x[0] = 1.;
     254        y = g.Forward(0, x);
     255
     256        // check result
     257        double check  = tanh(x[0]);
     258        ok &= CppAD::NearEqual(y[0], check, eps, eps);
     259
     260        return ok;
     261}
     262
    223263} // END empty namespace
    224264
     
    228268        ok     &= Two();
    229269# ifdef CPPAD_ADOLC_TEST
    230         ok     &= Three();
     270        ok     &= adolc();
    231271# endif
    232         return ok;
    233 }
     272        ok     &= std_math();
     273
     274        return ok;
     275}
  • trunk/test_more/tan.cpp

    r2028 r2031  
    2121        bool tan_case(bool tan_first)
    2222        {       bool ok = true;
    23                 double eps = 10. * std::numeric_limits<double>::epsilon();
     23                double eps = 100. * std::numeric_limits<double>::epsilon();
    2424                using CppAD::AD;
    2525                using CppAD::NearEqual;
     
    6666                return ok;
    6767        }
     68        bool tanh_case(bool tanh_first)
     69        {       bool ok = true;
     70                double eps = 100. * std::numeric_limits<double>::epsilon();
     71                using CppAD::AD;
     72                using CppAD::NearEqual;
     73       
     74                // independent variable vector, indices, values, and declaration
     75                size_t n = 1;
     76                CPPAD_TEST_VECTOR< AD<double> > ax(n);
     77                ax[0]     = .5;
     78                Independent(ax);
     79       
     80                // dependent variable vector and indices
     81                size_t m = 1;
     82                CPPAD_TEST_VECTOR< AD<double> > ay(m);
     83                AD<double> z;
     84                if( tanh_first )
     85                {       z     = tanh( ax[0] );
     86                        ay[0] = .5 * log( (1. + z) / (1. - z) );
     87                }
     88                else
     89                {       z     = .5 * log( (1. + ax[0]) / (1. - ax[0]) );
     90                        ay[0] = tanh(z);
     91                }
     92                // check value
     93                ok &= NearEqual(ax[0] , ay[0],  eps, eps);
     94       
     95                // create f: x -> y and vectors used for derivative calculations
     96                CppAD::ADFun<double> f(ax, ay);
     97                CPPAD_TEST_VECTOR<double> dx(n), dy(m);
     98       
     99                // forward computation of partials w.r.t. x
     100                dx[0] = 1.;
     101                dy    = f.Forward(1, dx);
     102                ok   &= NearEqual(dy[0], 1e0, eps, eps);
     103                size_t p, order = 5;
     104                dx[0] = 0.;
     105                for(p = 2; p < order; p++)
     106                {       dy    = f.Forward(p, dx);
     107                        ok   &= NearEqual(dy[0], 0e0, eps, eps);
     108                }
     109       
     110                // reverse computation of order partial
     111                CPPAD_TEST_VECTOR<double>  w(m), dw(n * order);
     112                w[0] = 1.;
     113                dw   = f.Reverse(order, w);
     114                ok   &= NearEqual(dw[0], 1e0, eps, eps);
     115                for(p = 1; p < order; p++)
     116                        ok   &= NearEqual(dw[p], 0e0, eps, eps);
     117       
     118                return ok;
     119        }
    68120}
    69121bool tan(void)
     
    71123        ok     &= tan_case(true);
    72124        ok     &= tan_case(false);
     125        ok     &= tanh_case(true);
     126        ok     &= tanh_case(false);
    73127        return ok;
    74128}
Note: See TracChangeset for help on using the changeset viewer.