Changeset 3757 for trunk/test_more


Ignore:
Timestamp:
Nov 30, 2015 7:03:07 AM (4 years ago)
Author:
bradbell
Message:

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

commit aec9ede58726ce1a40825eac63d4d8f7cb40bfba
Author: Brad Bell <bradbell@…>
Date: Sun Nov 29 21:24:17 2015 -0800

Move omh/libaray to omh/utility becasue it corresponds to cppad/utility.

commit 17b6e02f29dcc2a1ab2d2e6980a979374e73e19e
Author: Brad Bell <bradbell@…>
Date: Sun Nov 29 19:03:22 2015 -0800

Batch edit the entire souce directory using the script

bin/batch_edit.sh

  1. With a few exceptions, move cppad/*.hpp to cppad/utility/*.hpp
  2. Change include gaurd from CPPAD_<NAME>_INCLUDED to CPPAD_<NAME>_HPP
  3. Make the source code control $Id$ commands more uniform.
  4. Remove invisible white space
  5. Create utility.hpp (includes entire utilty directory)

commit 4a8fbe249f97116cac86583a7d9bf596dbb06473
Author: Brad Bell <bradbell@…>
Date: Sun Nov 29 18:12:50 2015 -0800

new version that passes bin/check_all.sh

commit f041069fe3e24d68133f829353f7200cf2c299ed
Author: Brad Bell <bradbell@…>
Date: Sun Nov 29 14:27:08 2015 -0800

pases bin/check_all.sh

commit 32ac61696305b7625938d4c488203cdcc19f36dc
Author: Brad Bell <bradbell@…>
Date: Sun Nov 29 06:13:56 2015 -0800

passed bin/check_all.sh

Location:
trunk/test_more
Files:
14 edited

Legend:

Unmodified
Added
Removed
  • trunk/test_more/copy.cpp

    r2506 r3757  
    1 /* $Id$ */
     1// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 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
     
    3131
    3232        // create an AD<double> that does not depend on s
    33         AD<double> t = 3.;   
     33        AD<double> t = 3.;
    3434
    35         // use copy constructor 
    36         AD<double> x(U[is]);   
     35        // use copy constructor
     36        AD<double> x(U[is]);
    3737        AD<double> y(t);
    3838
     
    5252        CPPAD_TESTVECTOR(double) v( f.Domain() );
    5353        CPPAD_TESTVECTOR(double) w( f.Range() );
    54  
    55         // check parameters flags
    56         ok &= ! f.Parameter(ix);
    57         ok &=   f.Parameter(iy);
     54
     55        // check parameters flags
     56        ok &= ! f.Parameter(ix);
     57        ok &=   f.Parameter(iy);
    5858
    5959        // check function values
     
    8383
    8484        // create an AD<double> that does not depend on x
    85         AD<double> b = 3.;   
     85        AD<double> b = 3.;
    8686
    87         // use copy constructor 
    88         AD<double> u(x[0]);   
     87        // use copy constructor
     88        AD<double> u(x[0]);
    8989        AD<double> v = b;
    9090
     
    103103        CPPAD_TESTVECTOR(double) dx(n);
    104104        CPPAD_TESTVECTOR(double) dy(m);
    105  
    106         // check parameters flags
    107         ok &= ! f.Parameter(0);
    108         ok &=   f.Parameter(1);
     105
     106        // check parameters flags
     107        ok &= ! f.Parameter(0);
     108        ok &=   f.Parameter(1);
    109109
    110110        // check function values
     
    124124        using CppAD::AD;   // so can use AD in place of CppAD::AD
    125125
    126         // construct directly from Base where Base is double 
    127         AD<double> x(1.); 
     126        // construct directly from Base where Base is double
     127        AD<double> x(1.);
    128128
    129129        // construct from a type that converts to Base where Base is double
     
    131131
    132132        // construct from a type that converts to Base where Base = AD<double>
    133         AD< AD<double> > z(3); 
     133        AD< AD<double> > z(3);
    134134
    135135        // check that resulting objects are parameters
     
    164164
    165165        // assign them values
    166         x = 3.; 
     166        x = 3.;
    167167        y = 4.;
    168168
  • trunk/test_more/div.cpp

    r3519 r3757  
    1 /* $Id$ */
     1// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 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
     
    4848        Z[x] = U[s]   / U[t];   // AD<double> / AD<double>
    4949        Z[y] = Z[x]   / 4.;     // AD<double> / double
    50         Z[z] = 5. / Z[y];       //     double / AD<double> 
     50        Z[z] = 5. / Z[y];       //     double / AD<double>
    5151        Z[u] =  Z[z] / one;     // division by a parameter equal to one
    5252        Z[v] =  Z[z] / 1.;      // division by a double equal to one
     
    6161        CPPAD_TESTVECTOR(double) q( f.Domain() );
    6262        CPPAD_TESTVECTOR(double) r( f.Range() );
    63  
    64         // check parameter flag
    65         ok &= f.Parameter(w);
     63
     64        // check parameter flag
     65        ok &= f.Parameter(w);
    6666
    6767        // check values
     
    9595        Q    = f.Reverse(2, r);
    9696        ok  &= NearEqual(
    97                 Q[s * f.Domain() + 1], 
    98                 - 1. / (U[t] * U[t]), 
    99                 1e-10, 
     97                Q[s * f.Domain() + 1],
     98                - 1. / (U[t] * U[t]),
     99                1e-10,
    100100                1e-10
    101101        );
     
    116116        AD<double> a = U[0] / 1.; // AD<double> / double
    117117        AD<double> b = a  / 2;    // AD<double> / int
    118         AD<double> c = 3. / b;    // double     / AD<double> 
    119         AD<double> d = 4  / c;    // int        / AD<double> 
    120 
    121         // dependent variable vector 
     118        AD<double> c = 3. / b;    // double     / AD<double>
     119        AD<double> d = 4  / c;    // int        / AD<double>
     120
     121        // dependent variable vector
    122122        CPPAD_TESTVECTOR(AD<double>) Z(1);
    123123        Z[0] = U[0] * U[0] / d;   // AD<double> / AD<double>
    124124
    125125        // create f: U -> Z and vectors used for derivative calculations
    126         ADFun<double> f(U, Z); 
     126        ADFun<double> f(U, Z);
    127127        CPPAD_TESTVECTOR(double) v(1);
    128128        CPPAD_TESTVECTOR(double) w(1);
    129129
    130         // check value 
     130        // check value
    131131        ok &= NearEqual(Value(Z[0]) , u0*u0/(4/(3/(u0/2))),  1e-10 , 1e-10);
    132132
     
    140140        {
    141141                jfac *= j;
    142                 w     = f.Forward(j, v);       
     142                w     = f.Forward(j, v);
    143143                ok &= NearEqual(jfac*w[0], value, 1e-10 , 1e-10); // d^jz/du^j
    144144                v[0]  = 0.;
     
    147147
    148148        // reverse computation of partials of Taylor coefficients
    149         CPPAD_TESTVECTOR(double) r(p); 
     149        CPPAD_TESTVECTOR(double) r(p);
    150150        w[0]  = 1.;
    151151        r     = f.Reverse(p, w);
     
    166166        using namespace CppAD;
    167167
    168         // more testing of variable / variable case 
     168        // more testing of variable / variable case
    169169        double x0 = 2.;
    170170        double x1 = 3.;
     
    184184        dx[1] = 1.;
    185185        dy    = f.Forward(1, dx);
    186         check = 1. / x1 - x0 / (x1 * x1); 
     186        check = 1. / x1 - x0 / (x1 * x1);
    187187        ok   &= NearEqual(dy[0], check, 1e-10 , 1e-10);
    188188
     
    203203{       bool ok = true;
    204204        ok &= DivTestOne();
    205         ok &= DivTestTwo(); 
    206         ok &= DivTestThree(); 
    207         return ok;
    208 }
     205        ok &= DivTestTwo();
     206        ok &= DivTestThree();
     207        return ok;
     208}
  • trunk/test_more/div_eq.cpp

    r2506 r3757  
    1 /* $Id$ */
     1// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 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
     
    4141
    4242        // dependent variable values
    43         Z[x] = U[s];   
     43        Z[x] = U[s];
    4444        Z[y] = U[t];
    4545        Z[x] /= U[t]; // AD<double> *= AD<double>
     
    4848        Z[y] /= one;  // divide by a parameter equal to one
    4949        Z[y] /= 1.;   // divide by a double equal to one
    50        
     50
    5151        // check that zero is still a parameter
    5252        // (must do this before creating f because it erases the tape)
     
    5959
    6060        // check that none of the components of f are parameters
    61         size_t i;
    62         for(i = 0; i < f.Range(); i++)
    63                 ok &= ! f.Parameter(i);
     61        size_t i;
     62        for(i = 0; i < f.Range(); i++)
     63                ok &= ! f.Parameter(i);
    6464
    6565        // check functin values
     
    7878        w[x] = 1.;
    7979        w[y] = 0.;
    80         r    = f.Reverse(2, w); 
     80        r    = f.Reverse(2, w);
    8181        ok &= NearEqual(r[2 * s + 1]                 // d^2 x / (dt ds)
    8282                 , - 1. / (U[t] * U[t])     , 1e-10 , 1e-10 );
     
    9595        double u0 = .5;
    9696        CPPAD_TESTVECTOR(AD<double>) U(1);
    97         U[0]      = u0; 
     97        U[0]      = u0;
    9898        Independent(U);
    9999
    100         // dependent variable vector 
     100        // dependent variable vector
    101101        CPPAD_TESTVECTOR(AD<double>) Z(1);
    102102        Z[0] = U[0] * U[0]; // initial value
    103103        Z[0] /= 2;          // AD<double> /= int
    104104        Z[0] /= 4.;         // AD<double> /= double
    105         Z[0] /= U[0];       // AD<double> /= AD<double> 
     105        Z[0] /= U[0];       // AD<double> /= AD<double>
    106106
    107107        // create f: U -> Z and vectors used for derivative calculations
    108         ADFun<double> f(U, Z); 
     108        ADFun<double> f(U, Z);
    109109        CPPAD_TESTVECTOR(double) v(1);
    110110        CPPAD_TESTVECTOR(double) w(1);
    111111
    112         // check value 
     112        // check value
    113113        ok &= NearEqual(Z[0] , u0*u0/(2*4*u0),  1e-10 , 1e-10);
    114114
     
    121121        for(j = 1; j < p; j++)
    122122        {       jfac *= j;
    123                 w     = f.Forward(j, v);       
     123                w     = f.Forward(j, v);
    124124                ok &= NearEqual(jfac*w[0], value, 1e-10 , 1e-10); // d^jz/du^j
    125125                v[0]  = 0.;
     
    128128
    129129        // reverse computation of partials of Taylor coefficients
    130         CPPAD_TESTVECTOR(double) r(p); 
     130        CPPAD_TESTVECTOR(double) r(p);
    131131        w[0]  = 1.;
    132132        r     = f.Reverse(p, w);
     
    147147{       bool ok = true;
    148148        ok &= DivEqTestOne();
    149         ok &= DivEqTestTwo(); 
     149        ok &= DivEqTestTwo();
    150150        return ok;
    151151}
  • trunk/test_more/extern_value.hpp

    r3275 r3757  
    1 /* $Id$ */
     1// $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
     
    1111-------------------------------------------------------------------------- */
    1212
    13 # ifndef CPPAD_EXTERN_VALUE_INCLUDED
    14 # define CPPAD_EXTERN_VALUE_INCLUDED
     13# ifndef CPPAD_EXTERN_VALUE_HPP
     14# define CPPAD_EXTERN_VALUE_HPP
    1515
    16 template <class Type> 
     16template <class Type>
    1717class extern_value  {
    1818private:
  • trunk/test_more/ipopt_solve.cpp

    r2896 r3757  
    1 /* $Id$ */
     1// $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
     
    2727                        assert( x.size()  == 4 );
    2828
    29                         // Fortran style indexing 
     29                        // Fortran style indexing
    3030                        AD<double> x1 = x[0];
    3131                        AD<double> x2 = x[1];
     
    4343        };
    4444}
    45        
     45
    4646bool ipopt_solve(void)
    4747{       bool ok = true;
     
    5050
    5151        // number of independent variables (domain dimension for f and g)
    52         size_t nx = 4; 
     52        size_t nx = 4;
    5353        // number of constraints (range dimension for g)
    5454        size_t ng = 2;
     
    6868        Dvector gl(ng), gu(ng);
    6969        gl[0] = 25.0;     gu[0] = 1.0e19;
    70         gl[1] = 40.0;     gu[1] = 40.0;
     70        gl[1] = 40.0;     gu[1] = 40.0;
    7171
    7272        // object that computes objective and constraints
    7373        FG_eval fg_eval;
    7474
    75         // options 
     75        // options
    7676        std::string base_options;
    7777        // turn off any printing
    78         base_options += "Integer print_level  0\n"; 
     78        base_options += "Integer print_level  0\n";
    7979        base_options += "String  sb         yes\n";
    8080        // maximum number of iterations
    8181        base_options += "Integer max_iter     10\n";
    8282        // approximate accuracy in first order necessary conditions;
    83         // see Mathematical Programming, Volume 106, Number 1, 
     83        // see Mathematical Programming, Volume 106, Number 1,
    8484        // Pages 25-57, Equation (6)
    8585        base_options += "Numeric tol          1e-6\n";
    8686        // derivative testing
    8787        base_options += "String  derivative_test            second-order\n";
    88         // maximum amount of random pertubation; e.g., 
     88        // maximum amount of random pertubation; e.g.,
    8989        // when evaluation finite diff
    9090        base_options += "Numeric point_perturbation_radius  0.\n";
     
    113113                ok &= solution.status==CppAD::ipopt::solve_result<Dvector>::success;
    114114                //
    115                 // Check some of the solution values
     115                // Check some of the solution values
    116116                for(j = 0; j < nx; j++)
    117117                {       ok &= CppAD::NearEqual(
  • trunk/test_more/ode_err_control.cpp

    r2506 r3757  
    1 /* $Id$ */
     1// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-07 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
     
    1313# include <cstddef>                    // for size_t
    1414# include <cmath>                      // for exp
    15 # include <cppad/ode_err_control.hpp>  // CppAD::OdeErrControl
    16 # include <cppad/near_equal.hpp>       // CppAD::NearEqual
    17 # include <cppad/vector.hpp>           // CppAD::vector
    18 # include <cppad/runge_45.hpp>         // CppAD::Runge45
     15# include <cppad/utility/ode_err_control.hpp>  // CppAD::OdeErrControl
     16# include <cppad/utility/near_equal.hpp>       // CppAD::NearEqual
     17# include <cppad/utility/vector.hpp>           // CppAD::vector
     18# include <cppad/utility/runge_45.hpp>         // CppAD::Runge45
    1919
    2020/* -------------------------------------------------------------------------
     
    3131                // constructor
    3232                Fun_one(size_t n_) : n(n_)
    33                 { } 
     33                { }
    3434
    3535                // given x(0) = 0
    3636                // solution is x_i (t) = t^(i+1)
    3737                void Ode(
    38                         const double                &t, 
    39                         const CppAD::vector<double> &x, 
     38                        const double                &t,
     39                        const CppAD::vector<double> &x,
    4040                        CppAD::vector<double>       &f)
    4141                {       size_t i;
     
    5555                { }
    5656                void step(
    57                         double ta, 
    58                         double tb, 
     57                        double ta,
     58                        double tb,
    5959                        CppAD::vector<double> &xa ,
    6060                        CppAD::vector<double> &xb ,
     
    7171
    7272        // Runge45 should yield exact results for x_i (t) = t^(i+1), i < 4
    73         size_t  n = 6;       
    74        
     73        size_t  n = 6;
     74
    7575        // construct method for n component solution
    7676        Method_one method(n);
     
    9797        CppAD::vector<double> ef(n);
    9898        CppAD::vector<double> xf(n);
    99        
     99
    100100        xf = OdeErrControl(method,
    101101                ti, tf, xi, smin, smax, scur, eabs, erel, ef);
     
    112112/*
    113113Old example now just a test
    114 Define 
     114Define
    115115$latex X : \B{R} \rightarrow \B{R}^2$$ by
    116116$latex \[
     
    124124\begin{array}{rcl}
    125125        X_0^{(1)} (t) & = & - w_0 X_0 (t)  \\
    126         X_1^{(1)} (t) & = & + w_0 X_0 (t) - w_1 X_1 (t) 
     126        X_1^{(1)} (t) & = & + w_0 X_0 (t) - w_1 X_1 (t)
    127127\end{array}
    128128\] $$
     
    137137                // constructor
    138138                Fun_two(const CppAD::vector<double> &w_) : w(w_)
    139                 { } 
     139                { }
    140140
    141141                // set f = x'(t)
    142142                void Ode(
    143                         const double                &t, 
    144                         const CppAD::vector<double> &x, 
     143                        const double                &t,
     144                        const CppAD::vector<double> &x,
    145145                        CppAD::vector<double>       &f)
    146146                {       f[0] = - w[0] * x[0];
    147                         f[1] = + w[0] * x[0] - w[1] * x[1];     
     147                        f[1] = + w[0] * x[0] - w[1] * x[1];
    148148                }
    149149        };
     
    158158                { }
    159159                void step(
    160                         double ta, 
    161                         double tb, 
     160                        double ta,
     161                        double tb,
    162162                        CppAD::vector<double> &xa ,
    163163                        CppAD::vector<double> &xb ,
     
    200200        size_t nstep;
    201201
    202        
     202
    203203        xf = OdeErrControl(method,
    204204                ti, tf, xi, smin, smax, scur, eabs, erel, ef, maxabs, nstep);
     
    215215}
    216216/*
    217 Define 
     217Define
    218218$latex X : \B{R} \rightarrow \B{R}^2$$ by
    219219$latex \[
     
    230230X_0 (t) & = &  \exp ( \alpha t^2 )  \\
    231231X_1 (t) & = &  \int_0^t \exp( - \alpha s^2 ) {\bf d} s \\
    232 & = & 
     232& = &
    233233\frac{1}{ \sqrt{\alpha} \int_0^{\sqrt{\alpha} t} \exp( - r^2 ) {\bf d} r
    234234\\
     
    237237\] $$
    238238If $latex X_0 (t) < 0$$,
    239 we return $code nan$$ in order to inform 
     239we return $code nan$$ in order to inform
    240240$code OdeErrControl$$ that its is taking to large a step.
    241241
    242242*/
    243243
    244 # include <cppad/rosen_34.hpp>          // CppAD::Rosen34
     244# include <cppad/utility/rosen_34.hpp>          // CppAD::Rosen34
    245245# include <cppad/cppad.hpp>
    246246
     
    254254                // constructor
    255255                Fun_three(double alpha) : alpha_(alpha), was_negative_(false)
    256                 { } 
     256                { }
    257257
    258258                // set f = x'(t)
    259259                void Ode(
    260                         const double                &t, 
    261                         const CppAD::vector<double> &x, 
     260                        const double                &t,
     261                        const CppAD::vector<double> &x,
    262262                        CppAD::vector<double>       &f)
    263263                {       f[0] = 2. * alpha_ * t * x[0];
    264                         f[1] = 1. / x[0];       
     264                        f[1] = 1. / x[0];
    265265                        // case where ODE does not make sense
    266266                        if( x[0] < 0. || x[1] < 0. )
     
    271271                // set f_t = df / dt
    272272                void Ode_ind(
    273                         const double                &t, 
    274                         const CppAD::vector<double> &x, 
     273                        const double                &t,
     274                        const CppAD::vector<double> &x,
    275275                        CppAD::vector<double>       &f_t)
    276276                {
    277277                        f_t[0] =  2. * alpha_ * x[0];
    278                         f_t[1] = 0.;   
     278                        f_t[1] = 0.;
    279279                        if( x[0] < 0. || x[1] < 0. )
    280280                        {       was_negative_ = true;
     
    284284                // set f_x = df / dx
    285285                void Ode_dep(
    286                         const double                &t, 
    287                         const CppAD::vector<double> &x, 
     286                        const double                &t,
     287                        const CppAD::vector<double> &x,
    288288                        CppAD::vector<double>       &f_x)
    289289                {       double x0_sq = x[0] * x[0];
     
    311311                { }
    312312                void step(
    313                         double ta, 
    314                         double tb, 
     313                        double ta,
     314                        double tb,
    315315                        CppAD::vector<double> &xa ,
    316316                        CppAD::vector<double> &xb ,
     
    351351        size_t nstep;
    352352
    353        
     353
    354354        xf = OdeErrControl(method,
    355355                ti, tf, xi, smin, smax, scur, eabs, erel, ef, maxabs, nstep);
     
    379379                // constructor
    380380                Fun_four(size_t n_) : n(n_)
    381                 { } 
     381                { }
    382382
    383383                // given x(0) = 0
    384384                // solution is x_i (t) = t^(i+1)
    385385                void Ode(
    386                         const double                &t, 
    387                         const CppAD::vector<double> &x, 
     386                        const double                &t,
     387                        const CppAD::vector<double> &x,
    388388                        CppAD::vector<double>       &f)
    389389                {       size_t i;
     
    403403                { }
    404404                void step(
    405                         double ta, 
    406                         double tb, 
     405                        double ta,
     406                        double tb,
    407407                        CppAD::vector<double> &xa ,
    408408                        CppAD::vector<double> &xb ,
     
    417417bool OdeErrControl_four(void)
    418418{       bool   ok = true;     // initial return value
    419        
     419
    420420        // construct method for n component solution
    421         size_t  n = 6;       
     421        size_t  n = 6;
    422422        Method_four method(n);
    423423
     
    444444        CppAD::vector<double> ef(n);
    445445        CppAD::vector<double> xf(n);
    446        
     446
    447447        xf = OdeErrControl(method,
    448448                ti, tf, xi, smin, smax, scur, eabs, erel, ef);
  • trunk/test_more/old_mat_mul.hpp

    r3740 r3757  
    11// $Id$
    2 # ifndef CPPAD_OLD_MAT_MUL_INCLUDED
    3 # define CPPAD_OLD_MAT_MUL_INCLUDED
     2# ifndef CPPAD_OLD_MAT_MUL_HPP
     3# define CPPAD_OLD_MAT_MUL_HPP
    44
    55/* --------------------------------------------------------------------------
  • trunk/test_more/omp_alloc.cpp

    r3740 r3757  
    1 /* $Id$ */
     1// $Id$
    22/* --------------------------------------------------------------------------
    33CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     
    3232*/
    3333// BEGIN C++
    34 # include <cppad/omp_alloc.hpp>
    35 # include <cppad/memory_leak.hpp>
     34# include <cppad/utility/omp_alloc.hpp>
     35# include <cppad/utility/memory_leak.hpp>
    3636# include <vector>
    3737
  • trunk/test_more/rev_sparse_jac.cpp

    r3519 r3757  
    1 /* $Id$ */
     1// $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
     
    4949        Check[index * n + 2] = false;  \
    5050        index++;
    51  
     51
    5252
    5353# define CheckBinaryFun(Fun)           \
     
    7575
    7676        // dimension of the domain space
    77         size_t n = 3; 
     77        size_t n = 3;
    7878
    7979        // dimension of the range space
    8080        size_t m = (4 + 11 + 1) * 3 + 4;
    8181
    82         // independent variable vector 
     82        // independent variable vector
    8383        CPPAD_TESTVECTOR(AD<double>) X(n);
    84         X[0] = .1; 
     84        X[0] = .1;
    8585        X[1] = .2;
    8686        X[2] = .3;
     
    167167        {       for(j = 0; j < n; j++)
    168168                        ok &= (Px[i * n + j] == Check[i * n + j]);
    169         }       
     169        }
    170170        // --------------------------------------------------------
    171171        // dependency matrix for the identity function U(y) = y
     
    186186        {       for(j = 0; j < n; j++)
    187187                {       found = Sx[i].find(j) != Sx[i].end();
    188                         ok    &= (found == Check[i * n + j]);
     188                        ok    &= (found == Check[i * n + j]);
    189189                }
    190         }       
     190        }
    191191
    192192        return ok;
     
    198198
    199199        // dimension of the domain space
    200         size_t n = 3; 
     200        size_t n = 3;
    201201
    202202        // dimension of the range space
     
    209209                Z[k] = 0.;
    210210
    211         // independent variable vector 
     211        // independent variable vector
    212212        CPPAD_TESTVECTOR(AD<double>) X(n);
    213         X[0] = 0.; 
     213        X[0] = 0.;
    214214        X[1] = 1.;
    215215        X[2] = 2.;
     
    218218        // VecAD vector is going to depend on X[1] and X[2]
    219219        Z[ X[0] ] = X[1];
    220         Z[ X[1] ] = X[2]; 
     220        Z[ X[1] ] = X[2];
    221221
    222222        // dependent variable vector
     
    274274        {       for(j = 0; j < n; j++)
    275275                        ok &= (Px[i * n + j] == Check[i * n + j]);
    276         }       
     276        }
    277277        // --------------------------------------------------------
    278278        // dependency matrix for the identity function U(y) = y
     
    293293        {       for(j = 0; j < n; j++)
    294294                {       found = Sx[i].find(j) != Sx[i].end();
    295                         ok    &= (found == Check[i * n + j]);
     295                        ok    &= (found == Check[i * n + j]);
    296296                }
    297         }       
     297        }
    298298
    299299        return ok;
     
    305305
    306306        // dimension of the domain space
    307         size_t n = 2; 
     307        size_t n = 2;
    308308
    309309        // dimension of the range space
    310310        size_t m = 3;
    311311
    312         // independent variable vector 
     312        // independent variable vector
    313313        CPPAD_TESTVECTOR(AD<double>) X(n);
    314         X[0] = 2.; 
     314        X[0] = 2.;
    315315        X[1] = 3.;
    316316        Independent(X);
     
    366366        {       for(j = 0; j < n; j++)
    367367                        ok &= (Px[i * n + j] == Check[i * n + j]);
    368         }       
     368        }
    369369
    370370        // ---------------------------------------------------------
    371         // dependency matrix for the identity function 
     371        // dependency matrix for the identity function
    372372        CPPAD_TESTVECTOR(std::set<size_t>) Sy(m);
    373373        for(i = 0; i < m; i++)
     
    387387                        ok &= (found == Check[i * n + j]);
    388388                }
    389         }       
     389        }
    390390
    391391        return ok;
     
    395395// case where s is not identity matrix
    396396bool case_four()
    397 {       
     397{
    398398        bool ok = true;
    399399        using namespace CppAD;
    400400
    401401        // dimension of the domain space
    402         size_t n = 2; 
     402        size_t n = 2;
    403403
    404404        // dimension of the range space
    405405        size_t m = n;
    406406
    407         // independent and variable vectors 
     407        // independent and variable vectors
    408408        CPPAD_TESTVECTOR(AD<double>) ax(n), ay(m);
    409         ax[0] = 2.; 
     409        ax[0] = 2.;
    410410        ax[1] = 3.;
    411411        Independent(ax);
     
    435435
    436436        // dimension of the domain space
    437         size_t n = 2; 
     437        size_t n = 2;
    438438
    439439        // dimension of the range space
    440440        size_t m = 3;
    441441
    442         // independent variable vector 
     442        // independent variable vector
    443443        CPPAD_TESTVECTOR(AD<double>) X(n);
    444         X[0] = 2.; 
     444        X[0] = 2.;
    445445        X[1] = 3.;
    446446        Independent(X);
     
    497497        {       for(j = 0; j < n; j++)
    498498                        ok &= (Px[j * m + i] == Check[i * n + j]);
    499         }       
     499        }
    500500
    501501        // ---------------------------------------------------------
    502         // dependency matrix for the identity function 
     502        // dependency matrix for the identity function
    503503        CPPAD_TESTVECTOR(std::set<size_t>) Sy(m);
    504504        for(i = 0; i < m; i++)
     
    518518                        ok &= (found == Check[i * n + j]);
    519519                }
    520         }       
     520        }
    521521
    522522        return ok;
  • trunk/test_more/rev_two.cpp

    r2506 r3757  
    1 /* $Id$ */
     1// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-06 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
     
    2020
    2121        size_t n = 2;
    22         vector< AD<double> > X(n);
     22        vector< AD<double> > X(n);
    2323        X[0] = 1.;
    2424        X[1] = 1.;
     
    2626
    2727        size_t m = 1;
    28         vector< AD<double> > Y(m);
     28        vector< AD<double> > Y(m);
    2929        Y[0] = X[0] * X[0] + X[0] * X[1] + 2. * X[1] * X[1];
    3030        CppAD::ADFun<double> F(X,Y);
  • trunk/test_more/simple_vector.cpp

    r2506 r3757  
    1 /* $Id$ */
     1// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 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
     
    2727
    2828// Assuming CppAD (http://www.seanet.com/~bradbell/cppad) is installed
    29 # include <cppad/vector.hpp>
     29# include <cppad/utility/vector.hpp>
    3030# define MySimpleVector CppAD::vector
    3131
     
    4545        MyInt& operator=(const MyInt &x)
    4646        {       value = x.value;
    47                 count++; 
     47                count++;
    4848                return *this;
    4949        }
     
    5858private:
    5959        size_t count;  // count number of assignments
    60         int    value;  // value of this object 
     60        int    value;  // value of this object
    6161};
    6262
     
    6767        typedef vector::value_type myInt;        // type of elements
    6868
    69         vector x;                // default constructor 
     69        vector x;                // default constructor
    7070        ok &= (x.size() == 0);
    7171
     
    8282        ok &= ( (z[0] == myInt(0)) && (z[1] == myInt(1)) );
    8383
    84         // check that vector assignment 
     84        // check that vector assignment
    8585        x[0] = 2;                      // modify so that assignment changes x
    8686        size_t x0count = x[0].Count(); // store initial counts
  • trunk/test_more/sparse_jacobian.cpp

    r3108 r3757  
    1 /* $Id$ */
     1// $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
     
    7878        {       r[k] = i;
    7979                c[k] = i;
    80                 k++;   
     80                k++;
    8181                if( i < n-1 )
    8282                {       r[k] = i;
    8383                        c[k] = i+1;
    8484                        k++;
    85                 } 
     85                }
    8686        }
    8787        ok &= K == k;
     
    9191        ok &= n_sweep == 3;
    9292        for(k = 0; k < K; k++)
    93         {       ell = r[k] * n + c[k];
     93        {       ell = r[k] * n + c[k];
    9494                ok &=  NearEqual(check[ell], jac[k], eps, eps);
    9595        }
     
    9898        ok &= n_sweep == 3;
    9999        for(k = 0; k < K; k++)
    100         {       ell = r[k] * n + c[k];
     100        {       ell = r[k] * n + c[k];
    101101                ok &=  NearEqual(check[ell], jac[k], eps, eps);
    102102        }
     
    105105}
    106106
    107 template <class VectorBase, class VectorSet> 
     107template <class VectorBase, class VectorSet>
    108108bool rc_set(void)
    109109{       bool ok = true;
     
    136136                x[j] = double(j);
    137137
    138         // Jacobian of y 
     138        // Jacobian of y
    139139        /*
    140140              [ 1 2 0 0    ]
     
    153153        p   = f.RevSparseJac(m, s);
    154154
    155         // Use forward mode to compute columns 0 and 2 
     155        // Use forward mode to compute columns 0 and 2
    156156        // (make sure order of rows and columns does not matter)
    157157        CPPAD_TESTVECTOR(size_t) r(3), c(3);
     
    163163        size_t n_sweep = f.SparseJacobianForward(x, p, r, c, jac, work);
    164164        for(k = 0; k < 3; k++)
    165         {       ell = r[k] * n + c[k];
     165        {       ell = r[k] * n + c[k];
    166166                ok &=  NearEqual(check[ell], jac[k], eps, eps);
    167167        }
    168168        ok &= (n_sweep == 1);
    169169
    170         // Use reverse mode to compute rows 0 and 1 
     170        // Use reverse mode to compute rows 0 and 1
    171171        // (make sure order of rows and columns does not matter)
    172172        r.resize(4), c.resize(4); jac.resize(4);
     
    178178        n_sweep = f.SparseJacobianReverse(x, p, r, c, jac, work);
    179179        for(k = 0; k < 4; k++)
    180         {       ell = r[k] * n + c[k];
     180        {       ell = r[k] * n + c[k];
    181181                ok &=  NearEqual(check[ell], jac[k], eps, eps);
    182182        }
     
    185185        return ok;
    186186}
    187 template <class VectorBase, class VectorBool> 
     187template <class VectorBase, class VectorBool>
    188188bool rc_bool(void)
    189189{       bool ok = true;
     
    216216                x[j] = double(j);
    217217
    218         // Jacobian of y 
     218        // Jacobian of y
    219219        /*
    220220              [ 1 2 0 0    ]
     
    231231        s[8] = true;   s[9] = true;  s[10] = false;  s[11] = true;
    232232
    233         // Use forward mode to compute columns 0 and 2 
     233        // Use forward mode to compute columns 0 and 2
    234234        // (make sure order of rows and columns does not matter)
    235235        CPPAD_TESTVECTOR(size_t) r(3), c(3);
     
    241241        size_t n_sweep = f.SparseJacobianForward(x, s, r, c, jac, work);
    242242        for(k = 0; k < 3; k++)
    243         {       ell = r[k] * n + c[k];
     243        {       ell = r[k] * n + c[k];
    244244                ok &=  NearEqual(check[ell], jac[k], eps, eps);
    245245        }
    246246        ok &= (n_sweep == 1);
    247247
    248         // Use reverse mode to compute rows 0 and 1 
     248        // Use reverse mode to compute rows 0 and 1
    249249        // (make sure order of rows and columns does not matter)
    250250        r.resize(4), c.resize(4); jac.resize(4);
     
    256256        n_sweep = f.SparseJacobianReverse(x, s, r, c, jac, work);
    257257        for(k = 0; k < 4; k++)
    258         {       ell = r[k] * n + c[k];
     258        {       ell = r[k] * n + c[k];
    259259                ok &=  NearEqual(check[ell], jac[k], eps, eps);
    260260        }
     
    265265
    266266
    267 template <class VectorBase, class VectorBool> 
     267template <class VectorBase, class VectorBool>
    268268bool reverse_bool(void)
    269269{       bool ok = true;
     
    326326}
    327327
    328 template <class VectorBase, class VectorSet> 
     328template <class VectorBase, class VectorSet>
    329329bool reverse_set(void)
    330330{       bool ok = true;
     
    383383}
    384384
    385 template <class VectorBase, class VectorBool> 
     385template <class VectorBase, class VectorBool>
    386386bool forward_bool(void)
    387387{       bool ok = true;
     
    424424        */
    425425        VectorBase check(m * n);
    426         check[0] = 1.; check[1]  = 0.; check[2]  = 1.; 
     426        check[0] = 1.; check[1]  = 0.; check[2]  = 1.;
    427427        check[3] = 1.; check[4]  = 0.; check[5]  = 1.;
    428         check[6] = 0.; check[7]  = 1.; check[8]  = 1.; 
     428        check[6] = 0.; check[7]  = 1.; check[8]  = 1.;
    429429        check[9] = 0.; check[10] = 1.; check[11] = x[2];
    430430        for(k = 0; k < 12; k++)
     
    447447}
    448448
    449 template <class VectorBase, class VectorSet> 
     449template <class VectorBase, class VectorSet>
    450450bool forward_set(void)
    451451{       bool ok = true;
     
    488488        */
    489489        VectorBase check(m * n);
    490         check[0] = 1.; check[1]  = 0.; check[2]  = 1.; 
     490        check[0] = 1.; check[1]  = 0.; check[2]  = 1.;
    491491        check[3] = 1.; check[4]  = 0.; check[5]  = 1.;
    492         check[6] = 0.; check[7]  = 1.; check[8]  = 1.; 
     492        check[6] = 0.; check[7]  = 1.; check[8]  = 1.;
    493493        check[9] = 0.; check[10] = 1.; check[11] = x[2];
    494494        for(k = 0; k < 12; k++)
     
    513513        size_t i, j;
    514514
    515         // should be the same as the corresponding typedef in 
     515        // should be the same as the corresponding typedef in
    516516        // cppad/local/sparse_pack.hpp
    517517        typedef size_t Pack;
     
    550550        return ok;
    551551}
    552 } // End empty namespace 
     552} // End empty namespace
    553553# include <vector>
    554554# include <valarray>
  • trunk/test_more/test_more.cpp

    r3740 r3757  
    1 /* $Id$ */
     1// $Id$
    22/* --------------------------------------------------------------------------
    33CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     
    1515
    1616// memory leak checker
    17 # include <cppad/thread_alloc.hpp>
     17# include <cppad/utility/thread_alloc.hpp>
    1818
    1919// prototype external compiled tests (this line expected by bin/new_test.sh)
  • trunk/test_more/track_new_del.cpp

    r2794 r3757  
    1 /* $Id$ */
     1// $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
     
    1515
    1616$section Tracking Use of New and Delete: Example and Test$$
     17$mindex delete$$
    1718
    18 $index new, example$$
    19 $index example, new$$
    20 $index test, new$$
    2119
    22 $index delete, example$$
    23 $index example, delete$$
    24 $index test, delete$$
    2520
    2621$code
     
    3227// BEGIN C++
    3328
    34 # include <cppad/track_new_del.hpp>
     29# include <cppad/utility/track_new_del.hpp>
    3530
    3631bool track_new_del(void)
     
    5449        newlen = 10;
    5550        ptr    = CPPAD_TRACK_EXTEND(newlen, ncopy, ptr);
    56                
     51
    5752        // copy data into the new part of the array
    5853        for(i = ncopy; i < newlen; i++)
     
    6055
    6156        // check the values in the array
    62         for(i = 0; i < newlen; i++)
     57        for(i = 0; i < newlen; i++)
    6358                ok &= (ptr[i] == double(i));
    6459
Note: See TracChangeset for help on using the changeset viewer.