Changeset 3779 for trunk/test_more


Ignore:
Timestamp:
Jan 1, 2016 6:26:11 AM (4 years ago)
Author:
bradbell
Message:

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

commit 5661e2a629cceb77e7b703225bc1f3f8cf422129
Author: Brad Bell <bradbell@…>
Date: Fri Jan 1 04:23:41 2016 -0700

push_git2svn.py: Include changes in copyright date when checking for difference.

commit f0e9d149dc00ccf410a268389e3dcfd95499b863
Author: Brad Bell <bradbell@…>
Date: Fri Jan 1 03:57:09 2016 -0700

Advance copyright year to 2016.

commit 01d25679b7baddca878129635b0758f4ebb263fb
Author: Brad Bell <bradbell@…>
Date: Fri Jan 1 03:54:41 2016 -0700

download.omh: improve the no documentation download instructions.

Location:
trunk/test_more
Files:
55 edited

Legend:

Unmodified
Added
Removed
  • trunk/test_more/abs.cpp

    r2506 r3779  
    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
  • trunk/test_more/add.cpp

    r2506 r3779  
    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        Z[x] = U[s]  + U[t];   // AD<double> + AD<double>
    4242        Z[y] = Z[x]  + 1.;     // AD<double> + double
    43         Z[z] = 1.    + Z[y];   // double + AD<double> 
     43        Z[z] = 1.    + Z[y];   // double + AD<double>
    4444
    4545        // create f: U -> Z and vectors used for derivative calculations
     
    8181        double u0 = .5;
    8282        CPPAD_TESTVECTOR(AD<double>) U(1);
    83         U[0]      = u0; 
     83        U[0]      = u0;
    8484        Independent(U);
    8585
    8686        AD<double> a = U[0] + 1.; // AD<double> + double
    8787        AD<double> b = a  + 2;    // AD<double> + int
    88         AD<double> c = 3. + b;    // double     + AD<double> 
    89         AD<double> d = 4  + c;    // int        + AD<double> 
     88        AD<double> c = 3. + b;    // double     + AD<double>
     89        AD<double> d = 4  + c;    // int        + AD<double>
    9090
    91         // dependent variable vector 
     91        // dependent variable vector
    9292        CPPAD_TESTVECTOR(AD<double>) Z(1);
    93         Z[0] = d + U[0];          // AD<double> + AD<double> 
     93        Z[0] = d + U[0];          // AD<double> + AD<double>
    9494
    9595        // create f: U -> Z and vectors used for derivative calculations
    96         ADFun<double> f(U, Z); 
     96        ADFun<double> f(U, Z);
    9797        CPPAD_TESTVECTOR(double) v(1);
    9898        CPPAD_TESTVECTOR(double) w(1);
    9999
    100         // check value 
     100        // check value
    101101        ok &= NearEqual(Z[0] , 2 * u0 + 10,  1e-10 , 1e-10);
    102102
     
    109109        for(j = 1; j < p; j++)
    110110        {       jfac *= j;
    111                 w     = f.Forward(j, v);       
     111                w     = f.Forward(j, v);
    112112                ok &= NearEqual(jfac*w[0], value, 1e-10 , 1e-10); // d^jz/du^j
    113113                v[0]  = 0.;
     
    116116
    117117        // reverse computation of partials of Taylor coefficients
    118         CPPAD_TESTVECTOR(double) r(p); 
     118        CPPAD_TESTVECTOR(double) r(p);
    119119        w[0]  = 1.;
    120120        r     = f.Reverse(p, w);
     
    135135{       bool ok = true;
    136136        ok &= AddTestOne();
    137         ok &= AddTestTwo(); 
     137        ok &= AddTestTwo();
    138138        return ok;
    139139}
  • trunk/test_more/add_eq.cpp

    r2506 r3779  
    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
     
    4242        Z[x] += U[s];  // parameter += variable
    4343        Z[x] += U[t];  // variable  += variable
    44         Z[y] += .5;    // variable  += double 
     44        Z[y] += .5;    // variable  += double
    4545        // use .5 because it is represented exactly in binary and
    4646        // because it makes sure that += does not slice the double to an int
     
    8181        double u0 = .5;
    8282        CPPAD_TESTVECTOR(AD<double>) U(1);
    83         U[0]      = u0; 
     83        U[0]      = u0;
    8484        Independent(U);
    8585
    86         // dependent variable vector 
     86        // dependent variable vector
    8787        CPPAD_TESTVECTOR(AD<double>) Z(1);
    8888        Z[0] = U[0];       // initial value
    8989        Z[0] += 2;         // AD<double> += int
    9090        Z[0] += 4.;        // AD<double> += double
    91         Z[0] += U[0];      // AD<double> += AD<double> 
     91        Z[0] += U[0];      // AD<double> += AD<double>
    9292
    9393        // create f: U -> Z and vectors used for derivative calculations
    94         ADFun<double> f(U, Z); 
     94        ADFun<double> f(U, Z);
    9595        CPPAD_TESTVECTOR(double) v(1);
    9696        CPPAD_TESTVECTOR(double) w(1);
    9797
    98         // check value 
     98        // check value
    9999        ok &= NearEqual(Z[0] , u0+2+4+u0,  1e-10 , 1e-10);
    100100
     
    107107        for(j = 1; j < p; j++)
    108108        {       jfac *= j;
    109                 w     = f.Forward(j, v);       
     109                w     = f.Forward(j, v);
    110110                ok &= NearEqual(jfac*w[0], value, 1e-10 , 1e-10); // d^jz/du^j
    111111                v[0]  = 0.;
     
    114114
    115115        // reverse computation of partials of Taylor coefficients
    116         CPPAD_TESTVECTOR(double) r(p); 
     116        CPPAD_TESTVECTOR(double) r(p);
    117117        w[0]  = 1.;
    118118        r     = f.Reverse(p, w);
  • trunk/test_more/add_zero.cpp

    r2506 r3779  
    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
     
    2121
    2222bool AddZero(void)
    23 {       
     23{
    2424        using namespace CppAD;
    2525
  • trunk/test_more/adfun_copy.cpp

    r3519 r3779  
    1 /* $Id$ */
     1// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-10 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
  • trunk/test_more/alloc_openmp.cpp

    r2506 r3779  
    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
     
    4848bool alloc_openmp(void)
    4949{       bool ok = true;
    50        
     50
    5151        int num_threads = NUMBER_THREADS;
    5252
     
    5555                size_t(num_threads), in_parallel, thread_number
    5656        );
    57        
     57
    5858        // Execute the worker function in parallel
    5959        int thread_num;
     
    6262                worker();
    6363// end omp parallel for
    64        
     64
    6565        // now inform CppAD that there is only one thread
    6666        thread_alloc::parallel_setup(1, CPPAD_NULL, CPPAD_NULL);
     
    7070                ok &= thread_all_[thread_num].x[0] == static_cast<double>(thread_num);
    7171
    72                 // test having master thread (thread number zero) 
     72                // test having master thread (thread number zero)
    7373                // free memory that was allocated by thread number thread_num.
    7474                thread_all_[thread_num].x.clear();
  • trunk/test_more/assign.cpp

    r2506 r3779  
    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
     
    2929        // declare independent variables and start tape recording
    3030        CppAD::Independent(x);
    31        
    32         // range space vector 
     31
     32        // range space vector
    3333        size_t m = 3;
    3434        CPPAD_TESTVECTOR(AD<double>) y(m);
     
    3737        // (choose the first independent variable to check a special case)
    3838        // use the value returned by the assignment (for another assignment)
    39         y[0] = y[1] = x[0]; 
     39        y[0] = y[1] = x[0];
    4040
    41         // assign an AD<Base> object equal to an expression 
     41        // assign an AD<Base> object equal to an expression
    4242        y[1] = x[1] + 1.;
    4343        y[2] = x[2] + 2.;
  • trunk/test_more/atan2.cpp

    r3083 r3779  
    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
     
    4646        // a temporary values
    4747        AD<double> x = cos(U[0]);
    48         AD<double> y = sin(U[0]); 
     48        AD<double> y = sin(U[0]);
    4949
    50         // dependent variable vector 
     50        // dependent variable vector
    5151        CPPAD_TESTVECTOR(AD<double>) Z(1);
    52         Z[0] = atan2(y, x); 
     52        Z[0] = atan2(y, x);
    5353
    5454        // create f: U -> Z and vectors used for derivative calculations
    55         ADFun<double> f(U, Z); 
     55        ADFun<double> f(U, Z);
    5656        CPPAD_TESTVECTOR(double) v(1);
    5757        CPPAD_TESTVECTOR(double) w(1);
     
    8383        for(j = 1; j < p; j++)
    8484        {       jfac *= j;
    85                 w     = f.Forward(j, v);       
     85                w     = f.Forward(j, v);
    8686                ok &= NearEqual(jfac*w[0], value, 1e-10 , 1e-10); // d^jz/du^j
    8787                v[0]  = 0.;
     
    9090
    9191        // reverse computation of partials of Taylor coefficients
    92         CPPAD_TESTVECTOR(double) r(p); 
     92        CPPAD_TESTVECTOR(double) r(p);
    9393        w[0]  = 1.;
    9494        r     = f.Reverse(p, w);
  • trunk/test_more/base_adolc.cpp

    r2794 r3779  
    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
     
    1414# include <adolc/interfaces.h>
    1515
    16 // adouble definitions not in Adolc distribution and 
     16// adouble definitions not in Adolc distribution and
    1717// required in order to use CppAD::AD<adouble>
    1818# include <cppad/example/base_adolc.hpp>
     
    2020# include <cppad/cppad.hpp>
    2121
    22 bool base_adolc(void) 
     22bool base_adolc(void)
    2323{       bool ok = true;                   // initialize test result
    2424
     
    4040                aa_x[j] = a_x[j];          // track how aa_x depends on a_x
    4141        CppAD::Independent(aa_x);          // aa_x is independent for ADDdouble
    42          
     42
    4343
    4444        // compute function
  • trunk/test_more/base_alloc.cpp

    r2506 r3779  
    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
     
    3030        for(i = 0; i < N; i++)
    3131                a_y[0] += double(i);
    32                
     32
    3333        CppAD::ADFun<base_alloc> f(a_x, a_y);
    3434
  • trunk/test_more/check_simple_vector.cpp

    r2506 r3779  
    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
     
    2020        void Case(const Scalar& x, const Scalar& y)
    2121        {       using CppAD::CheckSimpleVector;
    22        
     22
    2323                CheckSimpleVector<Scalar, CppAD::vector<Scalar> > (x, y);
    2424                CheckSimpleVector<Scalar, std::vector<Scalar>   > (x, y);
  • trunk/test_more/compare.cpp

    r2506 r3779  
    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
     
    1616# include <cppad/cppad.hpp>
    1717
    18 namespace { 
     18namespace {
    1919        template <class Type>
    2020        bool Compare(void)
    2121        {       bool ok = true;
    2222                using CppAD::AD;
    23        
     23
    2424                Type      middle = 4;
    2525                AD<double> three = 3;
    2626                AD<double> four  = 4;
    2727                AD<double> five  = 5;
    28        
     28
    2929                // AD<double> > Type
    30                 ok &= ! (three  >  middle);   
    31                 ok &= ! (four   >  middle);   
    32                 ok &=   (five   >  middle);   
    33                 // Type > AD<double> 
    34                 ok &=   (middle >  three );   
    35                 ok &= ! (middle >  four  );   
    36                 ok &= ! (middle >  five  );   
    37        
     30                ok &= ! (three  >  middle);
     31                ok &= ! (four   >  middle);
     32                ok &=   (five   >  middle);
     33                // Type > AD<double>
     34                ok &=   (middle >  three );
     35                ok &= ! (middle >  four  );
     36                ok &= ! (middle >  five  );
     37
    3838                // AD<double> >= Type
    39                 ok &= ! (three  >= middle);   
    40                 ok &=   (four   >= middle);   
    41                 ok &=   (five   >= middle);   
    42                 // Type > AD<double> 
    43                 ok &=   (middle >= three );   
    44                 ok &=   (middle >= four  );   
    45                 ok &= ! (middle >= five  );   
    46        
     39                ok &= ! (three  >= middle);
     40                ok &=   (four   >= middle);
     41                ok &=   (five   >= middle);
     42                // Type > AD<double>
     43                ok &=   (middle >= three );
     44                ok &=   (middle >= four  );
     45                ok &= ! (middle >= five  );
     46
    4747                // AD<double> < Type
    48                 ok &=   (three  <  middle);   
    49                 ok &= ! (four   <  middle);   
    50                 ok &= ! (five   <  middle);   
    51                 // Type > AD<double> 
    52                 ok &= ! (middle <  three );   
    53                 ok &= ! (middle <  four  );   
    54                 ok &=   (middle <  five  );   
    55        
     48                ok &=   (three  <  middle);
     49                ok &= ! (four   <  middle);
     50                ok &= ! (five   <  middle);
     51                // Type > AD<double>
     52                ok &= ! (middle <  three );
     53                ok &= ! (middle <  four  );
     54                ok &=   (middle <  five  );
     55
    5656                // AD<double> <= Type
    57                 ok &=   (three  <= middle);   
    58                 ok &=   (four   <= middle);   
    59                 ok &= ! (five   <= middle);   
    60                 // Type > AD<double> 
    61                 ok &= ! (middle <= three );   
    62                 ok &=   (middle <= four  );   
    63                 ok &=   (middle <= five  );   
    64        
     57                ok &=   (three  <= middle);
     58                ok &=   (four   <= middle);
     59                ok &= ! (five   <= middle);
     60                // Type > AD<double>
     61                ok &= ! (middle <= three );
     62                ok &=   (middle <= four  );
     63                ok &=   (middle <= five  );
     64
    6565                return ok;
    6666        }
  • trunk/test_more/cond_exp_ad.cpp

    r2506 r3779  
    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
     
    7878        ADFun< ADdouble > fa(Xaa, Yaa);
    7979
    80         // function values 
     80        // function values
    8181        CPPAD_TESTVECTOR( ADdouble ) Ya(m);
    8282        Ya  = fa.Forward(0, Xa);
     
    228228        ADFun< ADdouble > fa(Xaa, Yaa);
    229229
    230         // function values 
     230        // function values
    231231        CPPAD_TESTVECTOR( ADdouble ) Ya(m);
    232232        Ya  = fa.Forward(0, Xa);
  • trunk/test_more/cos.cpp

    r2506 r3779  
    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
     
    2828        Independent(U);
    2929
    30         // dependent variable vector 
     30        // dependent variable vector
    3131        CPPAD_TESTVECTOR(AD<double>) Z(1);
    32         Z[0] = cos(U[0]); 
     32        Z[0] = cos(U[0]);
    3333
    3434        // create f: U -> Z and vectors used for derivative calculations
    35         ADFun<double> f(U, Z); 
     35        ADFun<double> f(U, Z);
    3636        CPPAD_TESTVECTOR(double) v(1);
    3737        CPPAD_TESTVECTOR(double) w(1);
    3838
    39         // check value 
     39        // check value
    4040        double sin_u = sin( Value(U[0]) );
    4141        double cos_u = cos( Value(U[0]) );
     
    4949        v[0]         = 1.;
    5050        for(j = 1; j < p; j++)
    51         {       w     = f.Forward(j, v);       
     51        {       w     = f.Forward(j, v);
    5252
    5353                double value;
     
    6666
    6767        // reverse computation of partials of Taylor coefficients
    68         CPPAD_TESTVECTOR(double) r(p); 
     68        CPPAD_TESTVECTOR(double) r(p);
    6969        w[0]  = 1.;
    7070        r     = f.Reverse(p, w);
  • trunk/test_more/cosh.cpp

    r2506 r3779  
    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
     
    2828        Independent(U);
    2929
    30         // dependent variable vector 
     30        // dependent variable vector
    3131        CPPAD_TESTVECTOR(AD<double>) Z(1);
    32         Z[0] = cosh(U[0]); 
     32        Z[0] = cosh(U[0]);
    3333
    3434        // create f: U -> Z and vectors used for derivative calculations
    35         ADFun<double> f(U, Z); 
     35        ADFun<double> f(U, Z);
    3636        CPPAD_TESTVECTOR(double) v(1);
    3737        CPPAD_TESTVECTOR(double) w(1);
    3838
    39         // check value 
     39        // check value
    4040        double sinh_u = sinh( Value(U[0]) );
    4141        double cosh_u = cosh( Value(U[0]) );
     
    4949        v[0]         = 1.;
    5050        for(j = 1; j < p; j++)
    51         {       w     = f.Forward(j, v);       
     51        {       w     = f.Forward(j, v);
    5252
    5353                double value;
     
    6262
    6363        // reverse computation of partials of Taylor coefficients
    64         CPPAD_TESTVECTOR(double) r(p); 
     64        CPPAD_TESTVECTOR(double) r(p);
    6565        w[0]  = 1.;
    6666        r     = f.Reverse(p, w);
  • trunk/test_more/dbl_epsilon.cpp

    r2506 r3779  
    1 /* $Id$ */
     1// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-08 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
     
    1212
    1313/*
    14 Check the value of machine epsilon is accurate enough for the correctness tests 
     14Check the value of machine epsilon is accurate enough for the correctness tests
    1515*/
    1616
  • trunk/test_more/div_zero_one.cpp

    r2506 r3779  
    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
     
    2121
    2222bool DivZeroOne(void)
    23 {       
     23{
    2424        using namespace CppAD;
    2525
  • trunk/test_more/exp.cpp

    r2506 r3779  
    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
     
    6060        ok &= NearEqual(v[s], Z[y] * Z[x],     1e-10 , 1e-10); // dy/ds
    6161
    62         // forward computation of second partials w.r.t s 
     62        // forward computation of second partials w.r.t s
    6363        v[s] = 1.;
    6464        w    = f.Forward(1, v);
     
    6666        w    = f.Forward(2, v);
    6767        ok &= NearEqual(       // d^2 y / (ds ds)
    68                 2. * w[y] , 
     68                2. * w[y] ,
    6969                Z[y] * Z[x] * Z[x] + Z[y] * Z[x],
    7070                1e-10 ,
    71                 1e-10 
    72         ); 
     71                1e-10
     72        );
    7373
    7474        // reverse computation of second partials of y
     
    7878        r    = f.Reverse(2, w);
    7979        ok &= NearEqual(      // d^2 y / (ds ds)
    80                 r[2 * s + 1] , 
     80                r[2 * s + 1] ,
    8181                Z[y] * Z[x] * Z[x] + Z[y] * Z[x],
    8282                1e-10 ,
    83                 1e-10 
    84         ); 
     83                1e-10
     84        );
    8585
    8686        return ok;
     
    9797        Independent(U);
    9898
    99         // dependent variable vector 
     99        // dependent variable vector
    100100        CPPAD_TESTVECTOR(AD<double>) Z(1);
    101         Z[0] = exp(U[0]); 
     101        Z[0] = exp(U[0]);
    102102
    103103        // create f: U -> Z and vectors used for derivative calculations
    104         ADFun<double> f(U, Z); 
     104        ADFun<double> f(U, Z);
    105105        CPPAD_TESTVECTOR(double) v(1);
    106106        CPPAD_TESTVECTOR(double) w(1);
    107107
    108         // check value 
     108        // check value
    109109        double exp_u = exp( Value(U[0]) );
    110110        ok &= NearEqual(exp_u, Value(Z[0]),  1e-10 , 1e-10);
     
    116116        v[0]         = 1.;
    117117        for(j = 1; j < p; j++)
    118         {       w     = f.Forward(j, v);       
     118        {       w     = f.Forward(j, v);
    119119                jfac *= j;
    120120                ok &= NearEqual(jfac*w[0], exp_u, 1e-10 , 1e-10); // d^jz/du^j
     
    123123
    124124        // reverse computation of partials of Taylor coefficients
    125         CPPAD_TESTVECTOR(double) r(p); 
     125        CPPAD_TESTVECTOR(double) r(p);
    126126        w[0]  = 1.;
    127127        r     = f.Reverse(p, w);
     
    140140{       bool ok = true;
    141141        ok &= ExpTestOne();
    142         ok &= ExpTestTwo(); 
     142        ok &= ExpTestTwo();
    143143        return ok;
    144144}
  • trunk/test_more/extern_value.cpp

    r2756 r3779  
    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
     
    1616# define INSTANTIATE(Type) template class extern_value< Type >
    1717
    18 template <class Type> 
     18template <class Type>
    1919extern_value<Type>::extern_value(Type value)
    2020{       value_ = value; }
    2121
    22 template <class Type> 
     22template <class Type>
    2323void extern_value<Type>::set(Type value)
    2424{       value_ = value; }
    2525
    26 template <class Type> 
     26template <class Type>
    2727Type extern_value<Type>::get(void)
    2828{       return value_; }
  • trunk/test_more/for_hess.cpp

    r2506 r3779  
    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
     
    3939        CPPAD_TESTVECTOR(AD<double>) Y(2);
    4040        Y[0] = U[0] * exp( U[1] );
    41         Y[1] = U[1] * sin( U[2] ); 
     41        Y[1] = U[1] * sin( U[2] );
    4242
    4343        // create the function y = F(u)
    4444        ADFun<double> F(U, Y);
    4545
    46         // formulas for the upper triangle of Hessian of F_0 
     46        // formulas for the upper triangle of Hessian of F_0
    4747        CPPAD_TESTVECTOR(double) H0(9);
    4848        H0[0] = 0.;                    // d^2 y[0] / d_u[0] d_u[0]
     
    8888                        CPPAD_TESTVECTOR(double) Cij = F.Forward(2, u2);
    8989
    90                         // diagonal of Hessian in j-th coordinate direction 
     90                        // diagonal of Hessian in j-th coordinate direction
    9191                        u1[i] = 0.;
    9292                        F.Forward(1, u1);
  • trunk/test_more/for_sparse_jac.cpp

    r2859 r3779  
    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
     
    7676
    7777        // dimension of the domain space
    78         size_t n = 3; 
     78        size_t n = 3;
    7979
    8080        // dimension of the range space
    8181        size_t m = (4 + 11 + 1) * 3 + 4;
    8282
    83         // independent variable vector 
     83        // independent variable vector
    8484        CPPAD_TESTVECTOR(AD<double>) X(n);
    85         X[0] = .1; 
     85        X[0] = .1;
    8686        X[1] = .2;
    8787        X[2] = .3;
     
    167167        {       for(j = 0; j < n; j++)
    168168                        ok &= (Py[i * n + j] == Check[i * n + j]);
    169         }       
     169        }
    170170
    171171        // ---------------------------------------------------------
     
    188188                        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
     
    275275        {       for(j = 0; j < n; j++)
    276276                        ok &= (Py[i * n + j] == Check[i * n + j]);
    277         }       
     277        }
    278278
    279279        // ---------------------------------------------------------
     
    296296                        ok &= (found == Check[i * n + j]);
    297297                }
    298         }       
     298        }
    299299
    300300        return ok;
     
    306306
    307307        // dimension of the domain space
    308         size_t n = 2; 
     308        size_t n = 2;
    309309
    310310        // dimension of the range space
    311311        size_t m = 3;
    312312
    313         // independent variable vector 
     313        // independent variable vector
    314314        CPPAD_TESTVECTOR(AD<double>) X(n);
    315         X[0] = 2.; 
     315        X[0] = 2.;
    316316        X[1] = 3.;
    317317        Independent(X);
     
    368368        {       for(j = 0; j < n; j++)
    369369                        ok &= (Py[i * n + j] == Check[i * n + j]);
    370         }       
     370        }
    371371
    372372        // ---------------------------------------------------------
    373         // dependency matrix for the identity function 
     373        // dependency matrix for the identity function
    374374        CPPAD_TESTVECTOR(std::set<size_t>) Sx(n);
    375375        for(i = 0; i < n; i++)
     
    389389                        ok &= (found == Check[i * n + j]);
    390390                }
    391         }       
     391        }
    392392
    393393        return ok;
     
    399399
    400400        // dimension of the domain space
    401         size_t n = 2; 
     401        size_t n = 2;
    402402
    403403        // dimension of the range space
    404404        size_t m = 3;
    405405
    406         // independent variable vector 
     406        // independent variable vector
    407407        CPPAD_TESTVECTOR(AD<double>) X(n);
    408         X[0] = 2.; 
     408        X[0] = 2.;
    409409        X[1] = 3.;
    410410        Independent(X);
     
    462462        {       for(j = 0; j < n; j++)
    463463                        ok &= (Py[j * m + i] == Check[i * n + j]);
    464         }       
     464        }
    465465
    466466        // ---------------------------------------------------------
    467         // dependency matrix for the identity function 
     467        // dependency matrix for the identity function
    468468        CPPAD_TESTVECTOR(std::set<size_t>) Sx(n);
    469469        for(i = 0; i < n; i++)
     
    483483                        ok &= (found == Check[i * n + j]);
    484484                }
    485         }       
     485        }
    486486
    487487        return ok;
  • trunk/test_more/forward_order.cpp

    r3214 r3779  
    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
     
    8989        CPPAD_TESTVECTOR(double) x(n), x_p(n * p1), y_p(m * p1);
    9090        for(j = 0; j < n; j++)
    91         {       x[j]            = double(j) / double(n); 
     91        {       x[j]            = double(j) / double(n);
    9292                x_p[j * p1 + 0] = x[j]; // order 0
    9393                x_p[j * p1 + 1] = 1.;   // order 1
  • trunk/test_more/from_base.cpp

    r2506 r3779  
    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
     
    2222        using namespace CppAD;
    2323
    24         // construct directly form Base where Base = double 
    25         AD<double> x(1.); 
     24        // construct directly form Base where Base = double
     25        AD<double> x(1.);
    2626        AD<double> y = 2.;
    2727
    28         // construct from a type that can be converted to Base 
     28        // construct from a type that can be converted to Base
    2929        // where Base = AD<double>
    30         AD< AD<double> > X(1.); 
     30        AD< AD<double> > X(1.);
    3131        AD< AD<double> > Y(2);
    3232
  • trunk/test_more/fun_check.cpp

    r3214 r3779  
    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
     
    3333                for(i = 0; i < n; i++)
    3434                {       // This operaiton sequence depends on x
    35                         if( x[i] >= 0 ) 
     35                        if( x[i] >= 0 )
    3636                                y[i] = exp(x[i]);
    3737                        else    y[i] = exp(-x[i]);
    3838                }
    3939                return y;
    40         }       
     40        }
    4141};
    4242// template function FunCheckCases<Vector, ADVector> in empty namespace
     
    7575        Fun<double, Vector> g(n);
    7676
    77         // function values should agree when the independent variable 
     77        // function values should agree when the independent variable
    7878        // values are the same as during recording
    7979        Vector x(n);
     
    8181        for(j = 0; j < n; j++)
    8282                x[j] = Value(X[j]);
    83         double r = 1e-10; 
     83        double r = 1e-10;
    8484        double a = 1e-10;
    8585        ok      &= FunCheck(f, g, x, a, r);
     
    106106        return ok;
    107107}
    108 } // End empty namespace 
     108} // End empty namespace
    109109# include <vector>
    110110# include <valarray>
     
    118118        typedef std::valarray< CppAD::AD<double> > ADVector3;
    119119        // Run with Vector and ADVector equal to three different cases
    120         // all of which are Simple Vectors with elements of type 
     120        // all of which are Simple Vectors with elements of type
    121121        // double and AD<double> respectively.
    122122        ok &= FunCheckCases< Vector1, ADVector2 >();
  • trunk/test_more/jacobian.cpp

    r2506 r3779  
    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
     
    4545
    4646
    47 } // End empty namespace 
     47} // End empty namespace
    4848
    4949bool jacobian(void)
     
    7474                ok &= CppAD::NearEqual(jac_g[k], check[k], 1e-10, 1e-10);
    7575
    76         // one argument sparse jacobian 
     76        // one argument sparse jacobian
    7777        jac_g = fun_g.SparseJacobian(x);
    7878        for(k = 0; k < m *n; k++)
  • trunk/test_more/mul.cpp

    r2506 r3779  
    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
     
    4646        Z[x] = U[s] * U[t];   // AD<double> * AD<double>
    4747        Z[y] = Z[x] * 4.;     // AD<double> *    double
    48         Z[z] = 4.   * Z[y];   //    double  * AD<double> 
     48        Z[z] = 4.   * Z[y];   //    double  * AD<double>
    4949        Z[u] =  one * Z[z];   // multiplication by parameter equal to one
    5050        Z[v] = zero * Z[z];   // multiplication by parameter equal to zero
     
    7272        q[t] = 0.;
    7373        r    = f.Forward(1, q);
    74         ok &= ( r[x] == U[t] );           // dx/ds     
     74        ok &= ( r[x] == U[t] );           // dx/ds
    7575        ok &= ( r[y] == U[t] * 4. );      // dy/ds
    7676        ok &= ( r[z] == 4. * U[t] * 4. ); // dz/ds
     
    107107        AD<double> a = U[0] * 1.; // AD<double> * double
    108108        AD<double> b = a  * 2;    // AD<double> * int
    109         AD<double> c = 3. * b;    // double     * AD<double> 
    110         AD<double> d = 4  * c;    // int        * AD<double> 
     109        AD<double> c = 3. * b;    // double     * AD<double>
     110        AD<double> d = 4  * c;    // int        * AD<double>
    111111
    112         // dependent variable vector 
     112        // dependent variable vector
    113113        CPPAD_TESTVECTOR(AD<double>) Z(1);
    114114        Z[0] = U[0] * d;          // AD<double> * AD<double>
    115115
    116116        // create f: U -> Z and vectors used for derivative calculations
    117         ADFun<double> f(U, Z); 
     117        ADFun<double> f(U, Z);
    118118        CPPAD_TESTVECTOR(double) v(1);
    119119        CPPAD_TESTVECTOR(double) w(1);
    120120
    121         // check value 
     121        // check value
    122122        ok &= NearEqual(Value(Z[0]) , u0*4*3*2*u0,  1e-10 , 1e-10);
    123123
     
    136136
    137137                jfac *= j;
    138                 w     = f.Forward(j, v);       
     138                w     = f.Forward(j, v);
    139139                ok &= NearEqual(jfac*w[0], value, 1e-10 , 1e-10); // d^jz/du^j
    140140                v[0]  = 0.;
     
    142142
    143143        // reverse computation of partials of Taylor coefficients
    144         CPPAD_TESTVECTOR(double) r(p); 
     144        CPPAD_TESTVECTOR(double) r(p);
    145145        w[0]  = 1.;
    146146        r     = f.Reverse(p, w);
     
    166166{       bool ok = true;
    167167        ok &= MulTestOne();
    168         ok &= MulTestTwo(); 
     168        ok &= MulTestTwo();
    169169        return ok;
    170170}
  • trunk/test_more/mul_eq.cpp

    r2506 r3779  
    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
     
    8888        double u0 = .5;
    8989        CPPAD_TESTVECTOR(AD<double>) U(1);
    90         U[0]      = u0; 
     90        U[0]      = u0;
    9191        Independent(U);
    9292
    93         // dependent variable vector 
     93        // dependent variable vector
    9494        CPPAD_TESTVECTOR(AD<double>) Z(1);
    9595        Z[0] = U[0];       // initial value
    9696        Z[0] *= 2;         // AD<double> *= int
    9797        Z[0] *= 4.;        // AD<double> *= double
    98         Z[0] *= U[0];      // AD<double> *= AD<double> 
     98        Z[0] *= U[0];      // AD<double> *= AD<double>
    9999
    100100        // create f: U -> Z and vectors used for derivative calculations
    101         ADFun<double> f(U, Z); 
     101        ADFun<double> f(U, Z);
    102102        CPPAD_TESTVECTOR(double) v(1);
    103103        CPPAD_TESTVECTOR(double) w(1);
    104104
    105         // check value 
     105        // check value
    106106        ok &= NearEqual(Z[0] , u0*2*4*u0,  1e-10 , 1e-10);
    107107
     
    120120
    121121                jfac *= j;
    122                 w     = f.Forward(j, v);       
     122                w     = f.Forward(j, v);
    123123                ok &= NearEqual(jfac*w[0], value, 1e-10 , 1e-10); // d^jz/du^j
    124124                v[0]  = 0.;
     
    126126
    127127        // reverse computation of partials of Taylor coefficients
    128         CPPAD_TESTVECTOR(double) r(p); 
     128        CPPAD_TESTVECTOR(double) r(p);
    129129        w[0]  = 1.;
    130130        r     = f.Reverse(p, w);
     
    150150{       bool ok = true;
    151151        ok &= MulEqTestOne();
    152         ok &= MulEqTestTwo(); 
     152        ok &= MulEqTestTwo();
    153153        return ok;
    154154}
  • trunk/test_more/mul_level.cpp

    r3071 r3779  
    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
     
    1616# include <adolc/taping.h>
    1717# include <adolc/interfaces.h>
    18 // adouble definitions not in Adolc distribution and 
     18// adouble definitions not in Adolc distribution and
    1919// required in order to use CppAD::AD<adouble>
    2020# include <cppad/example/base_adolc.hpp>
     
    2626namespace { // BEGIN empty namespace
    2727
    28 bool One(void) 
     28bool One(void)
    2929{       bool ok = true;                          // initialize test result
    3030        using CppAD::NearEqual;
     
    9595
    9696        // check computed assignment AD< AD<double> > -= int
    97         sum -= 1; 
    98 
    99         // check double * AD< AD<double> > 
     97        sum -= 1;
     98
     99        // check double * AD< AD<double> >
    100100        return .5 * sum;
    101 } 
    102 
    103 bool Two(void) 
     101}
     102
     103bool Two(void)
    104104{       bool ok = true;                          // initialize test result
    105105
     
    128128        CppAD::ADFun<ADdouble> a_F(aa_x, aa_f);
    129129
    130         // compute f'(x) 
     130        // compute f'(x)
    131131        size_t p = 1;                        // order of derivative of a_F
    132132        CPPAD_TESTVECTOR(ADdouble) a_w(1);  // weight vector for a_F
     
    156156# ifdef CPPAD_ADOLC_TEST
    157157
    158 bool adolc(void) 
     158bool adolc(void)
    159159{       bool ok = true;                   // initialize test result
    160160
     
    187187        CppAD::ADFun<ADdouble> a_F(aa_x, aa_f);
    188188
    189         // compute f'(x) 
     189        // compute f'(x)
    190190        size_t p = 1;                        // order of derivative of a_F
    191191        CPPAD_TESTVECTOR(ADdouble) a_w(1);  // weight vector for a_F
     
    194194        a_df   = a_F.Reverse(p, a_w);        // gradient of f
    195195
    196         // declare outter function 
     196        // declare outter function
    197197        // (corresponding to the tape of adouble operations)
    198198        double df_j;
     
    252252        ADFun<double> g(ax, ay);
    253253
    254         // evaluate h(x) = g(x) 
     254        // evaluate h(x) = g(x)
    255255        x[0] = 1.;
    256256        y = g.Forward(0, x);
  • trunk/test_more/mul_zero_one.cpp

    r2506 r3779  
    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
     
    2121
    2222bool MulZeroOne(void)
    23 {       
     23{
    2424        using namespace CppAD;
    2525
  • trunk/test_more/near_equal_ext.cpp

    r2506 r3779  
    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
     
    2323        using CppAD::NearEqual;
    2424
    25         // double 
     25        // double
    2626        double x    = 1.00000;
    2727        double y    = 1.00001;
    2828        double a    =  .00005;
    2929        double r    =  .00005;
    30         double zero = 0.; 
     30        double zero = 0.;
    3131        double inf  = 1. / zero;
    3232        double nan  = 0. / zero;
    3333
    34         // AD<double> 
     34        // AD<double>
    3535        AD<double> X(x);
    3636        AD<double> Y(y);
  • trunk/test_more/neg.cpp

    r2506 r3779  
    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
     
    3636
    3737        // dependent variable values
    38         Z[x] = - U[t];   //  - AD<double> 
     38        Z[x] = - U[t];   //  - AD<double>
    3939
    4040        // create f: U -> Z and vectors used for derivative calculations
     
    6464        ok &= ( r[2 * s + 1] == 0. );  // d^2 x / (ds ds)
    6565        ok &= ( r[2 * t + 1] == 0. );  // d^2 x / (ds dt)
    66          
     66
    6767        return ok;
    6868}
  • trunk/test_more/parameter.cpp

    r2506 r3779  
    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
     
    3232        CPPAD_TESTVECTOR(AD<Float>) ax(n);
    3333        for(j = 0; j < n; j++)
    34                 ax[j] = Float(j); 
     34                ax[j] = Float(j);
    3535        Independent(ax);
    3636
     
    3939        CPPAD_TESTVECTOR(AD<Float>) ay(m);
    4040        for(i = 0; i < m; i++)
    41         {       // must avoid Float(k) = 0 because it would get optimized out   
    42                 size_t k = (i % n_parameter); 
     41        {       // must avoid Float(k) = 0 because it would get optimized out
     42                size_t k = (i % n_parameter);
    4343                k        = k * k * 10 + 1;
    4444                j        = i;
     
    4646        }
    4747
    48         // create f: ax -> ay 
     48        // create f: ax -> ay
    4949        ADFun<Float> f(ax, ay);
    5050
     
    5959{       bool ok = true;
    6060        ok &= test<double>();
    61         ok &= test<float>(); 
     61        ok &= test<float>();
    6262        return ok;
    6363}
  • trunk/test_more/poly.cpp

    r2506 r3779  
    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
     
    4343        Independent(Z);                       // declare independent variable
    4444
    45         // dependent variables 
     45        // dependent variables
    4646        CPPAD_TESTVECTOR(AD<double>) P(1); // one dependent variable
    4747        P[0]     = Poly(0, A, Z[0]);    // value of polynomial at Z[0]
    4848
    49         // define f : Z -> P as a function mapping independent to dependent 
     49        // define f : Z -> P as a function mapping independent to dependent
    5050        ADFun<double> f(Z, P);          // ADFun corresponding to polynomial
    5151
  • trunk/test_more/pow.cpp

    r2506 r3779  
    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
     
    3535        CppAD::Independent(XY);
    3636
    37         // range space vector 
     37        // range space vector
    3838        size_t m = 3;
    3939        CPPAD_TESTVECTOR(AD<double>) Z(m);
     
    4343
    4444        // create f: XY -> Z and stop tape recording
    45         CppAD::ADFun<double> f(XY, Z); 
    46 
    47         // check value 
     45        CppAD::ADFun<double> f(XY, Z);
     46
     47        // check value
    4848        double check = std::pow(x, y);
    4949        size_t i;
     
    153153        ok &= ( w[y] == U[s] * u * Z[y] );               // dy/dt
    154154
    155         // forward computation of second Taylor coefficient w.r.t. t 
     155        // forward computation of second Taylor coefficient w.r.t. t
    156156        v[t] = 1.;
    157157        w    = f.Forward(1, v);
     
    159159        CPPAD_TESTVECTOR(double) f_tt = f.Forward(2, v);
    160160
    161         // forward computation of second Taylor coefficient w.r.t. s 
     161        // forward computation of second Taylor coefficient w.r.t. s
    162162        v[s] = 1.;
    163163        w    = f.Forward(1, v);
     
    165165        CPPAD_TESTVECTOR(double) f_ss = f.Forward(2, v);
    166166
    167         // second Taylor coefficient w.r.t. direction r = (s,t) 
     167        // second Taylor coefficient w.r.t. direction r = (s,t)
    168168        v[s] = 1.;
    169169        v[t] = 1.;
     
    175175        // check second order partial of y
    176176        ok &= NearEqual(
    177                 f_rr[y] - f_ss[y] - f_tt[y], 
    178                 (1. + U[s]) * u * Z[y] + 
     177                f_rr[y] - f_ss[y] - f_tt[y],
     178                (1. + U[s]) * u * Z[y] +
    179179                        (1. + U[s]) * U[t] * u * U[s] * u * Z[y],
    180180                1e-10 ,
    181                 1e-10 
    182         ); 
     181                1e-10
     182        );
    183183
    184184        return ok;
     
    199199        CppAD::Independent(x);
    200200
    201         // range space vector 
     201        // range space vector
    202202        size_t m = 4;
    203203        CPPAD_TESTVECTOR(AD<double>) y(m);
     
    210210
    211211        // create f: x -> y and stop tape recording
    212         CppAD::ADFun<double> f(x, y); 
     212        CppAD::ADFun<double> f(x, y);
    213213
    214214        // check function values
     
    228228        ok   &= (dy[3] == 0.);
    229229
    230         // reverse mode computation of derivative of y[0]+y[1]+y[2]+y[3] 
     230        // reverse mode computation of derivative of y[0]+y[1]+y[2]+y[3]
    231231        CPPAD_TESTVECTOR(double)  w(m);
    232232        CPPAD_TESTVECTOR(double) dw(n);
     
    238238        ok  &= NearEqual(dw[0], 1., 1e-10, 1e-10);
    239239
    240         return ok;     
     240        return ok;
    241241}
    242242
     
    256256        CppAD::Independent(x);
    257257
    258         // range space vector 
     258        // range space vector
    259259        size_t m = 5;
    260260        CPPAD_TESTVECTOR(AD<double>) y(m);
     
    263263        y[0] = pow(1., x[0]);
    264264        size_t i;
    265         for(i = 1; i < m; i++) 
     265        for(i = 1; i < m; i++)
    266266                y[i] = pow(x[0], i-1);   // pow(AD<double>, int)
    267267
    268268        // create f: x -> y and stop tape recording
    269         CppAD::ADFun<double> f(x, y); 
     269        CppAD::ADFun<double> f(x, y);
    270270
    271271        ok  &= (Value(y[0]) == 1.);
     
    299299        ok  &= NearEqual(dw[0], sum, 1e-10, 1e-10);
    300300
    301         return ok;     
     301        return ok;
    302302}
    303303bool PowTestFive(void)
     
    316316        CppAD::Independent(x);
    317317
    318         // range space vector 
     318        // range space vector
    319319        size_t m = 1;
    320320        CPPAD_TESTVECTOR(AD<double>) y(m);
     
    325325
    326326        // create f: x -> y and stop tape recording
    327         CppAD::ADFun<double> f(x, y); 
     327        CppAD::ADFun<double> f(x, y);
    328328
    329329        // check function value
     
    338338        ok   &= NearEqual(dy[0], d1, 1e-10, 1e-10);
    339339
    340         // reverse mode computation of second partials 
     340        // reverse mode computation of second partials
    341341        // x.r.t. x[1],x[0]  and x[1], x[1]
    342342        double d2 = e * (e-1) * pow(x0, (e-2));
     
    348348        ok  &= NearEqual(ddw[1], d2, 1e-10, 1e-10);
    349349
    350         return ok;     
     350        return ok;
    351351}
    352352bool PowTestSix(void)
     
    369369        CppAD::Independent(X);
    370370
    371         // range space vector 
     371        // range space vector
    372372        size_t m = 1;
    373373        CPPAD_TESTVECTOR(AD< AD<double> >) Y(m);
     
    375375        // case of AD< AD<double> > raised to a double power
    376376        double e = 2.5;
    377         Y[0] = pow(X[0], e); 
     377        Y[0] = pow(X[0], e);
    378378
    379379        // create F: X -> Y and stop tape recording
    380         CppAD::ADFun< AD<double> > F(X, Y); 
     380        CppAD::ADFun< AD<double> > F(X, Y);
    381381
    382382        // check function value
     
    391391        ok   &= NearEqual(dy[0], d1, 1e-10, 1e-10);
    392392
    393         // reverse mode computation of second partials 
     393        // reverse mode computation of second partials
    394394        // x.r.t. x[1],x[0]  and x[1], x[1]
    395395        double d2 = e * (e-1) * pow(x0, (e-2));
     
    401401        ok  &= NearEqual(ddw[1], d2, 1e-10, 1e-10);
    402402
    403         return ok;     
     403        return ok;
    404404}
    405405
    406406} // END empty namespace
    407  
     407
    408408bool Pow(void)
    409409{       bool ok = true;
  • trunk/test_more/pow_int.cpp

    r2506 r3779  
    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
     
    5353        ok &= NearEqual(Z[1] , exp( - log(u) * 5.),            1e-10 , 1e-10);
    5454
    55         // forward computation of partials 
     55        // forward computation of partials
    5656        v[0] = 1.;
    5757        w = f.Forward(1, v);
  • trunk/test_more/print_for.cpp

    r2506 r3779  
    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
     
    1414# include <cppad/cppad.hpp>
    1515
    16 namespace { 
     16namespace {
    1717        using std::endl;
    1818        using CppAD::AD;
     
    2727
    2828                return log(y);
    29         } 
     29        }
    3030}
    3131
     
    4747        AD<double> Zero(0);
    4848        av[Zero] = 0.;
    49         PrintFor("v[0] = ", av[Zero]); 
     49        PrintFor("v[0] = ", av[Zero]);
    5050        string_check += "v[0] = 0"; // v[0] == 0 during Forward(0, x)
    5151
    5252        // Print a newline to separate this from previous output,
    5353        // then print an AD<double> object that is a variable.
    54         PrintFor("\nv[0] + x[0] = ", av[0] + ax[0]); 
    55         string_check += "\nv[0] + x[0] = 2"; // x[0] == 2 during Forward(0, x) 
     54        PrintFor("\nv[0] + x[0] = ", av[0] + ax[0]);
     55        string_check += "\nv[0] + x[0] = 2"; // x[0] == 2 during Forward(0, x)
    5656
    5757        // A conditional print that will not generate output when x[0] = 2.
     
    6767        string_check += "check_log: y == 0 which is <= 0\n";
    6868
    69         // dependent variable vector 
     69        // dependent variable vector
    7070        size_t m = 2;
    7171        CPPAD_TESTVECTOR(AD<double>) ay(m);
     
    7373
    7474        // define f: x -> y and stop tape recording
    75         CppAD::ADFun<double> f(ax, ay); 
     75        CppAD::ADFun<double> f(ax, ay);
    7676
    77         // zero order forward with x[0] = 2 
     77        // zero order forward with x[0] = 2
    7878        CPPAD_TESTVECTOR(double) x(n);
    7979        x[0] = 2.;
    80         f.Forward(0, x, stream_out);   
     80        f.Forward(0, x, stream_out);
    8181
    8282        std::string string_out = stream_out.str();
    83         ok &= string_out == string_check; 
     83        ok &= string_out == string_check;
    8484        return ok;
    8585}
  • trunk/test_more/rev_sparse_hes.cpp

    r2935 r3779  
    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
     
    1313
    1414# include <cppad/cppad.hpp>
    15  
     15
    1616namespace { // Begin empty namespace
    1717
     
    2121
    2222        // dimension of the domain space
    23         size_t n = 10; 
     23        size_t n = 10;
    2424
    2525        // dimension of the range space
     
    3434                Check[j] = false;
    3535
    36         // independent variable vector 
     36        // independent variable vector
    3737        CPPAD_TESTVECTOR(AD<double>) X(n);
    3838        for(j = 0; j < n; j++)
     
    5555        Check[6 * n + 6] = true;
    5656        Check[7 * n + 7] = true;
    57        
     57
    5858        // pow(variable, variable)
    5959        sum += pow(X[8], X[9]);
     
    8383        F.ForSparseJac(n, Px);
    8484
    85         // compute sparsity pattern for Hessian of F_0 ( U(x) ) 
     85        // compute sparsity pattern for Hessian of F_0 ( U(x) )
    8686        CPPAD_TESTVECTOR(bool) Py(m);
    8787        Py[0] = true;
     
    110110        F.ForSparseJac(n, Sx);
    111111
    112         // compute sparsity pattern for Hessian of F_0 ( U(x) ) 
     112        // compute sparsity pattern for Hessian of F_0 ( U(x) )
    113113        CPPAD_TESTVECTOR(std::set<size_t>) Sy(1);
    114114        Sy[0].insert(0);
     
    143143
    144144        // dimension of the domain space
    145         size_t n = 4; 
     145        size_t n = 4;
    146146
    147147        // dimension of the range space
     
    156156                Check[j] = false;
    157157
    158         // independent variable vector 
     158        // independent variable vector
    159159        CPPAD_TESTVECTOR(AD<double>) X(n);
    160160        for(j = 0; j < n; j++)
     
    163163
    164164        // Test the case where dependent variable is a non-linear function
    165         // of the result of a conditional expression. 
     165        // of the result of a conditional expression.
    166166        CPPAD_TESTVECTOR(AD<double>) Y(m);
    167167        Y[0] = CondExpLt(X[0], X[1], X[2], X[3]);
     
    174174        Check[2 * n + 2] = Check[ 2 * n + 3 ] = true;
    175175        Check[3 * n + 2] = Check[ 3 * n + 3 ] = true;
    176        
     176
    177177        // create function object F : X -> Y
    178178        ADFun<double> F(X, Y);
     
    190190        F.ForSparseJac(n, Px);
    191191
    192         // compute sparsity pattern for Hessian of F_0 ( U(x) ) 
     192        // compute sparsity pattern for Hessian of F_0 ( U(x) )
    193193        CPPAD_TESTVECTOR(bool) Py(m);
    194194        Py[0] = true;
     
    209209        F.ForSparseJac(n, Sx);
    210210
    211         // compute sparsity pattern for Hessian of F_0 ( U(x) ) 
     211        // compute sparsity pattern for Hessian of F_0 ( U(x) )
    212212        CPPAD_TESTVECTOR(std::set<size_t>) Sy(1);
    213213        Sy[0].insert(0);
     
    231231
    232232        // domain space vector
    233         size_t n = 1; 
     233        size_t n = 1;
    234234        CPPAD_TESTVECTOR(AD<double>) X(n);
    235         X[0] = 0.; 
     235        X[0] = 0.;
    236236
    237237        // declare independent variables and start recording
     
    282282        f.ForSparseJac(n, Sx);
    283283
    284         // compute sparsity pattern for Hessian of F_0 ( U(x) ) 
     284        // compute sparsity pattern for Hessian of F_0 ( U(x) )
    285285        CPPAD_TESTVECTOR(std::set<size_t>) Sy(1);
    286286        Sy[0].insert(0);
     
    300300
    301301        // dimension of the domain space
    302         size_t n = 3; 
     302        size_t n = 3;
    303303
    304304        // dimension of the range space
     
    311311                Z[k] = 0.;
    312312
    313         // independent variable vector 
     313        // independent variable vector
    314314        CPPAD_TESTVECTOR(AD<double>) X(n);
    315         X[0] = 0.; 
     315        X[0] = 0.;
    316316        X[1] = 1.;
    317317        X[2] = 2.;
     
    321321        // (component indices do not matter because they can change).
    322322        Z[ X[0] ] = X[1] * X[2];
    323         Z[ X[1] ] = 0.; 
     323        Z[ X[1] ] = 0.;
    324324
    325325        // dependent variable vector
     
    367367        {       for(j = 0; j < n; j++)
    368368                        ok &= (h[i * n + j] == Check[i * n + j]);
    369         }       
     369        }
    370370
    371371        // ------------------------------------------------------------------
     
    378378        F.ForSparseJac(n, Sx);
    379379
    380         // compute sparsity pattern for Hessian of F_0 ( U(x) ) 
     380        // compute sparsity pattern for Hessian of F_0 ( U(x) )
    381381        CPPAD_TESTVECTOR(std::set<size_t>) Sy(1);
    382382        Sy[0].insert(0);
     
    401401
    402402        size_t n = 2;
    403         CPPAD_TESTVECTOR(AD<double>) X(n); 
     403        CPPAD_TESTVECTOR(AD<double>) X(n);
    404404        X[0] = 1.;
    405405        X[1] = 2.;
     
    423423        F.ForSparseJac(n, Px);
    424424
    425         // compute sparsity pattern for Hessian of F_k ( U(x) ) 
     425        // compute sparsity pattern for Hessian of F_k ( U(x) )
    426426        CPPAD_TESTVECTOR(bool) Py(m);
    427427        CPPAD_TESTVECTOR(bool) Pxx(n * n);
     
    446446
    447447        // dimension of the domain space
    448         size_t n = 3; 
     448        size_t n = 3;
    449449
    450450        // dimension of the range space
    451451        size_t m = 1;
    452452
    453         // independent variable vector 
     453        // independent variable vector
    454454        CPPAD_TESTVECTOR(AD<double>) X(n);
    455         X[0] = 0.; 
     455        X[0] = 0.;
    456456        X[1] = 1.;
    457457        X[2] = 2.;
     
    513513        {       for(j = 0; j < n; j++)
    514514                        ok &= (h[i * n + j] == Check[i * n + j]);
    515         }       
     515        }
    516516
    517517        // compute the reverse Hessian sparsity pattern for R^T * F^2
     
    523523        {       for(j = 0; j < n; j++)
    524524                        ok &= (h[j * n + i] == Check[i * n + j]);
    525         }       
     525        }
    526526
    527527        return ok;
  • trunk/test_more/reverse.cpp

    r2859 r3779  
    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
     
    2323        using namespace CppAD;
    2424
    25         // independent variable vector 
     25        // independent variable vector
    2626        CPPAD_TESTVECTOR(AD<double>) U(3);
    2727        U[0] = 0.; U[1] = 1.; U[2] = 2.;
     
    3737        }
    3838
    39         // dependent variable vector 
     39        // dependent variable vector
    4040        CPPAD_TESTVECTOR(AD<double>) V(2);
    4141        V[0] = Sum;
     
    6262        // compare values
    6363        for(i = 0; i < 3; i++)
    64         {       ok &= NearEqual(r1[i] , 
     64        {       ok &= NearEqual(r1[i] ,
    6565                        v[0] * g0[i] + v[1] * g1[i], 1e-10, 1e-10);
    6666        }
     
    8686        // check derivative of the zero order term
    8787        for(i = 0; i < 3; i++)
    88         {       ok &= NearEqual(r2[p * i + 0] , 
     88        {       ok &= NearEqual(r2[p * i + 0] ,
    8989                        v[0] * g0[i] + v[1] * g1[i], 1e-10, 1e-10);
    9090        }
    9191
    9292        /*
    93         The j-th component of the first order term is 
     93        The j-th component of the first order term is
    9494                d/dt z_j(0, u0, u1) = f_j^{(1)} (u0) * u1
    9595        We use ei to denote the vector with its i-th component one and all
    9696        the other components zero. The partial derivative of the j-th
    97         component of the first order term with respect u0[i] is 
     97        component of the first order term with respect u0[i] is
    9898                ei * f_j^{(2)} ( u0 ) * u1
    9999        */
     
    122122
    123123// define the template function reverse_any_cases<Vector> in empty namespace
    124 template <typename Vector> 
     124template <typename Vector>
    125125bool reverse_any_cases(void)
    126126{       bool ok = true;
     
    131131        size_t n = 3;
    132132        CPPAD_TESTVECTOR(AD<double>) X(n);
    133         X[0] = 0.; 
     133        X[0] = 0.;
    134134        X[1] = 1.;
    135135        X[2] = 2.;
     
    219219$index composition, example$$
    220220$index example, composition$$
    221 $index test, composition$$ 
     221$index test, composition$$
    222222
    223223$head Purpose$$
    224 Break a derivative computation into pieces and only store values at the 
     224Break a derivative computation into pieces and only store values at the
    225225interface of the pieces.
    226 In actual applications, there may be many functions, but 
     226In actual applications, there may be many functions, but
    227227for this example there are only two.
    228 The functions 
    229 $latex F : \B{R}^2 \rightarrow \B{R}^2$$ 
     228The functions
     229$latex F : \B{R}^2 \rightarrow \B{R}^2$$
    230230and
    231 $latex G : \B{R}^2 \rightarrow \B{R}^2$$ 
     231$latex G : \B{R}^2 \rightarrow \B{R}^2$$
    232232defined by
    233233$latex \[
    234         F(x) = \left( \begin{array}{c} x_0 x_1   \\ x_1 - x_0 \end{array} \right) 
     234        F(x) = \left( \begin{array}{c} x_0 x_1   \\ x_1 - x_0 \end{array} \right)
    235235        \; , \;
    236         G(y) = \left( \begin{array}{c} y_0 - y_1 \\ y_1  y_0   \end{array} \right) 
     236        G(y) = \left( \begin{array}{c} y_0 - y_1 \\ y_1  y_0   \end{array} \right)
    237237\] $$
    238238Another difference is that in actual applications,
     
    246246$latex \[
    247247\begin{array}{rcl}
    248         H(x) 
    249         & = & G_0 [ F(x) ] + G_1 [ F(x)  ] 
    250         \\
    251         & = & x_0 x_1 - ( x_1 - x_0 ) + x_0 x_1 ( x_1 - x_0 ) 
     248        H(x)
     249        & = & G_0 [ F(x) ] + G_1 [ F(x)  ]
     250        \\
     251        & = & x_0 x_1 - ( x_1 - x_0 ) + x_0 x_1 ( x_1 - x_0 )
    252252        \\
    253253        & = & x_0 x_1 ( 1 - x_0 + x_1 ) - x_1 + x_0
    254254\end{array}
    255 \] $$ 
    256 Given the zero and first order Taylor coefficients 
     255\] $$
     256Given the zero and first order Taylor coefficients
    257257$latex x^{(0)} $$ and $latex x^{(1)}$$,
    258258we use $latex X(t)$$, $latex Y(t)$$ and $latex Z(t)$$
     
    260260$latex \[
    261261\begin{array}{rcl}
    262         X(t) & = & x^{(0)} + x^{(1)} t 
     262        X(t) & = & x^{(0)} + x^{(1)} t
    263263        \\
    264264        Y(t) & = & F[X(t)] = y^{(0)} + y^{(1)} t  + O(t^2)
     
    273273Here are the processing steps:
    274274$list number$$
    275 Use forward mode on $latex F(x)$$ to compute 
    276 $latex y^{(0)}$$ and $latex y^{(1)}$$ 
     275Use forward mode on $latex F(x)$$ to compute
     276$latex y^{(0)}$$ and $latex y^{(1)}$$
    277277$lnext
    278 Use forward mode on $latex G(y)$$ to compute 
    279 $latex z^{(0)}$$ and $latex z^{(1)}$$ 
     278Use forward mode on $latex G(y)$$ to compute
     279$latex z^{(0)}$$ and $latex z^{(1)}$$
    280280$lnext
    281 Use reverse mode on $latex G(y)$$ to compute the derivative of 
     281Use reverse mode on $latex G(y)$$ to compute the derivative of
    282282$latex h^{(k)}$$ with respect to
    283283$latex y^{(0)}$$ and $latex y^{(1)}$$.
     
    389389        w[1*p+0] = 1.; // coefficient for z^0_1
    390390        w[0*p+1] = 0.; // coefficient for z^1_0
    391         w[1*p+1] = 0.; // coefficient for z^1_1 
     391        w[1*p+1] = 0.; // coefficient for z^1_1
    392392        dw       = g.Reverse(p, w);
    393393
    394         // dv^0 = dw^0 * \partial_x^0 y^0 (x) + dw^1 * \partial_x^0 y^1 (x) 
    395         // dv^1 = dw^0 * \partial_x^1 y^0 (x) + dw^1 * \partial_x^1 y^1 (x) 
     394        // dv^0 = dw^0 * \partial_x^0 y^0 (x) + dw^1 * \partial_x^0 y^1 (x)
     395        // dv^1 = dw^0 * \partial_x^1 y^0 (x) + dw^1 * \partial_x^1 y^1 (x)
    396396        CPPAD_TESTVECTOR(double) dv(n*p);
    397         dv   = f.Reverse(p, dw); 
     397        dv   = f.Reverse(p, dw);
    398398
    399399        // check partial of h^0 w.r.t x^0_0
     
    418418        w[1*p+0] = 0.; // coefficient for z^0_1
    419419        w[0*p+1] = 1.; // coefficient for z^1_0
    420         w[1*p+1] = 1.; // coefficient for z^1_1 
     420        w[1*p+1] = 1.; // coefficient for z^1_1
    421421        dw       = g.Reverse(p, w);
    422422
    423         // dv^0 = dw^0 * \partial_x^0 y^0 (x) + dw^1 * \partial_x^0 y^1 (x) 
    424         // dv^1 = dw^0 * \partial_x^1 y^0 (x) + dw^1 * \partial_x^1 y^1 (x) 
    425         dv   = f.Reverse(p, dw); 
     423        // dv^0 = dw^0 * \partial_x^0 y^0 (x) + dw^1 * \partial_x^0 y^1 (x)
     424        // dv^1 = dw^0 * \partial_x^1 y^0 (x) + dw^1 * \partial_x^1 y^1 (x)
     425        dv   = f.Reverse(p, dw);
    426426
    427427        // check partial of h^1 w.r.t x^0_0
     
    433433        // check partial of h^1 w.r.t x^0_1
    434434        check  = x0[0] * (- x1[0] + x1[1]);
    435         check += x1[0] * (1. - x0[0] + x0[1]) + x1[0] * x0[1]; 
     435        check += x1[0] * (1. - x0[0] + x0[1]) + x1[0] * x0[1];
    436436        check += x0[0] * x1[1];
    437437        ok    &= NearEqual(dv[1*p+0], check, eps, eps);
     
    452452}
    453453// ----------------------------------------------------------------------------
    454 } // End empty namespace 
     454} // End empty namespace
    455455
    456456# include <vector>
  • trunk/test_more/rosen_34.cpp

    r2506 r3779  
    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
     
    2424Case where
    2525x[0](0) = 1, x[0]'(t) = - w[0] * x[0](t)
    26 x[1](0) = 1, x[1]'(t) = - w[1] * x[1](t) 
     26x[1](0) = 1, x[1]'(t) = - w[1] * x[1](t)
    2727x[2](0) = 0, x[2]'(t) =   w[2] * t
    2828
     
    4040                }
    4141                void Ode(
    42                         const CppAD::AD<double>                      &t, 
    43                         const CPPAD_TESTVECTOR(CppAD::AD<double>) &x, 
    44                         CPPAD_TESTVECTOR(CppAD::AD<double>)       &f) 
     42                        const CppAD::AD<double>                      &t,
     43                        const CPPAD_TESTVECTOR(CppAD::AD<double>) &x,
     44                        CPPAD_TESTVECTOR(CppAD::AD<double>)       &f)
    4545                {
    4646                        f[0] = - w[0] * x[0];
    4747                        f[1] = - w[1] * x[1];
    4848                        f[2] =   w[2] * t;
    49        
     49
    5050                }
    51        
     51
    5252                void Ode_ind(
    53                         const CppAD::AD<double>                      &t, 
    54                         const CPPAD_TESTVECTOR(CppAD::AD<double>) &x, 
    55                         CPPAD_TESTVECTOR(CppAD::AD<double>)       &f_t) 
     53                        const CppAD::AD<double>                      &t,
     54                        const CPPAD_TESTVECTOR(CppAD::AD<double>) &x,
     55                        CPPAD_TESTVECTOR(CppAD::AD<double>)       &f_t)
    5656                {
    5757                        f_t[0] = 0.;
    5858                        f_t[1] = 0.;
    5959                        f_t[2] = w[2];
    60        
     60
    6161                }
    62        
     62
    6363                void Ode_dep(
    64                         const CppAD::AD<double>                      &t, 
    65                         const CPPAD_TESTVECTOR(CppAD::AD<double>) &x, 
    66                         CPPAD_TESTVECTOR(CppAD::AD<double>)       &f_x) 
     64                        const CppAD::AD<double>                      &t,
     65                        const CPPAD_TESTVECTOR(CppAD::AD<double>) &x,
     66                        CPPAD_TESTVECTOR(CppAD::AD<double>)       &f_x)
    6767                {
    6868                        f_x[0] = - w[0];    f_x[1] = 0.;      f_x[2] = 0.;
    6969                        f_x[3] = 0.;        f_x[4] = - w[1];  f_x[5] = 0.;
    7070                        f_x[6] = 0.;        f_x[7] = 0.;      f_x[8] = 0.;
    71        
     71
    7272                }
    73        
     73
    7474        private:
    7575                CPPAD_TESTVECTOR(CppAD::AD<double>) w;
     
    9797        // construct the function object using the independent variables
    9898        TestFun  fun(w);
    99        
     99
    100100        // initial value of x
    101101        CPPAD_TESTVECTOR(AD<double>) xini(3);
     
    103103        xini[1] = 1.;
    104104        xini[2] = 0.;
    105        
     105
    106106
    107107        // integrate the differential equation
  • trunk/test_more/runge_45.cpp

    r2506 r3779  
    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                void Ode(
    29                         const CppAD::AD<double>                      &t, 
    30                         const CPPAD_TESTVECTOR(CppAD::AD<double>) &x, 
    31                         CPPAD_TESTVECTOR(CppAD::AD<double>)       &f) 
     29                        const CppAD::AD<double>                      &t,
     30                        const CPPAD_TESTVECTOR(CppAD::AD<double>) &x,
     31                        CPPAD_TESTVECTOR(CppAD::AD<double>)       &f)
    3232                {
    3333                        using CppAD::exp;
    34        
     34
    3535                        size_t n = x.size();
    36        
     36
    3737                        size_t i;
    3838                        f[0]  = 0.;
    3939                        for(i = 1; i < n-1; i++)
    4040                                f[i] = w[i] * x[i-1];
    41        
     41
    4242                        f[n-1] = x[0] * x[1];
    4343                }
     
    118118                        if (j == 0 )
    119119                                ok &= NearEqual(q[j], x[i], 1e-14, 1e-14);
    120                         else if( j <= i  ) 
     120                        else if( j <= i  )
    121121                                ok &= NearEqual(
    122122                                        q[j], x[i]/w[j], 1e-14, 1e-14);
     
    136136                if (j == 0 )
    137137                        ok &= NearEqual(q[j], 2.*x[i], 1e-14, 1e-14);
    138                 else if( j == 1  ) 
     138                else if( j == 1  )
    139139                        ok &= NearEqual(
    140140                                q[j], x[i]/w[1], 1e-14, 1e-14);
  • trunk/test_more/sin.cpp

    r2506 r3779  
    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
     
    2828        Independent(U);
    2929
    30         // dependent variable vector 
     30        // dependent variable vector
    3131        CPPAD_TESTVECTOR(AD<double>) Z(1);
    32         Z[0] = sin(U[0]); 
     32        Z[0] = sin(U[0]);
    3333
    3434        // create f: U -> Z and vectors used for derivative calculations
    35         ADFun<double> f(U, Z); 
     35        ADFun<double> f(U, Z);
    3636        CPPAD_TESTVECTOR(double) v(1);
    3737        CPPAD_TESTVECTOR(double) w(1);
    3838
    39         // check value 
     39        // check value
    4040        double sin_u = sin( Value(U[0]) );
    4141        double cos_u = cos( Value(U[0]) );
     
    4949        v[0]         = 1.;
    5050        for(j = 1; j < p; j++)
    51         {       w     = f.Forward(j, v);       
     51        {       w     = f.Forward(j, v);
    5252
    5353                double value;
     
    6666
    6767        // reverse computation of partials of Taylor coefficients
    68         CPPAD_TESTVECTOR(double) r(p); 
     68        CPPAD_TESTVECTOR(double) r(p);
    6969        w[0]  = 1.;
    7070        r     = f.Reverse(p, w);
  • trunk/test_more/sin_cos.cpp

    r2506 r3779  
    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
     
    3535        Independent(X);
    3636
    37         // dependent variable vector 
     37        // dependent variable vector
    3838        CPPAD_TESTVECTOR(AD<double>) Z(1);
    3939        AD<double> U = X[0] * X[1];
    40         Z[0] = sin( U ); 
     40        Z[0] = sin( U );
    4141
    4242        // create f: X -> Z and vectors used for derivative calculations
    4343        // f(x, y) = sin(x, y)
    44         ADFun<double> f(X, Z); 
     44        ADFun<double> f(X, Z);
    4545        CPPAD_TESTVECTOR(double) v( 2 );
    4646        CPPAD_TESTVECTOR(double) w( 1 );
    4747
    48         // check value 
     48        // check value
    4949        double sin_u = sin( Value(U) );
    5050        double cos_u = cos( Value(U) );
     
    6060        double yj    = 1;   // y^j
    6161        for(j = 1; j < p; j++)
    62         {       w      = f.Forward(j, v);       
     62        {       w      = f.Forward(j, v);
    6363
    6464                // compute j-th power of y
     
    7878
    7979                // check j-th derivative of z w.r.t x
    80                 ok &= NearEqual(jfac*w[0], sinj * yj, 1e-10 , 1e-10); 
     80                ok &= NearEqual(jfac*w[0], sinj * yj, 1e-10 , 1e-10);
    8181
    8282                v[0]  = 0.;
     
    8484
    8585        // reverse computation of partials of Taylor coefficients
    86         CPPAD_TESTVECTOR(double) r( 2 * p); 
     86        CPPAD_TESTVECTOR(double) r( 2 * p);
    8787        w[0]  = 1.;
    8888        r     = f.Reverse(p, w);
     
    132132        Independent(X);
    133133
    134         // dependent variable vector 
     134        // dependent variable vector
    135135        CPPAD_TESTVECTOR(AD<double>) Z(1);
    136136        AD<double> U = X[0] * X[1];
    137         Z[0] = cos( U ); 
     137        Z[0] = cos( U );
    138138
    139139        // create f: X -> Z and vectors used for derivative calculations
    140140        // f(x, y) = cos(x, y)
    141         ADFun<double> f(X, Z); 
     141        ADFun<double> f(X, Z);
    142142        CPPAD_TESTVECTOR(double) v( 2 );
    143143        CPPAD_TESTVECTOR(double) w( 1 );
    144144
    145         // check value 
     145        // check value
    146146        double sin_u = sin( Value(U) );
    147147        double cos_u = cos( Value(U) );
     
    157157        double yj    = 1;   // y^j
    158158        for(j = 1; j < p; j++)
    159         {       w      = f.Forward(j, v);       
     159        {       w      = f.Forward(j, v);
    160160
    161161                // compute j-th power of y
     
    175175
    176176                // check j-th derivative of z w.r.t x
    177                 ok &= NearEqual(jfac*w[0], cosj * yj, 1e-10 , 1e-10); 
     177                ok &= NearEqual(jfac*w[0], cosj * yj, 1e-10 , 1e-10);
    178178
    179179                v[0]  = 0.;
     
    181181
    182182        // reverse computation of partials of Taylor coefficients
    183         CPPAD_TESTVECTOR(double) r( 2 * p); 
     183        CPPAD_TESTVECTOR(double) r( 2 * p);
    184184        w[0]  = 1.;
    185185        r     = f.Reverse(p, w);
     
    229229        Independent(X);
    230230
    231         // dependent variable vector 
     231        // dependent variable vector
    232232        CPPAD_TESTVECTOR(AD<double>) Z(1);
    233233        AD<double> U = X[0] * X[1];
    234         Z[0] = cosh( U ); 
     234        Z[0] = cosh( U );
    235235
    236236        // create f: X -> Z and vectors used for derivative calculations
    237237        // f(x, y) = cosh(x, y)
    238         ADFun<double> f(X, Z); 
     238        ADFun<double> f(X, Z);
    239239        CPPAD_TESTVECTOR(double) v( 2 );
    240240        CPPAD_TESTVECTOR(double) w( 1 );
    241241
    242         // check value 
     242        // check value
    243243        double sinh_u = sinh( Value(U) );
    244244        double cosh_u = cosh( Value(U) );
     
    254254        double yj    = 1;   // y^j
    255255        for(j = 1; j < p; j++)
    256         {       w      = f.Forward(j, v);       
     256        {       w      = f.Forward(j, v);
    257257
    258258                // compute j-th power of y
     
    268268
    269269                // check j-th derivative of z w.r.t x
    270                 ok &= NearEqual(jfac*w[0], coshj * yj, 1e-10 , 1e-10); 
     270                ok &= NearEqual(jfac*w[0], coshj * yj, 1e-10 , 1e-10);
    271271
    272272                v[0]  = 0.;
     
    274274
    275275        // reverse computation of partials of Taylor coefficients
    276         CPPAD_TESTVECTOR(double) r( 2 * p); 
     276        CPPAD_TESTVECTOR(double) r( 2 * p);
    277277        w[0]  = 1.;
    278278        r     = f.Reverse(p, w);
     
    318318        Independent(X);
    319319
    320         // dependent variable vector 
     320        // dependent variable vector
    321321        CPPAD_TESTVECTOR(AD<double>) Z(1);
    322322        AD<double> U = X[0] * X[1];
    323         Z[0] = sinh( U ); 
     323        Z[0] = sinh( U );
    324324
    325325        // create f: X -> Z and vectors used for derivative calculations
    326326        // f(x, y) = sinh(x, y)
    327         ADFun<double> f(X, Z); 
     327        ADFun<double> f(X, Z);
    328328        CPPAD_TESTVECTOR(double) v( 2 );
    329329        CPPAD_TESTVECTOR(double) w( 1 );
    330330
    331         // check value 
     331        // check value
    332332        double sinh_u = sinh( Value(U) );
    333333        double cosh_u = cosh( Value(U) );
     
    343343        double yj    = 1;   // y^j
    344344        for(j = 1; j < p; j++)
    345         {       w      = f.Forward(j, v);       
     345        {       w      = f.Forward(j, v);
    346346
    347347                // compute j-th power of y
     
    357357
    358358                // check j-th derivative of z w.r.t x
    359                 ok &= NearEqual(jfac*w[0], sinhj * yj, 1e-10 , 1e-10); 
     359                ok &= NearEqual(jfac*w[0], sinhj * yj, 1e-10 , 1e-10);
    360360
    361361                v[0]  = 0.;
     
    363363
    364364        // reverse computation of partials of Taylor coefficients
    365         CPPAD_TESTVECTOR(double) r( 2 * p); 
     365        CPPAD_TESTVECTOR(double) r( 2 * p);
    366366        w[0]  = 1.;
    367367        r     = f.Reverse(p, w);
     
    398398        return ok;
    399399}
    400        
     400
  • trunk/test_more/sinh.cpp

    r2506 r3779  
    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
     
    2828        Independent(U);
    2929
    30         // dependent variable vector 
     30        // dependent variable vector
    3131        CPPAD_TESTVECTOR(AD<double>) Z(1);
    32         Z[0] = sinh(U[0]); 
     32        Z[0] = sinh(U[0]);
    3333
    3434        // create f: U -> Z and vectors used for derivative calculations
    35         ADFun<double> f(U, Z); 
     35        ADFun<double> f(U, Z);
    3636        CPPAD_TESTVECTOR(double) v(1);
    3737        CPPAD_TESTVECTOR(double) w(1);
    3838
    39         // check value 
     39        // check value
    4040        double sin_u = sinh( Value(U[0]) );
    4141        double cos_u = cosh( Value(U[0]) );
     
    4949        v[0]         = 1.;
    5050        for(j = 1; j < p; j++)
    51         {       w     = f.Forward(j, v);       
     51        {       w     = f.Forward(j, v);
    5252
    5353                double value;
     
    6262
    6363        // reverse computation of partials of Taylor coefficients
    64         CPPAD_TESTVECTOR(double) r(p); 
     64        CPPAD_TESTVECTOR(double) r(p);
    6565        w[0]  = 1.;
    6666        r     = f.Reverse(p, w);
  • trunk/test_more/sparse_hessian.cpp

    r2506 r3779  
    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
     
    3939
    4040        for(i = 0; i < m; i++)
    41         {       AD<double> diff = a_x[i+1] - a_x[i];   
    42                 a_y[i] = 0.5 * diff * diff / double(i+2); 
     41        {       AD<double> diff = a_x[i+1] - a_x[i];
     42                a_y[i] = 0.5 * diff * diff / double(i+2);
    4343                w[i] = double(i+1);
    4444                ell         = i * n + i;
     
    5454        // create f: x -> y
    5555        CppAD::ADFun<double> f(a_x, a_y);
    56                  
     56
    5757        // determine the sparsity pattern p for Hessian of w^T f
    5858        typedef CppAD::vector< std::set<size_t> > VectorSet;
     
    8282                        k++;
    8383                }
    84         } 
     84        }
    8585        ok &= k == K;
    8686
     
    100100
    101101
    102 template <class VectorBase, class VectorBool> 
     102template <class VectorBase, class VectorBool>
    103103bool bool_case()
    104104{       bool ok = true;
     
    128128                x[i] = double(i);
    129129
    130         // second derivative of y[1] 
     130        // second derivative of y[1]
    131131        VectorBase w(m);
    132132        w[0] = 1.;
     
    166166        return ok;
    167167}
    168 template <class VectorBase, class VectorSet> 
     168template <class VectorBase, class VectorSet>
    169169bool set_case()
    170170{       bool ok = true;
     
    194194                x[i] = double(i);
    195195
    196         // second derivative of y[1] 
     196        // second derivative of y[1]
    197197        VectorBase w(m);
    198198        w[0] = 1.;
     
    230230        return ok;
    231231}
    232 } // End empty namespace 
     232} // End empty namespace
    233233# include <vector>
    234234# include <valarray>
  • trunk/test_more/sparse_vec_ad.cpp

    r2506 r3779  
    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
     
    1919
    2020        // dimension of the domain space
    21         size_t n = 3; 
     21        size_t n = 3;
    2222
    2323        size_t i, j;
    2424
    25         // independent variable vector 
     25        // independent variable vector
    2626        CPPAD_TESTVECTOR(AD<double>) X(n);
    2727        for(j = 0; j < n; j++)
    28                 X[j] = AD<double>(j); 
     28                X[j] = AD<double>(j);
    2929        Independent(X);
    3030
     
    6262                        Check[ i * m + j ] = (j <= i);
    6363        }
    64        
     64
    6565        // create function object F : X -> Y
    6666        ADFun<double> F(X, Y);
     
    8181        {       for(j = 0; j < n; j++)
    8282                        ok &= (Px[i * m + j] == Check[i * m + j]);
    83         }       
     83        }
    8484
    8585        // evaluate the dependency matrix for F(Identity(x))
     
    9191        {       for(j = 0; j < n; j++)
    9292                        ok &= (Py[i * m + j] == Check[i * m + j]);
    93         }       
     93        }
    9494
    95         // test sparsity pattern for Hessian of F_2 ( Identity(x) ) 
     95        // test sparsity pattern for Hessian of F_2 ( Identity(x) )
    9696        CPPAD_TESTVECTOR(bool) Hy(m);
    9797        for(i = 0; i < m; i++)
     
    105105        }
    106106
    107         // test sparsity pattern for Hessian of F_1 ( Identity(x) ) 
     107        // test sparsity pattern for Hessian of F_1 ( Identity(x) )
    108108        for(i = 0; i < m; i++)
    109109                Hy[i] = false;
  • trunk/test_more/sqrt.cpp

    r2506 r3779  
    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
     
    6060        ok &= NearEqual(v[s], .25 * pow(4., -.75),  1e-10 , 1e-10); // dy/ds
    6161
    62         // forward computation of second partials w.r.t s 
     62        // forward computation of second partials w.r.t s
    6363        v[s] = 1.;
    6464        w    = f.Forward(1, v);
     
    6666        w    = f.Forward(2, v);
    6767        ok &= NearEqual(       // d^2 y / (ds ds)
    68                 2. * w[y] , 
     68                2. * w[y] ,
    6969                -.75 * .25 * pow(4., -1.75),
    7070                1e-10 ,
    71                 1e-10 
    72         ); 
     71                1e-10
     72        );
    7373
    7474        // reverse computation of second partials of y
     
    7878        r    = f.Reverse(2, w);
    7979        ok &= NearEqual(      // d^2 y / (ds ds)
    80                 r[2 * s + 1] , 
     80                r[2 * s + 1] ,
    8181                -.75 * .25 * pow(4., -1.75),
    8282                1e-10 ,
    83                 1e-10 
    84         ); 
     83                1e-10
     84        );
    8585
    8686        return ok;
     
    9797
    9898        // a temporary values
    99         AD<double> x = U[0] * U[0]; 
    100 
    101         // dependent variable vector 
     99        AD<double> x = U[0] * U[0];
     100
     101        // dependent variable vector
    102102        CPPAD_TESTVECTOR(AD<double>) Z(1);
    103103        Z[0] =  sqrt( x ); // z = sqrt( u * u )
    104104
    105105        // create f: U -> Z and vectors used for derivative calculations
    106         ADFun<double> f(U, Z); 
     106        ADFun<double> f(U, Z);
    107107        CPPAD_TESTVECTOR(double) v(1);
    108108        CPPAD_TESTVECTOR(double) w(1);
    109109
    110         // check value 
     110        // check value
    111111        ok &= NearEqual(U[0] , Z[0],  1e-10 , 1e-10);
    112112
     
    119119        for(j = 1; j < p; j++)
    120120        {       jfac *= j;
    121                 w     = f.Forward(j, v);       
     121                w     = f.Forward(j, v);
    122122                ok &= NearEqual(jfac*w[0], value, 1e-10 , 1e-10); // d^jz/du^j
    123123                v[0]  = 0.;
     
    126126
    127127        // reverse computation of partials of Taylor coefficients
    128         CPPAD_TESTVECTOR(double) r(p); 
     128        CPPAD_TESTVECTOR(double) r(p);
    129129        w[0]  = 1.;
    130130        r     = f.Reverse(p, w);
     
    164164        x1[0] = 1.;
    165165        y1    = f.Forward(1, x1);
    166         ok   &= NearEqual(y1[0], exp(x/2.)/2.,   1e-10 , 1e-10); 
     166        ok   &= NearEqual(y1[0], exp(x/2.)/2.,   1e-10 , 1e-10);
    167167
    168168        // forward computation of second Taylor coefficient
     
    171171        x2[0] = 0.;
    172172        y2    = f.Forward(2, x2);
    173         ok   &= NearEqual(2.*y2[0] , exp(x/2.)/4., 1e-10 , 1e-10 ); 
     173        ok   &= NearEqual(2.*y2[0] , exp(x/2.)/4., 1e-10 , 1e-10 );
    174174
    175175        // forward computation of third Taylor coefficient
     
    178178        x3[0] = 0.;
    179179        y3    = f.Forward(3, x3);
    180         ok   &= NearEqual(6.*y3[0] , exp(x/2.)/8., 1e-10 , 1e-10 ); 
     180        ok   &= NearEqual(6.*y3[0] , exp(x/2.)/8., 1e-10 , 1e-10 );
    181181
    182182        // reverse computation of deritavitve of Taylor coefficients
     
    185185        w[0] = 1.;
    186186        r    = f.Reverse(4, w);
    187         ok   &= NearEqual(r[0], exp(x/2.)/2., 1e-10 , 1e-10); 
    188         ok   &= NearEqual(r[1], exp(x/2.)/4., 1e-10 , 1e-10 ); 
    189         ok   &= NearEqual(2.*r[2], exp(x/2.)/8., 1e-10 , 1e-10 ); 
    190         ok   &= NearEqual(6.*r[3], exp(x/2.)/16., 1e-10 , 1e-10 ); 
     187        ok   &= NearEqual(r[0], exp(x/2.)/2., 1e-10 , 1e-10);
     188        ok   &= NearEqual(r[1], exp(x/2.)/4., 1e-10 , 1e-10 );
     189        ok   &= NearEqual(2.*r[2], exp(x/2.)/8., 1e-10 , 1e-10 );
     190        ok   &= NearEqual(6.*r[3], exp(x/2.)/16., 1e-10 , 1e-10 );
    191191
    192192        return ok;
     
    199199{       bool ok = true;
    200200        ok &= SqrtTestOne();
    201         ok &= SqrtTestTwo(); 
    202         ok &= SqrtTestThree(); 
    203         return ok;
    204 }
     201        ok &= SqrtTestTwo();
     202        ok &= SqrtTestThree();
     203        return ok;
     204}
  • trunk/test_more/std_math.cpp

    r3060 r3779  
    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
     
    2121
    2222bool std_math(void)
    23 {       using CppAD::NearEqual; 
     23{       using CppAD::NearEqual;
    2424        bool ok = true;
    2525        ADDdouble half(.5);
  • trunk/test_more/sub.cpp

    r2506 r3779  
    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
     
    4242        Z[x] = U[s]  - U[t];   // AD<double> - AD<double>
    4343        Z[y] = Z[x]  - 1.;     // AD<double> - double
    44         Z[z] = 1.    - Z[y];   // double - AD<double> 
     44        Z[z] = 1.    - Z[y];   // double - AD<double>
    4545
    4646        // create f: U -> Z and vectors used for derivative calculations
     
    8888        AD<double> a = 2. * U[0] - 1.; // AD<double> - double
    8989        AD<double> b = a  - 2;         // AD<double> - int
    90         AD<double> c = 3. - b;         // double     - AD<double> 
    91         AD<double> d = 4  - c;         // int        - AD<double> 
     90        AD<double> c = 3. - b;         // double     - AD<double>
     91        AD<double> d = 4  - c;         // int        - AD<double>
    9292
    93         // dependent variable vector 
     93        // dependent variable vector
    9494        CPPAD_TESTVECTOR(AD<double>) Z(1);
    9595        Z[0] = U[0] - d;          // AD<double> - AD<double>
    9696
    9797        // create f: U -> Z and vectors used for derivative calculations
    98         ADFun<double> f(U, Z); 
     98        ADFun<double> f(U, Z);
    9999        CPPAD_TESTVECTOR(double) v(1);
    100100        CPPAD_TESTVECTOR(double) w(1);
    101101
    102         // check value 
     102        // check value
    103103        ok &= NearEqual(Value(Z[0]) , u0-4+3-2*u0+1+2,  1e-10 , 1e-10);
    104104
     
    111111        for(j = 1; j < p; j++)
    112112        {       jfac *= j;
    113                 w     = f.Forward(j, v);       
     113                w     = f.Forward(j, v);
    114114                ok &= NearEqual(jfac*w[0], value, 1e-10 , 1e-10); // d^jz/du^j
    115115                v[0]  = 0.;
     
    118118
    119119        // reverse computation of partials of Taylor coefficients
    120         CPPAD_TESTVECTOR(double) r(p); 
     120        CPPAD_TESTVECTOR(double) r(p);
    121121        w[0]  = 1.;
    122122        r     = f.Reverse(p, w);
     
    136136        using namespace CppAD;
    137137
    138         // special cases where tests above check OK and SubpvOp 
    139         // implementation is known to be worng. 
     138        // special cases where tests above check OK and SubpvOp
     139        // implementation is known to be worng.
    140140        // Probably two minuses make a plus.
    141141        size_t n = 1;
     
    146146        CPPAD_TESTVECTOR(AD<double>) Y(m);
    147147        Y[0] = 1. - X[0];
    148         ADFun<double> f(X, Y); 
    149        
     148        ADFun<double> f(X, Y);
     149
    150150        CPPAD_TESTVECTOR(double) w(m), dw(n);
    151151        w[0] = 1.;
     
    171171                Y[0] = X[0] - 2.;
    172172        else    Y[0] = X[0] - 2.;
    173         ADFun<double> f(X, Y); 
    174        
     173        ADFun<double> f(X, Y);
     174
    175175        CPPAD_TESTVECTOR(double) y(m), x(n);
    176176        x[0] = 1.;
    177177        y    = f.Forward(0, x);
    178178        ok  &= (y[0] == -1.);
    179        
     179
    180180        CPPAD_TESTVECTOR(double) dy(m), dx(n);
    181181        dx[0] = 1.;
     
    192192{       bool ok = true;
    193193        ok &= One();
    194         ok &= Two(); 
    195         ok &= Three(); 
     194        ok &= Two();
     195        ok &= Three();
    196196        ok &= Four();
    197197        return ok;
  • trunk/test_more/sub_eq.cpp

    r2506 r3779  
    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
     
    3737
    3838        // dependent variable values
    39         Z[x]  = U[s]; 
     39        Z[x]  = U[s];
    4040        Z[y]  = U[t];
    41         Z[x] -= U[t];  // AD<double> -= AD<double> 
    42         Z[y] -= 5.;    // AD<double> -= double 
     41        Z[x] -= U[t];  // AD<double> -= AD<double>
     42        Z[y] -= 5.;    // AD<double> -= double
    4343
    4444        // create f: U -> Z and vectors used for derivative calculations
     
    7777        double u0 = .5;
    7878        CPPAD_TESTVECTOR(AD<double>) U(1);
    79         U[0]      = u0; 
     79        U[0]      = u0;
    8080        Independent(U);
    8181
    82         // dependent variable vector 
     82        // dependent variable vector
    8383        CPPAD_TESTVECTOR(AD<double>) Z(1);
    8484        Z[0] = U[0];       // initial value
    8585        Z[0] -= 2;         // AD<double> -= int
    8686        Z[0] -= 4.;        // AD<double> -= double
    87         Z[0] -= 2 * U[0];  // AD<double> -= AD<double> 
     87        Z[0] -= 2 * U[0];  // AD<double> -= AD<double>
    8888
    8989        // create f: U -> Z and vectors used for derivative calculations
    90         ADFun<double> f(U, Z); 
     90        ADFun<double> f(U, Z);
    9191        CPPAD_TESTVECTOR(double) v(1);
    9292        CPPAD_TESTVECTOR(double) w(1);
    9393
    94         // check value 
     94        // check value
    9595        ok &= NearEqual(Z[0] , u0-2-4-2*u0,  1e-10 , 1e-10);
    9696
     
    103103        for(j = 1; j < p; j++)
    104104        {       jfac *= j;
    105                 w     = f.Forward(j, v);       
     105                w     = f.Forward(j, v);
    106106                ok &= NearEqual(jfac*w[0], value, 1e-10 , 1e-10); // d^jz/du^j
    107107                v[0]  = 0.;
     
    110110
    111111        // reverse computation of partials of Taylor coefficients
    112         CPPAD_TESTVECTOR(double) r(p); 
     112        CPPAD_TESTVECTOR(double) r(p);
    113113        w[0]  = 1.;
    114114        r     = f.Reverse(p, w);
     
    129129{       bool ok = true;
    130130        ok &= SubEqTestOne();
    131         ok &= SubEqTestTwo(); 
     131        ok &= SubEqTestTwo();
    132132        return ok;
    133133}
  • trunk/test_more/sub_zero.cpp

    r2506 r3779  
    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
     
    2121
    2222bool SubZero(void)
    23 {       
     23{
    2424        using namespace CppAD;
    2525
  • trunk/test_more/test_vector.cpp

    r2506 r3779  
    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
     
    2626        double x0 = 0.5;
    2727        CPPAD_TEST_VECTOR< AD<double> > x(n);
    28         x[0]      = x0; 
     28        x[0]      = x0;
    2929
    3030        // declare independent variables and start tape recording
     
    3434        AD<double> a = x[0] + 1.; // AD<double> + double
    3535        AD<double> b = a    + 2;  // AD<double> + int
    36         AD<double> c = 3.   + b;  // double     + AD<double> 
    37         AD<double> d = 4    + c;  // int        + AD<double> 
     36        AD<double> c = 3.   + b;  // double     + AD<double>
     37        AD<double> d = 4    + c;  // int        + AD<double>
    3838
    39         // range space vector 
     39        // range space vector
    4040        size_t m = 1;
    4141        CPPAD_TEST_VECTOR< AD<double> > y(m);
    42         y[0] = d + x[0];          // AD<double> + AD<double> 
     42        y[0] = d + x[0];          // AD<double> + AD<double>
    4343
    4444        // create f: x -> y and stop tape recording
    45         CppAD::ADFun<double> f(x, y); 
     45        CppAD::ADFun<double> f(x, y);
    4646
    47         // check value 
     47        // check value
    4848        ok &= NearEqual(y[0] , 2. * x0 + 10,  1e-10 , 1e-10);
    4949
  • trunk/test_more/value.cpp

    r2506 r3779  
    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
  • trunk/test_more/vec_ad.cpp

    r2506 r3779  
    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
     
    4949        // check array values (while not taping)
    5050        for(i = 0; i < n; i++)
    51                 ok &= ( V[i] == 2. * double(n - i) ); 
    52 
    53         // independent variable 
     51                ok &= ( V[i] == 2. * double(n - i) );
     52
     53        // independent variable
    5454        CPPAD_TESTVECTOR(AD<double>) X(1);
    5555        X[0] = double(n - 1);
     
    8787                z    = f.Forward(0, x);
    8888                vx   = double(n - i);
    89                 ok  &= NearEqual(z[0], sin(x[0]) * vx, 1e-10, 1e-10); 
     89                ok  &= NearEqual(z[0], sin(x[0]) * vx, 1e-10, 1e-10);
    9090
    9191                // note that derivative of v[x] w.r.t. x is zero
    9292                dx[0] = 1.;
    9393                dz    = f.Forward(1, dx);
    94                 ok   &= NearEqual(dz[0], cos(x[0]) * vx, 1e-10, 1e-10); 
     94                ok   &= NearEqual(dz[0], cos(x[0]) * vx, 1e-10, 1e-10);
    9595
    9696                // reverse mode calculation of same value
    9797                dz[0] = 1.;
    9898                dx    = f.Reverse(1, dz);
    99                 ok   &= NearEqual(dx[0], cos(x[0]) * vx, 1e-10, 1e-10); 
    100         }
    101 
    102 
    103         return ok;
    104 }
    105 
    106 // create the discrete function AD<double> Floor(const AD<double> &X) 
     99                ok   &= NearEqual(dx[0], cos(x[0]) * vx, 1e-10, 1e-10);
     100        }
     101
     102
     103        return ok;
     104}
     105
     106// create the discrete function AD<double> Floor(const AD<double> &X)
    107107double Floor(const double &x)
    108 {       return std::floor(x); } 
     108{       return std::floor(x); }
    109109CPPAD_DISCRETE_FUNCTION(double, Floor)
    110110
     
    112112{       bool ok = true;
    113113        using namespace CppAD;
    114        
     114
    115115        double pi    = 4. * CppAD::atan(1.);
    116116        size_t nx    = 10;                       // number of x grid point
     
    124124        size_t i;
    125125        for(i = 0; i < nx; i++)
    126         {       xCur = xLow + double(i) * xStep; 
     126        {       xCur = xLow + double(i) * xStep;
    127127                // use size_t indexing of Data while not taping
    128                 Data[i] = CppAD::sin(xCur); 
    129         }
    130 
    131         // declare independent variable 
     128                Data[i] = CppAD::sin(xCur);
     129        }
     130
     131        // declare independent variable
    132132        CPPAD_TESTVECTOR(AD<double>) X(1);
    133133        X[0] = 2.;
     
    175175# include <limits>
    176176bool SecondOrderReverse(void)
    177 {       // Bradley M. Bell 2009-07-06 
     177{       // Bradley M. Bell 2009-07-06
    178178        // Reverse mode for LdpOp was only modifying the highest order partial
    179179        // This test demonstrated the bug
     
    199199        AD<double> one = X[0] - 1; // one in a variable here
    200200        Z[one]  = X[0] + 1.;
    201        
     201
    202202
    203203        // Compute a function where the second order partial for y
     
    226226        // check first derivative in dw
    227227        double check = 2. * (Value( X[0] ) + 1.);
    228         ok &= NearEqual(dw[0], check, eps, eps); 
     228        ok &= NearEqual(dw[0], check, eps, eps);
    229229
    230230        // check second derivative in dw
    231231        check = 2.;
    232         ok &= NearEqual(dw[1], check, eps, eps); 
     232        ok &= NearEqual(dw[1], check, eps, eps);
    233233
    234234        // Test LdvOp
     
    241241        // check first derivative in dw
    242242        check = 2. * (Value( X[0] ) + 1.);
    243         ok &= NearEqual(dw[0], check, eps, eps); 
     243        ok &= NearEqual(dw[0], check, eps, eps);
    244244
    245245        // check second derivative in dw
    246246        check = 2.;
    247         ok &= NearEqual(dw[1], check, eps, eps); 
     247        ok &= NearEqual(dw[1], check, eps, eps);
    248248
    249249        return ok;
     
    255255{       bool ok = true;
    256256        ok &= VecADTestOne();
    257         ok &= VecADTestTwo(); 
     257        ok &= VecADTestTwo();
    258258        ok &= SecondOrderReverse();
    259259        return ok;
  • trunk/test_more/vec_ad_par.cpp

    r2506 r3779  
    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
     
    2121
    2222bool VecADPar(void)
    23 {       
     23{
    2424        using namespace CppAD;
    2525
     
    3838        ADDdouble zero(0);
    3939        ADDdouble one(1);
    40         v[zero] = x[0]; // these two parameter values are equal, 
     40        v[zero] = x[0]; // these two parameter values are equal,
    4141        v[one]  = x[1]; // but they are not identically equal
    4242
  • trunk/test_more/vec_unary.cpp

    r2506 r3779  
    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
     
    1919
    2020bool VecUnary(void)
    21 {       
     21{
    2222        using namespace CppAD;
    2323        using CppAD::abs;
     
    4545
    4646        j    = 0.;
    47         Y[j] = X[0]; 
     47        Y[j] = X[0];
    4848        Z[0] = -Y[j];
    4949
    5050        j    = 1.;
    51         Y[j] = X[1]; 
     51        Y[j] = X[1];
    5252        Z[1] = sin( Y[j] );
    5353
    5454        j    = 2.;
    55         Y[j] = X[2]; 
     55        Y[j] = X[2];
    5656        Z[2] = abs( Y[j] );
    5757
    5858        j    = 3.;
    59         Y[j] = X[3]; 
     59        Y[j] = X[3];
    6060        Z[3] = atan( Y[j] );
    6161
    6262        j    = 4.;
    63         Y[j] = X[4]; 
     63        Y[j] = X[4];
    6464        Z[4] = cos( Y[j] );
    6565
    6666        j    = 5.;
    67         Y[j] = X[5]; 
     67        Y[j] = X[5];
    6868        Z[5] = exp( Y[j] );
    6969
    7070        j    = 6.;
    71         Y[j] = X[6]; 
     71        Y[j] = X[6];
    7272        Z[6] = log( Y[j] );
    7373
    7474        j    = 7.;
    75         Y[j] = X[7]; 
     75        Y[j] = X[7];
    7676        Z[7] = sqrt( Y[j] );
    7777
    78        
     78
    7979        ADFun<double> f(X, Z);
    8080        CPPAD_TESTVECTOR(double) x(n);
Note: See TracChangeset for help on using the changeset viewer.