Changeset 3732 for trunk/test_more


Ignore:
Timestamp:
Sep 24, 2015 11:04:11 PM (4 years ago)
Author:
bradbell
Message:

merge to branch: trunk
from repository: https://github.com/coin-or/CppAD
start hash code: 401c99935c98da4b2086f3777f7d4bee3ebebb22
end hash code: 37afaa0d224e420a8cd052c18ceadf1c684ffd34

commit 37afaa0d224e420a8cd052c18ceadf1c684ffd34
Author: Brad Bell <bradbell@…>
Date: Thu Sep 24 08:05:47 2015 -0700

  1. Make checking of duplicate warning specifications global (not local).
  2. Fix some MSC C++ warning C4459: hides global declaration. mul_zdouble.cpp: C4459 for the vairable n. optimize.cpp: C4459 for variables eps and conditional_skip. configure.hpp.in: fix doxygen documentation of warning supression.
Location:
trunk/test_more
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • trunk/test_more/mul_zdouble.cpp

    r3705 r3732  
    2424        //
    2525        zdouble eps    = 10. * std::numeric_limits<double>::epsilon();
    26         size_t  n      = 2;
    27         size_t  m      = 1;
     26        size_t  n_     = 2;
     27        size_t  m_     = 1;
    2828        //
    2929        void record(a2fun fun, ADFun<zdouble>& g)
    30         {       vector<zdouble>  x(n);
    31                 vector<a1type> a1x(n), a1w(m), a1z(m * n);
    32                 vector<a2type> a2x(n), a2y(m);
     30        {       vector<zdouble>  x(n_);
     31                vector<a1type> a1x(n_), a1w(m_), a1z(m_ * n_);
     32                vector<a2type> a2x(n_), a2y(m_);
    3333                //
    34                 for(size_t j = 0; j < n; j++)
     34                for(size_t j = 0; j < n_; j++)
    3535                {       x[j]   = 0.0;
    3636                        a1x[j] = a1type( x[j] );
     
    5353        // ----------------------------------------------------------------------
    5454        vector<a2type> div(const vector<a2type>& a2x)
    55         {       vector<a2type> a2y(1);
     55        {       vector<a2type> a2y(m_);
    5656                a2type a2zero = a2type(0.0);
    5757                a2type a2four = a2type(4.0);
     
    6565                ADFun<zdouble> g;
    6666                record(div, g);
    67                 vector<zdouble>  x(n), z(n);
     67                vector<zdouble>  x(n_), z(n_);
    6868                // check result where x[1] <= 0.0 (would be nan without absoute zero)
    6969                x[0] = 0.0;
     
    8484        // ----------------------------------------------------------------------
    8585        vector<a2type> mul(const vector<a2type>& a2x)
    86         {       vector<a2type> a2y(1);
     86        {       vector<a2type> a2y(m_);
    8787                a2type a2zero = a2type(0.0);
    8888                a2type a2four = a2type(4.0);
     
    9797                ADFun<zdouble> g;
    9898                record(mul, g);
    99                 vector<zdouble>  x(n), z(n);
     99                vector<zdouble>  x(n_), z(n_);
    100100                // check result where x[0] > 4 (would be nan without absoute zero)
    101101                ok &= std::numeric_limits<double>::has_infinity;
  • trunk/test_more/optimize.cpp

    r3724 r3732  
    1818namespace {
    1919        // include conditional skip optimization
    20         bool conditional_skip;
     20        bool conditional_skip_;
    2121
    2222        // accuracy for almost equal checks
    23         double eps = 10. * std::numeric_limits<double>::epsilon();
     23        double eps_ = 10. * std::numeric_limits<double>::epsilon();
    2424        using CppAD::NearEqual;
    2525
     
    5454
    5555                // now optimize the operation sequence
    56                 if( conditional_skip )
     56                if( conditional_skip_ )
    5757                        f.optimize();
    5858                else
     
    125125                // now optimize the operation sequence
    126126                j_check.option( atomic_sparsity_option );
    127                 if( conditional_skip )
     127                if( conditional_skip_ )
    128128                        f.optimize();
    129129                else
     
    197197
    198198                // now optimize the operation sequence
    199                 if( conditional_skip )
     199                if( conditional_skip_ )
    200200                        f.optimize();
    201201                else
     
    261261                // now optimize the operation sequence
    262262                g_check.option( atomic_sparsity_option );
    263                 if( conditional_skip )
     263                if( conditional_skip_ )
    264264                        f.optimize();
    265265                else
     
    308308                // now optimize f so that the calculation of au[1] is removed
    309309                g_check.option( atomic_sparsity_option );
    310                 if( conditional_skip )
     310                if( conditional_skip_ )
    311311                        f.optimize();
    312312                else
     
    334334        {       typedef typename Vector::value_type Scalar;
    335335                Scalar not_used;
    336                 Scalar one(1), two(2), three(3), four(4);
     336                Scalar one(1), two(2), three(3);
    337337
    338338                // independent variable and phantom at beginning
     
    418418                depend_fun(x, check, original, opt);
    419419                for(i = 0; i < m; i++)
    420                         ok &= NearEqual(y[i], check[i], eps, eps);
     420                        ok &= NearEqual(y[i], check[i], eps_, eps_);
    421421
    422422                // Check size before optimization
     
    424424
    425425                // Optimize the operation sequence
    426                 if( conditional_skip )
     426                if( conditional_skip_ )
    427427                        F.optimize();
    428428                else
     
    436436                y = F.Forward(0, x);
    437437                for(i = 0; i < m; i++)
    438                         ok &= NearEqual(y[i], check[i], eps, eps);
     438                        ok &= NearEqual(y[i], check[i], eps_, eps_);
    439439
    440440                return ok;
     
    502502                }
    503503
    504                 if( conditional_skip )
     504                if( conditional_skip_ )
    505505                        F.optimize();
    506506                else
     
    540540
    541541                CppAD::ADFun<double> F(X, Y);
    542                 if( conditional_skip )
     542                if( conditional_skip_ )
    543543                        F.optimize();
    544544                else
     
    560560
    561561                double check = x[1] * pow( x[0], x[1] - 1. );
    562                 ok &= NearEqual( dw[0], check, eps, eps );
     562                ok &= NearEqual( dw[0], check, eps_, eps_ );
    563563
    564564                check = log( x[0] ) * pow( x[0], x[1] );
    565                 ok &= NearEqual( dw[1], check, eps, eps );
     565                ok &= NearEqual( dw[1], check, eps_, eps_ );
    566566
    567567                check = 0.;
    568                 ok &= NearEqual( dw[2], check, eps, eps );
     568                ok &= NearEqual( dw[2], check, eps_, eps_ );
    569569
    570570                return ok;
     
    591591                vector<double> y_original     = F.Forward(0, x);
    592592                size_t         size_original  = F.size_var();
    593                 if( conditional_skip )
     593                if( conditional_skip_ )
    594594                        F.optimize();
    595595                else
     
    597597                ok &= F.size_var() + 5 == size_original;
    598598                vector<double> y = F.Forward(0, x);
    599                 ok &=  NearEqual(y[0], y_original[0], eps, eps);
     599                ok &=  NearEqual(y[0], y_original[0], eps_, eps_);
    600600# endif
    601601                return ok;
     
    706706                duplicate_fun(x, check, original, opt);
    707707                for(i = 0; i < m; i++)
    708                         ok &= NearEqual(y[i], check[i], eps, eps);
     708                        ok &= NearEqual(y[i], check[i], eps_, eps_);
    709709
    710710                // Check size before optimization
     
    712712
    713713                // Optimize the operation sequence
    714                 if( conditional_skip )
     714                if( conditional_skip_ )
    715715                        F.optimize();
    716716                else
     
    724724                y = F.Forward(0, x);
    725725                for(i = 0; i < m; i++)
    726                         ok &= NearEqual(y[i], check[i], eps, eps);
     726                        ok &= NearEqual(y[i], check[i], eps_, eps_);
    727727
    728728                return ok;
     
    781781                        ok &= ( y[i] == Value( Y[i] ) );
    782782
    783                 if( conditional_skip )
     783                if( conditional_skip_ )
    784784                        F.optimize();
    785785                else
     
    848848                        ok &= ( y[i] == Value( Y[i] ) );
    849849
    850                 if( conditional_skip )
     850                if( conditional_skip_ )
    851851                        F.optimize();
    852852                else
     
    904904                ok &= ( y[0] == Value( Y[0] ) );
    905905
    906                 if( conditional_skip )
     906                if( conditional_skip_ )
    907907                        F.optimize();
    908908                else
     
    970970                        ok &= ( y[i] == Value( Y[i] ) );
    971971
    972                 if( conditional_skip )
     972                if( conditional_skip_ )
    973973                        F.optimize();
    974974                else
     
    10041004
    10051005                // now optimize the operation sequence
    1006                 if( conditional_skip )
     1006                if( conditional_skip_ )
    10071007                        F.optimize();
    10081008                else
     
    10151015                x0[1]    = 4.;
    10161016                y0       = F.Forward(0, x0);
    1017                 ok      &= NearEqual(y0[0] , x0[0]+x0[0]+x0[1], eps, eps);
     1017                ok      &= NearEqual(y0[0] , x0[0]+x0[0]+x0[1], eps_, eps_);
    10181018
    10191019                // evaluate derivative of F in X[0] direction
     
    10231023                x1[1]    = 0.;
    10241024                y1       = F.Forward(1, x1);
    1025                 ok      &= NearEqual(y1[0] , x1[0]+x1[0]+x1[1], eps, eps);
     1025                ok      &= NearEqual(y1[0] , x1[0]+x1[0]+x1[1], eps_, eps_);
    10261026
    10271027                // evaluate second derivative of F in X[0] direction
     
    10321032                y2          = F.Forward(2, x2);
    10331033                double F_00 = 2. * y2[0];
    1034                 ok         &= NearEqual(F_00, 0., eps, eps);
     1034                ok         &= NearEqual(F_00, 0., eps_, eps_);
    10351035
    10361036                return ok;
     
    10561056
    10571057                // now optimize the operation sequence
    1058                 if( conditional_skip )
     1058                if( conditional_skip_ )
    10591059                        F.optimize();
    10601060                else
     
    10671067                x0[1]    = 4.;
    10681068                y0       = F.Forward(0, x0);
    1069                 ok      &= NearEqual(y0[0] , x0[0]-x0[0]+x0[1], eps, eps);
     1069                ok      &= NearEqual(y0[0] , x0[0]-x0[0]+x0[1], eps_, eps_);
    10701070
    10711071                // evaluate derivative of F
     
    10741074                w[0]    = 1.;
    10751075                dF      = F.Reverse(1, w);
    1076                 ok     &= NearEqual(dF[0] , 0., eps, eps);
    1077                 ok     &= NearEqual(dF[1] , 1., eps, eps);
     1076                ok     &= NearEqual(dF[0] , 0., eps_, eps_);
     1077                ok     &= NearEqual(dF[1] , 1., eps_, eps_);
    10781078
    10791079                return ok;
     
    11351135                // create function object F : X -> Y
    11361136                ADFun<double> F(X, Y);
    1137                 if( conditional_skip )
     1137                if( conditional_skip_ )
    11381138                        F.optimize();
    11391139                else
     
    12161216                // create function object F : X -> Y
    12171217                ADFun<double> F(X, Y);
    1218                 if( conditional_skip )
     1218                if( conditional_skip_ )
    12191219                        F.optimize();
    12201220                else
     
    12761276                // create function object F : X -> Y
    12771277                CppAD::ADFun<double> F(X, Y);
    1278                 if( conditional_skip )
     1278                if( conditional_skip_ )
    12791279                        F.optimize();
    12801280                else
     
    13251325
    13261326                CppAD::ADFun<double> f(X, Y);
    1327                 if( conditional_skip )
     1327                if( conditional_skip_ )
    13281328                        f.optimize();
    13291329                else
     
    13671367
    13681368                CppAD::ADFun<double> f(X, Y);
    1369                 if( conditional_skip )
     1369                if( conditional_skip_ )
    13701370                        f.optimize();
    13711371                else
     
    13751375                x[0] = 1.0;
    13761376                y    = f.Forward(0, x);
    1377                 ok &= NearEqual(y[0], false_case, eps, eps);
     1377                ok &= NearEqual(y[0], false_case, eps_, eps_);
    13781378
    13791379                w[0] = 1.0;
    13801380                dw   = f.Reverse(1, w);
    13811381                // derivative of cos is minus sin
    1382                 ok &= NearEqual(dw[0], - true_case, eps, eps);
     1382                ok &= NearEqual(dw[0], - true_case, eps_, eps_);
    13831383
    13841384                return ok;
     
    15521552                // Used to fail assert in optimize that forward mode results
    15531553                // are identically equal
    1554                 if( conditional_skip )
     1554                if( conditional_skip_ )
    15551555                        f.optimize();
    15561556                else
     
    15741574
    15751575                size_t size_before = f.size_var();
    1576                 if( conditional_skip )
     1576                if( conditional_skip_ )
    15771577                        f.optimize();
    15781578                else
     
    16281628                x[1]      = 2.0;
    16291629                y_before  = f.Forward(0, x);
    1630                 if( conditional_skip )
     1630                if( conditional_skip_ )
    16311631                        f.optimize();
    16321632                else
     
    16721672                dx[1]     = 2.0;
    16731673                dy_before = f.Forward(1, dx);
    1674                 if( conditional_skip )
     1674                if( conditional_skip_ )
    16751675                        f.optimize();
    16761676                else
     
    17061706                CppAD::ADFun<double> f(ax, ay);
    17071707
    1708                 if( conditional_skip )
     1708                if( conditional_skip_ )
    17091709                        f.optimize();
    17101710                else
     
    17471747                ay[2]  = CppAD::CondExpGe(ax[0], three, exp(ax[0]), exp(ax[0]) );
    17481748                CppAD::ADFun<double> f(ax, ay);
    1749                 if( conditional_skip )
     1749                if( conditional_skip_ )
    17501750                        f.optimize();
    17511751                else
     
    17761776{       bool ok = true;
    17771777        atomic_sparsity_option = CppAD::atomic_base<double>::bool_sparsity_enum;
    1778         conditional_skip       = true;
     1778        conditional_skip_      = true;
    17791779
    17801780        // atomic sparsity loop
     
    18331833                ok     &=  cond_exp_both_true_and_false();
    18341834                //
    1835                 conditional_skip = false;
     1835                conditional_skip_ = false;
    18361836        }
    18371837        //
Note: See TracChangeset for help on using the changeset viewer.