Changeset 3731


Ignore:
Timestamp:
Sep 24, 2015 8:19:58 AM (4 years ago)
Author:
bradbell
Message:

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

commit 401c99935c98da4b2086f3777f7d4bee3ebebb22
Author: Brad Bell <bradbell@…>
Date: Thu Sep 24 05:17:49 2015 -0700

Remove invisible white space.

commit 5787b4a1fe4dafab9c2c0a33572a9c5d84f325f3
Author: Brad Bell <bradbell@…>
Date: Thu Sep 24 05:17:33 2015 -0700

  1. Remove warnings level from CMAKE_CXX_FLAGS when it appers in cppad_cxx_flags.
  2. disable Visual Studio warning numbers 4100 and 4127.
  3. Fix some (MS VC++ mistaken warnings about combining ints with bools).

commit ea51118a94f13f8ddf9552ff7a81c8a2daf42f7b
Author: Brad Bell <bradbell@…>
Date: Wed Sep 23 10:13:18 2015 -0700

whats_new_15.omh: user's view of recent changes.

Location:
trunk
Files:
1 added
7 edited

Legend:

Unmodified
Added
Removed
  • trunk/CMakeLists.txt

    r3725 r3731  
    6868# check_source_runs(source variable)
    6969INCLUDE(cmake/check_source_runs.cmake)
     70#
     71# modify CMAKE_CXX_FLAGS according to value of cppad_cxx_flags
     72INCLUDE(cmake/modify_cmake_cxx_flags.cmake)
    7073# =============================================================================
    7174# command line arguments
  • trunk/cppad/configure.hpp.in

    r3724 r3731  
    2020$$
    2121
    22 $section Preprocessor Definitions Used by CppAD$$
    23 $index configure, symbol$$
    24 $index symbol, configure$$
     22$section Configuration Preprocessor Symbols Used by CppAD$$
    2523
    2624$head Preprocessor Symbols$$
    27 $index preprocessor, symbol$$
    28 $index symbol, processor$$
    2925All of the preprocessor symbols used by CppAD begin with
    3026$code CPPAD_$$
     
    4036
    4137/*!
     38\defgroup Disable Some Microsoft Compiler Warnings
     39
     40\li 4100
     41unreferenced formal parameter.
     42\li 4127
     43conditional expression is constant.
     44\{
     45*/
     46# if _MSC_VER
     47# pragma warning( disable : 4100 )
     48# pragma warning( disable : 4127 )
     49# endif
     50/*! \}
     51
    4252\def CPPAD_USE_CPLUSPLUS_2011
    4353Should CppAD use C++11 features. This will be true if the current
  • trunk/example/CMakeLists.txt

    r3718 r3731  
    1616# empty, Debug, Release, RelWithDebInfo and MinSizeRel
    1717SET(CMAKE_BUILD_TYPE DEBUG)
     18
     19# modify CMAKE_CXX_FLAGS corresponding to this build type
     20modify_cmake_cxx_flags("example")
    1821
    1922# initialize check_depends
  • trunk/example/atomic/norm_sq.cpp

    r3717 r3731  
    162162                {       s[j] = false;
    163163                        for(size_t i = 0; i < n; i++)
    164                                 s[j] |= r[i * p + j];
     164                        {       // Visual Studio 2013 generates warning without bool below
     165                                s[j] |= bool( r[i * p + j] );
     166                        }
    165167                }
    166168                return true;
     
    232234                {       for(j = 0; j < p; j++)
    233235                                for(size_t i = 0; i < n; i++)
    234                                         v[ i * p + j] |= r[ i * p + j];
     236                                {       // Visual Studio 2013 generates warning without bool below
     237                                        v[ i * p + j] |= bool( r[ i * p + j] );
     238                                }
    235239                }
    236240
  • trunk/example/atomic/old_usead_2.cpp

    r3214 r3731  
    11// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 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
     
    2626
    2727$head Deprecated$$
    28 This example has been deprecated because it is easier to use the 
     28This example has been deprecated because it is easier to use the
    2929$cref checkpoint$$ class instead.
    3030
    3131$head Purpose$$
    32 Consider the case where an inner function is used repeatedly in the 
     32Consider the case where an inner function is used repeatedly in the
    3333definition of an outer function.
    3434In this case, it may reduce the number of variables
     
    4545# include <cppad/cppad.hpp>
    4646
    47 namespace { // Begin empty namespace 
     47namespace { // Begin empty namespace
    4848        using CppAD::AD;
    4949        using CppAD::ADFun;
     
    5555        public:
    5656                void Ode(
    57                         const AD<double>           &t, 
    58                         const vector< AD<double> > &z, 
     57                        const AD<double>           &t,
     58                        const vector< AD<double> > &z,
    5959                        vector< AD<double> >       &f)
    6060                {       assert( z.size() == 2 );
     
    7272                vector< AD<double> > x(n), zi(m), y(m), e(m);
    7373                // The value of x does not matter because the operation sequence
    74                 // does not depend on x. 
     74                // does not depend on x.
    7575                x[0]  = 0.0;  // initial value z_0 (t) at t = ti
    7676                x[1]  = 0.0;  // initial value z_1 (t) at t = ti
     
    8787        }
    8888        void destroy_r(void)
    89         {       delete r_ptr_; 
     89        {       delete r_ptr_;
    9090                r_ptr_ = CPPAD_NULL;
    9191        }
     
    107107                assert( m == 2 );
    108108                assert( k == 0 || vx.size() == 0 );
    109                 bool ok = true; 
     109                bool ok = true;
    110110                vector<double> xp(n), yp(m);
    111111                size_t i, j;
     
    126126                                        assert( j < n );
    127127                                        // y[i] depends on the value of x[j]
    128                                         vy[i] |= vx[j];
     128                                        // Visual Studio 2013 generates warning without bool below
     129                                        vy[i] |= bool( vx[j] );
    129130                                }
    130131                        }
     
    167168                assert( n == 3 );
    168169                assert( m == 2 );
    169                 bool ok = true; 
     170                bool ok = true;
    170171                vector<double> xp(n), w( (k+1) * m ), dw( (k+1) * n );
    171172
    172                 // make sure r_ has proper forward mode coefficients 
     173                // make sure r_ has proper forward mode coefficients
    173174                size_t i, j, q;
    174175                for(q = 0; q <= k; q++)
     
    202203        // forward Jacobian sparsity routine called by CppAD
    203204        bool solve_ode_for_jac_sparse(
    204                 size_t                               id ,             
     205                size_t                               id ,
    205206                size_t                                n ,
    206207                size_t                                m ,
     
    223224                // (have to reconstruct them every time)
    224225                r_ptr_->size_forward_set(0);
    225                
    226                 return ok; 
     226
     227                return ok;
    227228        }
    228229        // ----------------------------------------------------------------------
    229230        // reverse Jacobian sparsity routine called by CppAD
    230231        bool solve_ode_rev_jac_sparse(
    231                 size_t                               id ,             
     232                size_t                               id ,
    232233                size_t                                n ,
    233234                size_t                                m ,
     
    257258                                r[*itr].insert(i);
    258259                }
    259                 return ok; 
     260                return ok;
    260261        }
    261262        // ----------------------------------------------------------------------
    262263        // reverse Hessian sparsity routine called by CppAD
    263264        bool solve_ode_rev_hes_sparse(
    264                 size_t                               id ,             
     265                size_t                               id ,
    265266                size_t                                n ,
    266267                size_t                                m ,
     
    321322        // Declare the AD<double> routine solve_ode(id, ax, ay)
    322323        CPPAD_USER_ATOMIC(
    323                 solve_ode                 , 
     324                solve_ode                 ,
    324325                CppAD::vector             ,
    325                 double                    , 
    326                 solve_ode_forward         , 
     326                double                    ,
     327                solve_ode_forward         ,
    327328                solve_ode_reverse         ,
    328329                solve_ode_for_jac_sparse  ,
    329330                solve_ode_rev_jac_sparse  ,
    330                 solve_ode_rev_hes_sparse 
     331                solve_ode_rev_hes_sparse
    331332        )
    332333} // End empty namespace
     
    356357        for(size_t i_step = 0; i_step < M; i_step++)
    357358        {       size_t id = 0;               // not used
    358                 solve_ode(id, ax, ay); 
     359                solve_ode(id, ax, ay);
    359360                ax[0] = ay[0];
    360361                ax[1] = ay[1];
     
    366367        // where t = u_2
    367368        ADFun<double> f;
    368         f.Dependent(au, ay); 
     369        f.Dependent(au, ay);
    369370
    370371        // --------------------------------------------------------------------
     
    434435        // forward mode sparsity pattern for the Jacobian
    435436        // f_u = [   1, 0,   1 ]
    436         //       [ u_2, 1, u_2 ] 
     437        //       [ u_2, 1, u_2 ]
    437438        size_t i, j, p = n;
    438439        CppAD::vectorBool r(n * p), s(m * p);
     
    440441        for(i = 0; i < n; i++)
    441442                for(j = 0; j < p; j++)
    442                         r[i*n +j] = (i == j); 
     443                        r[i*n +j] = (i == j);
    443444        s   = f.ForSparseJac(p, r);
    444445        ok &= s[ 0 * p + 0] == true;
     
    456457        for(i = 0; i < q; i++)
    457458                for(j = 0; j < m; j++)
    458                         s[i*m +j] = (i == j); 
     459                        s[i*m +j] = (i == j);
    459460        r   = f.RevSparseJac(q, s);
    460461        ok &= r[ 0 * n + 0] == true;
     
    485486        ok &= h[2 * n + 1] == false;
    486487        ok &= h[2 * n + 2] == true;
    487        
     488
    488489        // --------------------------------------------------------------------
    489490        destroy_r();
    490491
    491         // Free all temporary work space associated with old_atomic objects. 
    492         // (If there are future calls to user atomic functions, they will 
     492        // Free all temporary work space associated with old_atomic objects.
     493        // (If there are future calls to user atomic functions, they will
    493494        // create new temporary work space.)
    494495        CppAD::user_atomic<double>::clear();
  • trunk/example/atomic/tangent.cpp

    r3717 r3731  
    292292                if( s[0] | s[1] )
    293293                {       for(j = 0; j < p; j++)
    294                                 v[j] |= r[j];
     294                        {       // Visual Studio 2013 generates warning without bool below
     295                                v[j] |= bool( r[j] );
     296                        }
    295297                }
    296298
  • trunk/omh/whats_new/whats_new_15.omh

    r3726 r3731  
    5757        gmtime
    5858        asctime
     59        ipopt
     60        fadbad
     61        sacado
     62        unreferenced
    5963$$
    6064
     
    6670The purpose of this section is to
    6771assist you in learning about changes between various versions of CppAD.
     72
     73$head 09-24$$
     74Fix some Visual Studio 2013 C++ level four $code /W4$$ warnings
     75(previous warnings were are level 3).
     76In addition, disable warning
     77$code 4100$$ unreferenced formal parameter,
     78and warning
     79$code 4127$$ conditional expression is constant.
     80
     81$head 09-23$$
     82CppAD can optionally test its use with the external packages
     83$cref/eigen/get_eigen.sh/$$,
     84$cref/ipopt/get_ipopt.sh/$$, and
     85$cref/colpack/get_colpack.sh/$$.
     86In addition, it can compare its $cref speed$$ with the external AD packages
     87$cref/adolc/get_adolc.sh/$$,
     88$cref/fadbad/get_fadbad.sh/$$, and
     89$cref/sacado/get_sacado.sh/$$.
     90The scripts that download and install a local copy of these external packages
     91have been modified to automatically skip installation
     92when it has already been done.
    6893
    6994$head 09-21$$
Note: See TracChangeset for help on using the changeset viewer.