Changeset 3856 for trunk/test_more


Ignore:
Timestamp:
Dec 21, 2016 12:51:22 AM (3 years ago)
Author:
bradbell
Message:

merge to branch: trunk
from repository: https://github.com/coin-or/CppAD
start hash code: 70d349c1e2c4eba3bb52ac332d5a668f9baaf635
end hash code: 5b1136c40e85afdfe267a1b1bf35b1fbb652e90f

commit 5b1136c40e85afdfe267a1b1bf35b1fbb652e90f
Author: Brad Bell <bradbell@…>
Date: Tue Dec 20 22:40:09 2016 -0700

wish_list.omh: remove item that has been completed.

commit 0ee93391590fbc06121c15913655afe098933db1
Author: Brad Bell <bradbell@…>
Date: Tue Dec 20 22:24:32 2016 -0700

Some floating point exactly equal tests were failing on a mingw system.
This is even more likely with the optimizer because the order of operations
can change.

commit e261d2e3d97c1d7de7397cfff203864af3729652
Author: Brad Bell <bradbell@…>
Date: Tue Dec 20 18:08:49 2016 -0700

Use a muliple of machine epsilon in NearEqual? (where appropriate).

commit 0803459684dc68e32b3d66db8a6d3690fd3bd7a0
Author: Brad Bell <bradbell@…>
Date: Tue Dec 20 12:41:54 2016 -0700

  1. Change NearEqual? to use machine epsilon (where appropriate).
  2. Fix copyright messages in swig directory.
  3. Advance to verion cppad-20161220.
  4. Remove extra ! /bin/bash -e that are not at top of file.


example.hpp: fix include guard.

commit 769abd76975cd13b3ccfc9c4473504b2ea556b8a
Author: Brad Bell <bradbell@…>
Date: Mon Dec 19 13:53:21 2016 -0700

Change my_example -> example

commit 61c9b9bf28764e0aee77e48434cef3786572d7f1
Author: Brad Bell <bradbell@…>
Date: Mon Dec 19 13:52:01 2016 -0700

remove assignment operator, use .value() instead of int.

commit 1cfe5fbc1aebeb2b10aefac1bd0f4b9ff1affb9e
Author: Brad Bell <bradbell@…>
Date: Mon Dec 19 12:27:49 2016 -0700

Convert double quote " to single quote ' (better syntax highlighting of octave)

commit 51de94b618d162c167b8251a0b7e4e5d76d83192
Author: Brad Bell <bradbell@…>
Date: Mon Dec 19 12:24:38 2016 -0700

Example of class and operator overloading.

commit 40e6746948469d39ae5af81dd467fd03ee81a798
Author: Brad Bell <bradbell@…>
Date: Mon Dec 19 11:28:56 2016 -0700

Add exception handeling.

commit 7cd9445658ae8ddb77469f668b0bcd8d67489aaa
Author: Brad Bell <bradbell@…>
Date: Mon Dec 19 08:08:11 2016 -0700

Move my_example.h -> my_example.hpp (It is a C++ include file).
test_my_example.m: fix print of what is being tested.

commit 0ec7b682a781206b15685f0492b6ffa2ce3bfc5a
Author: Brad Bell <bradbell@…>
Date: Mon Dec 19 08:03:47 2016 -0700

Better function names and comments about what is being demonstrated/tested.

commit 398d21af1b062878cac1fab246e7777aaa2e5a5c
Author: Brad Bell <bradbell@…>
Date: Mon Dec 19 07:22:02 2016 -0700

Add array object example.

commit 5901d20652123b9cd1d8ca6d374043aaa6d83669
Author: Brad Bell <bradbell@…>
Date: Mon Dec 19 07:09:47 2016 -0700

Add missing entry in auto-tools build files.

commit 198cf13c477e26e11d482b5b3e04a6d4980d621d
Author: Brad Bell <bradbell@…>
Date: Mon Dec 19 07:04:25 2016 -0700

Add comments for what is being tested, remove redundant test (my_mod).

commit 2115bda67e07fb88e6cc409540c07a10cd35fada
Author: Brad Bell <bradbell@…>
Date: Mon Dec 19 06:53:00 2016 -0700

Cnage int_vector -> int_array_ptr and vec -> array_ptr.

commit e36c255d550462867b22dac86f1d4643d2eff448
Author: Brad Bell <bradbell@…>
Date: Mon Dec 19 06:42:32 2016 -0700

Change ptr -> obj and int_ptr -> int_class.

commit b924f91727a8e0c1850440016675c603864f30aa
Author: Brad Bell <bradbell@…>
Date: Mon Dec 19 06:28:36 2016 -0700

Move octave test program to separate file.

commit 8b871c7d187badb1973f3b2b0b4fd7b41867b705
Author: Brad Bell <bradbell@…>
Date: Mon Dec 19 06:21:20 2016 -0700

Move python test program to separate file.

commit b53fe94b7afecde4ce73a954ff12c296050b9ee4
Author: Brad Bell <bradbell@…>
Date: Mon Dec 19 05:58:47 2016 -0700

Use source files from original directory (not build directory).

commit b3c09a37db740807a0f9c4b592bf4819c518cf87
Author: Brad Bell <bradbell@…>
Date: Mon Dec 19 05:46:17 2016 -0700

Simplify by specifying swig output file.


CMakeLists.txt: remove comment that has no relevance.

commit bfd897955058ee32e00c3a0bcdb8f8c6be1d6646
Author: Brad Bell <bradbell@…>
Date: Mon Dec 19 05:23:53 2016 -0700

Delete pointers (when done with them).

commit dd1f74cb1c4f6083da6daf4d9122d6cac0e3343c
Author: Brad Bell <bradbell@…>
Date: Mon Dec 19 05:19:41 2016 -0700

Change int_ptr -> int_ctor and remove semi-colons from python (needed in octave)

commit f6c3ec9e8a55ff8f2015aeefa0ed653a683051b0
Author: Brad Bell <bradbell@…>
Date: Mon Dec 19 04:56:50 2016 -0700

my_example.i: use example.i instead of repeating code.

commit 5b934b8d6c443a64147e69764bb87a9c9c5fc627
Author: Brad Bell <bradbell@…>
Date: Sun Dec 18 22:15:46 2016 -0700

Add example using vectors.

commit 855f484a3dc20cf857b0a8e27c9859f69bc4ceb8
Author: Brad Bell <bradbell@…>
Date: Sun Dec 18 20:48:27 2016 -0700

Add example using pointers.

Location:
trunk/test_more
Files:
16 edited

Legend:

Unmodified
Added
Removed
  • trunk/test_more/atan2.cpp

    r3779 r3856  
    11// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    2323{       bool ok = true;
    2424        using CppAD::AD;
     25        using CppAD::NearEqual;
     26        double eps99 = 99.0 * std::numeric_limits<double>::epsilon();
    2527
    2628        AD< AD<double> > x(2.), y(2.);
    2729        AD< AD<double> > z = atan2(y, x);
    28         CppAD::NearEqual( Value( Value(z) ), atan(1.), 1e-10, 1e-10 );
     30        NearEqual( Value( Value(z) ), atan(1.), eps99, eps99);
    2931
    3032        return ok;
     
    3840        using CppAD::cos;
    3941        using namespace CppAD;
     42        using CppAD::NearEqual;
     43        double eps99 = 99.0 * std::numeric_limits<double>::epsilon();
    4044
    4145        // independent variable vector
     
    5862
    5963        // check original value (u in first quadrant)
    60         ok &= NearEqual(U[0] , Z[0],  1e-10 , 1e-10);
     64        ok &= NearEqual(U[0] , Z[0], eps99, eps99);
    6165
    6266        // check case where u is in second quadrant
    6367        v[0] = 3.;
    6468        w    = f.Forward(0, v);
    65         ok  &= NearEqual(w[0] , v[0],  1e-10 , 1e-10);
     69        ok  &= NearEqual(w[0] , v[0], eps99, eps99);
    6670
    6771        // check case where u is in third quadrant
    6872        v[0] = -3.;
    6973        w    = f.Forward(0, v);
    70         ok  &= NearEqual(w[0] , v[0],  1e-10 , 1e-10);
     74        ok  &= NearEqual(w[0] , v[0], eps99, eps99);
    7175
    7276        // check case where u is in fourth quadrant
    7377        v[0] = -1.;
    7478        w    = f.Forward(0, v);
    75         ok  &= NearEqual(w[0] , v[0],  1e-10 , 1e-10);
     79        ok  &= NearEqual(w[0] , v[0], eps99, eps99);
    7680
    7781        // forward computation of partials w.r.t. u
     
    8488        {       jfac *= j;
    8589                w     = f.Forward(j, v);
    86                 ok &= NearEqual(jfac*w[0], value, 1e-10 , 1e-10); // d^jz/du^j
     90                ok &= NearEqual(w[0], value/jfac, eps99, eps99); // d^jz/du^j
    8791                v[0]  = 0.;
    8892                value = 0.;
     
    96100        value = 1.;
    97101        for(j = 0; j < p; j++)
    98         {       ok &= NearEqual(jfac*r[j], value, 1e-10 , 1e-10); // d^jz/du^j
     102        {       ok &= NearEqual(r[j], value/jfac, eps99, eps99); // d^jz/du^j
    99103                jfac *= (j + 1);
    100104                value = 0.;
  • trunk/test_more/div.cpp

    r3757 r3856  
    11// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    2323
    2424        using namespace CppAD;
     25        using CppAD::NearEqual;
     26        double eps99 = 99.0 * std::numeric_limits<double>::epsilon();
    2527
    2628        // assign some parameters
     
    6668
    6769        // check values
    68         ok &= NearEqual( Z[x] , 2. / 3. ,           1e-10 , 1e-10);
    69         ok &= NearEqual( Z[y] , 2. / ( 3. * 4. ) ,  1e-10 , 1e-10);
    70         ok &= NearEqual( Z[z] , 5. * 3. * 4. / 2. , 1e-10 , 1e-10);
     70        ok &= NearEqual( Z[x] , 2. / 3. , eps99, eps99);
     71        ok &= NearEqual( Z[y] , 2. / ( 3. * 4. ) , eps99, eps99);
     72        ok &= NearEqual( Z[z] , 5. * 3. * 4. / 2. , eps99, eps99);
    7173        ok &= ( Z[w] == 0. );
    7274        ok &= ( Z[u] == Z[z] );
     
    7678        q[t] = 0.;
    7779        r    = f.Forward(1, q);
    78         ok &= NearEqual(r[x], 1./U[t],                1e-10 , 1e-10); // dx/ds
    79         ok &= NearEqual(r[y], 1./(U[t]*4.),           1e-10 , 1e-10); // dy/ds
    80         ok &= NearEqual(r[z], -5.*U[t]*4./(U[s]*U[s]),1e-10 , 1e-10); // dz/ds
     80        ok &= NearEqual(r[x], 1./U[t], eps99, eps99); // dx/ds
     81        ok &= NearEqual(r[y], 1./(U[t]*4.), eps99, eps99); // dy/ds
     82        ok &= NearEqual(r[z], -5.*U[t]*4./(U[s]*U[s]), eps99, eps99); // dz/ds
    8183        ok &= ( r[u] == r[z] );                                       // du/ds
    8284        ok &= ( r[v] == r[z] );                                       // dv/ds
     
    8789        q[t] = 1.;
    8890        r    = f.Forward(1, q);
    89         ok  &= NearEqual(r[x], 1./U[t] - U[s]/(U[t] * U[t]), 1e-10, 1e-10);
     91        ok  &= NearEqual(r[x], 1./U[t] - U[s]/(U[t] * U[t]), eps99, eps99);
    9092
    9193        // second order reverse mode computation
     
    107109{       bool ok = true;
    108110        using namespace CppAD;
     111        using CppAD::NearEqual;
     112        double eps99 = 99.0 * std::numeric_limits<double>::epsilon();
    109113
    110114        // independent variable vector
     
    129133
    130134        // check value
    131         ok &= NearEqual(Value(Z[0]) , u0*u0/(4/(3/(u0/2))),  1e-10 , 1e-10);
     135        ok &= NearEqual(Value(Z[0]) , u0*u0/(4/(3/(u0/2))), eps99, eps99);
    132136
    133137        // forward computation of partials w.r.t. u
     
    141145                jfac *= j;
    142146                w     = f.Forward(j, v);
    143                 ok &= NearEqual(jfac*w[0], value, 1e-10 , 1e-10); // d^jz/du^j
     147                ok &= NearEqual(jfac*w[0], value, eps99, eps99); // d^jz/du^j
    144148                v[0]  = 0.;
    145149                value = 0.;
     
    154158        for(j = 0; j < p; j++)
    155159        {
    156                 ok &= NearEqual(jfac*r[j], value, 1e-10 , 1e-10); // d^jz/du^j
     160                ok &= NearEqual(jfac*r[j], value, eps99, eps99); // d^jz/du^j
    157161                jfac *= (j + 1);
    158162                value = 0.;
     
    165169{       bool ok = true;
    166170        using namespace CppAD;
     171        using CppAD::NearEqual;
     172        double eps99 = 99.0 * std::numeric_limits<double>::epsilon();
    167173
    168174        // more testing of variable / variable case
     
    185191        dy    = f.Forward(1, dx);
    186192        check = 1. / x1 - x0 / (x1 * x1);
    187         ok   &= NearEqual(dy[0], check, 1e-10 , 1e-10);
     193        ok   &= NearEqual(dy[0], check, eps99, eps99);
    188194
    189195        CPPAD_TESTVECTOR(double) w(m), dw(n);
     
    191197        dw    = f.Reverse(1, w);
    192198        check = 1. / x1;
    193         ok   &= NearEqual(dw[0], check, 1e-10 , 1e-10);
     199        ok   &= NearEqual(dw[0], check, eps99, eps99);
    194200        check = - x0 / (x1 * x1);
    195         ok   &= NearEqual(dw[1], check, 1e-10 , 1e-10);
     201        ok   &= NearEqual(dw[1], check, eps99, eps99);
    196202
    197203        return ok;
  • trunk/test_more/div_eq.cpp

    r3757 r3856  
    11// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    2222
    2323        using namespace CppAD;
     24        using CppAD::NearEqual;
     25        double eps99 = 99.0 * std::numeric_limits<double>::epsilon();
    2426
    2527        // independent variable vector, indices, values, and declaration
     
    6466
    6567        // check functin values
    66         ok &= NearEqual(Z[x] , 3. / 2. , 1e-10, 1e-10);
    67         ok &= NearEqual(Z[y] , 2. / 5. , 1e-10, 1e-10);
     68        ok &= NearEqual(Z[x] , 3. / 2. , eps99, eps99);
     69        ok &= NearEqual(Z[y] , 2. / 5. , eps99, eps99);
    6870
    6971        // forward computation of partials w.r.t. t
     
    7173        v[t] = 1.;
    7274        w    = f.Forward(1, v);
    73         ok &= NearEqual(w[x] , -1.*U[s]/(U[t]*U[t]) , 1e-10, 1e-10); // dx/dt
    74         ok &= NearEqual(w[y] , 1. / 5.              , 1e-10, 1e-10); // dy/dt
     75        ok &= NearEqual(w[x] , -1.*U[s]/(U[t]*U[t]) , eps99, eps99); // dx/dt
     76        ok &= NearEqual(w[y] , 1. / 5.              , eps99, eps99); // dy/dt
    7577
    7678        // reverse computation of second partials of x
     
    9193
    9294        using namespace CppAD;
     95        using CppAD::NearEqual;
     96        double eps99 = 99.0 * std::numeric_limits<double>::epsilon();
    9397
    9498        // independent variable vector
     
    111115
    112116        // check value
    113         ok &= NearEqual(Z[0] , u0*u0/(2*4*u0),  1e-10 , 1e-10);
     117        ok &= NearEqual(Z[0] , u0*u0/(2*4*u0), eps99, eps99);
    114118
    115119        // forward computation of partials w.r.t. u
     
    122126        {       jfac *= j;
    123127                w     = f.Forward(j, v);
    124                 ok &= NearEqual(jfac*w[0], value, 1e-10 , 1e-10); // d^jz/du^j
     128                ok &= NearEqual(jfac*w[0], value, eps99, eps99); // d^jz/du^j
    125129                v[0]  = 0.;
    126130                value = 0.;
     
    134138        value = 1./8.;
    135139        for(j = 0; j < p; j++)
    136         {       ok &= NearEqual(jfac*r[j], value, 1e-10 , 1e-10); // d^jz/du^j
     140        {       ok &= NearEqual(jfac*r[j], value, eps99, eps99); // d^jz/du^j
    137141                jfac *= (j + 1);
    138142                value = 0.;
  • trunk/test_more/for_hess.cpp

    r3779 r3856  
    11// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    2626        using CppAD::sin;
    2727        using CppAD::cos;
     28        using CppAD::NearEqual;
     29        double eps99 = 99.0 * std::numeric_limits<double>::epsilon();
    2830
    2931        size_t i;
     
    7981                F.Forward(1, u1);
    8082                CPPAD_TESTVECTOR(double) Di = F.Forward(2, u2);
    81                 ok &= NearEqual( 2. * Di[0] , H0[ i + 3 * i], 1e-10, 1e-10);
    82                 ok &= NearEqual( 2. * Di[1] , H1[ i + 3 * i], 1e-10, 1e-10);
     83                ok &= NearEqual( 2. * Di[0] , H0[ i + 3 * i], eps99, eps99);
     84                ok &= NearEqual( 2. * Di[1] , H1[ i + 3 * i], eps99, eps99);
    8385                //
    8486                for(j = i+1; j < 3; j++)
     
    9597                        // (i, j) elements of the Hessians
    9698                        double H0ij = Cij[0] - Di[0] - Dj[0];
    97                         ok &= NearEqual( H0ij, H0[j + 3 * i], 1e-10, 1e-10);
     99                        ok &= NearEqual( H0ij, H0[j + 3 * i], eps99, eps99);
    98100                        double H1ij = Cij[1] - Di[1] - Dj[1];
    99                         ok &= NearEqual( H1ij, H1[j + 3 * i], 1e-10, 1e-10);
     101                        ok &= NearEqual( H1ij, H1[j + 3 * i], eps99, eps99);
    100102
    101103                        // reset all components of u1 to zero
  • trunk/test_more/forward.cpp

    r3744 r3856  
    1 /* $Id$ */
     1// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    2424
    2525        using namespace CppAD;
     26        using CppAD::NearEqual;
     27        double eps99 = 99.0 * std::numeric_limits<double>::epsilon();
    2628
    2729        // independent variable vector
     
    4446        x0[1]    = 4.;
    4547        y0       = F.Forward(0, x0);
    46         ok      &= NearEqual(y0[0] , x0[0]*x0[0]*x0[1], 1e-10, 1e-10);
     48        ok      &= NearEqual(y0[0] , x0[0]*x0[0]*x0[1], eps99, eps99);
    4749
    4850        // evaluate derivative of F in X[0] direction
     
    5254        x1[1]    = 0.;
    5355        y1       = F.Forward(1, x1);
    54         ok      &= NearEqual(y1[0] , 2.*x0[0]*x0[1], 1e-10, 1e-10);
     56        ok      &= NearEqual(y1[0] , 2.*x0[0]*x0[1], eps99, eps99);
    5557
    5658        // evaluate second derivative of F in X[0] direction
     
    6163        y2          = F.Forward(2, x2);
    6264        double F_00 = 2. * y2[0];
    63         ok         &= NearEqual(F_00, 2.*x0[1], 1e-10, 1e-10);
     65        ok         &= NearEqual(F_00, 2.*x0[1], eps99, eps99);
    6466
    6567        // evalute derivative of F in X[1] direction
     
    6769        x1[1]    = 1.;
    6870        y1       = F.Forward(1, x1);
    69         ok      &= NearEqual(y1[0] , x0[0]*x0[0], 1e-10, 1e-10);
     71        ok      &= NearEqual(y1[0] , x0[0]*x0[0], eps99, eps99);
    7072
    7173        // evaluate second derivative of F in X[1] direction
    7274        y2          = F.Forward(2, x2);
    7375        double F_11 = 2. * y2[0];
    74         ok         &= NearEqual(F_11, 0., 1e-10, 1e-10);
     76        ok         &= NearEqual(F_11, 0., eps99, eps99);
    7577
    7678        // evalute derivative of F in X[0] + X[1] direction
     
    7880        x1[1]    = 1.;
    7981        y1       = F.Forward(1, x1);
    80         ok      &= NearEqual(y1[0], 2.*x0[0]*x0[1] + x0[0]*x0[0], 1e-10, 1e-10);
     82        ok      &= NearEqual(y1[0], 2.*x0[0]*x0[1] + x0[0]*x0[0], eps99, eps99);
    8183
    8284        // use second derivative of F in X[0] direction to
     
    8486        y2          = F.Forward(2, x2);
    8587        double F_01 = y2[0] - F_00 / 2. - F_11 / 2.;
    86         ok         &= NearEqual(F_01 , 2.*x0[0], 1e-10, 1e-10);
     88        ok         &= NearEqual(F_01 , 2.*x0[0], eps99, eps99);
    8789
    8890        return ok;
     
    9395
    9496        using namespace CppAD;
     97        using CppAD::NearEqual;
     98        double eps99 = 99.0 * std::numeric_limits<double>::epsilon();
    9599
    96100        // independent variable vector
     
    130134
    131135        // compare values
    132         ok &= NearEqual(v0[0] , f0[0], 1e-10, 1e-10);
    133         ok &= NearEqual(v0[1] , f0[1], 1e-10, 1e-10);
     136        ok &= NearEqual(v0[0] , f0[0], eps99, eps99);
     137        ok &= NearEqual(v0[1] , f0[1], eps99, eps99);
    134138
    135139        // use ADFun object to evaluate f^(1) [ u0 ] * u1 -----------------
     
    177181                        v2_1 += .5 * u1[i] * H1[i * 3 + j] * u1[j];
    178182        }
    179         ok &= NearEqual(v2[1], v2_1, 1e-10, 1e-10);
     183        ok &= NearEqual(v2[1], v2_1, eps99, eps99);
    180184
    181185
  • trunk/test_more/jacobian.cpp

    r3779 r3856  
    11// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    5151        using CppAD::vector;
    5252        size_t i, j, k;
     53        using CppAD::NearEqual;
     54        double eps99 = 99.0 * std::numeric_limits<double>::epsilon();
    5355
    5456        size_t n = 4;
     
    7274        vector<double> jac_g = fun_g.Jacobian(x);
    7375        for(k = 0; k < m *n; k++)
    74                 ok &= CppAD::NearEqual(jac_g[k], check[k], 1e-10, 1e-10);
     76                ok &= NearEqual(jac_g[k], check[k], eps99, eps99);
    7577
    7678        // one argument sparse jacobian
    7779        jac_g = fun_g.SparseJacobian(x);
    7880        for(k = 0; k < m *n; k++)
    79                 ok &= CppAD::NearEqual(jac_g[k], check[k], 1e-10, 1e-10);
     81                ok &= NearEqual(jac_g[k], check[k], eps99, eps99);
    8082
    8183        // sparse jacobian using bool vectors
     
    8789        jac_g = fun_g.SparseJacobian(x, p_b);
    8890        for(k = 0; k < m *n; k++)
    89                 ok &= CppAD::NearEqual(jac_g[k], check[k], 1e-10, 1e-10);
     91                ok &= NearEqual(jac_g[k], check[k], eps99, eps99);
    9092
    9193        // sparse jacobian using vectors of sets
     
    9799        jac_g = fun_g.SparseJacobian(x, p_s);
    98100        for(k = 0; k < m *n; k++)
    99                 ok &= CppAD::NearEqual(jac_g[k], check[k], 1e-10, 1e-10);
     101                ok &= NearEqual(jac_g[k], check[k], eps99, eps99);
    100102
    101103        return ok;
  • trunk/test_more/ode_err_control.cpp

    r3757 r3856  
    11// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    7070{       bool   ok = true;     // initial return value
    7171
     72        using CppAD::NearEqual;
     73
    7274        // Runge45 should yield exact results for x_i (t) = t^(i+1), i < 4
    7375        size_t  n = 6;
     
    104106        for(i = 0; i < n; i++)
    105107        {       check *= tf;
    106                 ok &= CppAD::NearEqual(check, xf[i], erel, 0.);
     108                ok &= NearEqual(check, xf[i], erel, 0.);
    107109        }
    108110
     
    172174bool OdeErrControl_two(void)
    173175{       bool ok = true;     // initial return value
     176        using CppAD::NearEqual;
    174177
    175178        CppAD::vector<double> w(2);
     
    205208
    206209        double x0 = exp(-w[0]*tf);
    207         ok &= CppAD::NearEqual(x0, xf[0], 1e-4, 1e-4);
    208         ok &= CppAD::NearEqual(0., ef[0], 1e-4, 1e-4);
     210        ok &= NearEqual(x0, xf[0], 1e-4, 1e-4);
     211        ok &= NearEqual(0., ef[0], 1e-4, 1e-4);
    209212
    210213        double x1 = w[0] * (exp(-w[0]*tf) - exp(-w[1]*tf))/(w[1] - w[0]);
    211         ok &= CppAD::NearEqual(x1, xf[1], 1e-4, 1e-4);
    212         ok &= CppAD::NearEqual(0., ef[1], 1e-4, 1e-4);
     214        ok &= NearEqual(x1, xf[1], 1e-4, 1e-4);
     215        ok &= NearEqual(0., ef[1], 1e-4, 1e-4);
    213216
    214217        return ok;
     
    325328bool OdeErrControl_three(void)
    326329{       bool ok = true;     // initial return value
     330        using CppAD::NearEqual;
    327331
    328332        double alpha = 10.;
     
    357361
    358362        double x0       = exp( alpha * tf * tf );
    359         ok &= CppAD::NearEqual(x0, xf[0], 1e-4, 1e-4);
    360         ok &= CppAD::NearEqual(0., ef[0], 1e-4, 1e-4);
     363        ok &= NearEqual(x0, xf[0], 1e-4, 1e-4);
     364        ok &= NearEqual(0., ef[0], 1e-4, 1e-4);
    361365
    362366        double root_pi    = sqrt( 4. * atan(1.));
    363367        double root_alpha = sqrt( alpha );
    364368        double x1 = CppAD::erf(alpha * tf) * root_pi / (2 * root_alpha);
    365         ok &= CppAD::NearEqual(x1, xf[1], 1e-4, 1e-4);
    366         ok &= CppAD::NearEqual(0., ef[1], 1e-4, 1e-4);
     369        ok &= NearEqual(x1, xf[1], 1e-4, 1e-4);
     370        ok &= NearEqual(0., ef[1], 1e-4, 1e-4);
    367371
    368372        ok &= method.F.was_negative();
  • trunk/test_more/optimize.cpp

    r3853 r3856  
    2121
    2222        // accuracy for almost equal checks
    23         double eps_ = 10. * std::numeric_limits<double>::epsilon();
    2423        using CppAD::NearEqual;
    2524
     
    4948        {       bool ok = true;
    5049                using CppAD::AD;
     50                using CppAD::NearEqual;
     51                double eps10 = 10.0 * std::numeric_limits<double>::epsilon();
    5152                using CppAD::vector;
    52                 double eps = 100. * std::numeric_limits<double>::epsilon();
    5353
    5454                // independent variable vector
     
    9595                for(size_t j = 0; j < n; j++)
    9696                {       for(size_t i = j; i < m; i++)
    97                                 ok &= CppAD::NearEqual( tj , jac[ i * n * j], eps, eps );
     97                                ok &= CppAD::NearEqual( tj , jac[ i * n * j], eps10, eps10);
    9898                        tj *= Value( atf - ati );
    9999                }
     
    105105        {       bool ok = true;
    106106                using CppAD::AD;
     107                using CppAD::NearEqual;
     108                double eps10 = 10.0 * std::numeric_limits<double>::epsilon();
    107109                using CppAD::vector;
    108110
     
    157159                        else    c3 = 7.0 * c2;
    158160
    159                         ok &= y[0] == c3;
     161                        ok &= NearEqual(y[0], c3, eps10, eps10);
    160162                }
    161163                return ok;
     
    173175        {       bool ok = true;
    174176                using CppAD::AD;
     177                using CppAD::NearEqual;
     178                double eps10 = 10.0 * std::numeric_limits<double>::epsilon();
    175179                using CppAD::vector;
    176180
     
    208212                x[1] = -1;
    209213                y    = f.Forward(0, x);
    210                 ok  &= y[0] == x[0] + double(3) * x[1];
     214                ok &= NearEqual(y[0], x[0] + double(3) * x[1], eps10, eps10);
    211215
    212216
     
    215219                x[1] = 1;
    216220                y    = f.Forward(0, x);
    217                 ok  &= y[0] == x[0] + double(4) * x[1];
     221                ok &= NearEqual(y[0], x[0] + double(4) * x[1], eps10, eps10);
    218222
    219223                return ok;
     
    234238        {       bool ok = true;
    235239                typedef CppAD::vector< CppAD::AD<double> > ADVector;
     240                using CppAD::NearEqual;
     241                double eps10 = 10.0 * std::numeric_limits<double>::epsilon();
    236242
    237243                // Create a checkpoint version of the function g
     
    262268                x[1] = 4.;
    263269                y    = f.Forward(0, x);
    264                 ok  &= y[0] == x[0] + x[1];
     270                ok &= NearEqual(y[0], x[0] + x[1], eps10, eps10);
    265271
    266272                // before optimize
     
    279285                x[1] = 3.;
    280286                y    = f.Forward(0, x);
    281                 ok  &= y[0] == x[0] - x[1];
     287                ok &= NearEqual(y[0], x[0] - x[1], eps10, eps10);
    282288
    283289                // after optimize can skip either call to g or call to h
     
    288294                dx[1] = 1.;
    289295                dy    = f.Forward(1, dx);
    290                 ok   &= dy[0] == dx[0] - dx[1];
     296                ok &= NearEqual(dy[0], dx[0] - dx[1], eps10, eps10);
    291297
    292298                // optimized first order reverse
    293299                w[0]  = 1.;
    294300                dx    = f.Reverse(1, w);
    295                 ok   &= dx[0] == 1.;
    296                 ok   &= dx[1] == -1.;
     301                ok &= NearEqual(dx[0], 1., eps10, eps10);
     302                ok &= NearEqual(dx[1], -1., eps10, eps10);
    297303
    298304                return ok;
     
    308314        {       bool ok = true;
    309315                using CppAD::AD;
     316                using CppAD::NearEqual;
     317                double eps10 = 10.0 * std::numeric_limits<double>::epsilon();
    310318                using CppAD::vector;
    311319
     
    349357                x[1] = 3.;
    350358                z    = f.Forward(0, x);
    351                 ok  &= z[0] == x[0] - x[1];
     359                ok &= NearEqual(z[0], x[0] - x[1], eps10, eps10);
    352360
    353361                return ok;
     
    356364        {       bool ok = true;
    357365                using CppAD::AD;
     366                using CppAD::NearEqual;
     367                double eps10 = 10.0 * std::numeric_limits<double>::epsilon();
    358368                using CppAD::vector;
    359369                vector< AD<double> > au(2), aw(2), ax(2), ay(1);
     
    395405                x[1] = 6.0;
    396406                y    = f.Forward(0, x);
    397                 ok  &= (y[0] == x[0] + x[1]);
     407                ok &= NearEqual(y[0], x[0] + x[1], eps10, eps10);
    398408
    399409                return ok;
     
    463473                bool ok = true;
    464474                using CppAD::AD;
     475                using CppAD::NearEqual;
     476                double eps10 = 10.0 * std::numeric_limits<double>::epsilon();
    465477                size_t original;
    466478                size_t opt;
     
    491503                depend_fun(x, check, original, opt);
    492504                for(i = 0; i < m; i++)
    493                         ok &= NearEqual(y[i], check[i], eps_, eps_);
     505                        ok &= NearEqual(y[i], check[i], eps10, eps10);
    494506
    495507                // Check size before optimization
     
    509521                y = F.Forward(0, x);
    510522                for(i = 0; i < m; i++)
    511                         ok &= NearEqual(y[i], check[i], eps_, eps_);
     523                        ok &= NearEqual(y[i], check[i], eps10, eps10);
    512524
    513525                return ok;
     
    518530                bool ok = true;
    519531                using CppAD::AD;
     532                using CppAD::NearEqual;
     533                double eps10 = 10.0 * std::numeric_limits<double>::epsilon();
    520534                size_t i, j;
    521535
     
    571585                for(i = 0; i < m; i++)
    572586                {       if( i != static_cast<size_t>(x[0]) )
    573                                 ok &= (y[i] == 0.);
    574                         else    ok &= (y[i] == x[1]);
     587                                ok &= NearEqual(y[i], 0., eps10, eps10);
     588                        else    ok &= NearEqual(y[i], x[1], eps10, eps10);
    575589                }
    576590
     
    585599                for(i = 0; i < m; i++)
    586600                {       if( i != static_cast<size_t>(x[0]) )
    587                                 ok &= (y[i] == 0.);
    588                         else    ok &= (y[i] == x[1]);
     601                                ok &= NearEqual(y[i], 0., eps10, eps10);
     602                        else    ok &= NearEqual(y[i], x[1], eps10, eps10);
    589603                }
    590604
     
    595609                bool ok = true;
    596610                using CppAD::AD;
     611                using CppAD::NearEqual;
     612                double eps10 = 10.0 * std::numeric_limits<double>::epsilon();
    597613                using CppAD::vector;
    598614
     
    623639                // (This may not be true for some compiler in the future).
    624640                for(j = 0; j < n; j++)
    625                         ok &= ( y[j] == Value(Y[j]) );
     641                        ok &= NearEqual(y[j], Value(Y[j]), eps10, eps10);
    626642
    627643                // check reverse mode derivative
     
    633649
    634650                double check = x[1] * pow( x[0], x[1] - 1. );
    635                 ok &= NearEqual( dw[0], check, eps_, eps_ );
     651                ok &= NearEqual( dw[0], check, eps10, eps10 );
    636652
    637653                check = log( x[0] ) * pow( x[0], x[1] );
    638                 ok &= NearEqual( dw[1], check, eps_, eps_ );
     654                ok &= NearEqual( dw[1], check, eps10, eps10 );
    639655
    640656                check = 0.;
    641                 ok &= NearEqual( dw[2], check, eps_, eps_ );
     657                ok &= NearEqual( dw[2], check, eps10, eps10 );
    642658
    643659                return ok;
     
    648664# if CPPAD_USE_CPLUSPLUS_2011
    649665                using CppAD::AD;
     666                using CppAD::NearEqual;
     667                double eps10 = 10.0 * std::numeric_limits<double>::epsilon();
    650668                using CppAD::vector;
    651669
     
    670688                ok &= F.size_var() + 5 == size_original;
    671689                vector<double> y = F.Forward(0, x);
    672                 ok &=  NearEqual(y[0], y_original[0], eps_, eps_);
     690                ok &=  NearEqual(y[0], y_original[0], eps10, eps10);
    673691# endif
    674692                return ok;
     
    751769                bool ok = true;
    752770                using CppAD::AD;
     771                using CppAD::NearEqual;
     772                double eps10 = 10.0 * std::numeric_limits<double>::epsilon();
    753773                size_t original;
    754774                size_t opt;
     
    779799                duplicate_fun(x, check, original, opt);
    780800                for(i = 0; i < m; i++)
    781                         ok &= NearEqual(y[i], check[i], eps_, eps_);
     801                        ok &= NearEqual(y[i], check[i], eps10, eps10);
    782802
    783803                // Check size before optimization
     
    797817                y = F.Forward(0, x);
    798818                for(i = 0; i < m; i++)
    799                         ok &= NearEqual(y[i], check[i], eps_, eps_);
     819                        ok &= NearEqual(y[i], check[i], eps10, eps10);
    800820
    801821                return ok;
     
    807827                bool ok = true;
    808828                using CppAD::AD;
     829                using CppAD::NearEqual;
     830                double eps10 = 10.0 * std::numeric_limits<double>::epsilon();
    809831                size_t i, j;
    810832
     
    852874                y   = F.Forward(0, x);
    853875                for(i = 0; i < m; i++)
    854                         ok &= ( y[i] == Value( Y[i] ) );
     876                        ok &= NearEqual(y[i], Value(Y[i]), eps10, eps10);
    855877
    856878                if( conditional_skip_ )
     
    864886                y   = F.Forward(0, x);
    865887                for(i = 0; i < m; i++)
    866                         ok &= ( y[i] == Value( Y[i] ) );
     888                        ok &= NearEqual(y[i], Value(Y[i]), eps10, eps10);
    867889
    868890                return ok;
     
    874896                bool ok = true;
    875897                using CppAD::AD;
     898                using CppAD::NearEqual;
     899                double eps10 = 10.0 * std::numeric_limits<double>::epsilon();
    876900                size_t i, j;
    877901
     
    919943                y   = F.Forward(0, x);
    920944                for(i = 0; i < m; i++)
    921                         ok &= ( y[i] == Value( Y[i] ) );
     945                        ok &= NearEqual(y[i], Value(Y[i]), eps10, eps10);
    922946
    923947                if( conditional_skip_ )
     
    931955                y   = F.Forward(0, x);
    932956                for(i = 0; i < m; i++)
    933                         ok &= ( y[i] == Value( Y[i] ) );
     957                        ok &= NearEqual(y[i], Value(Y[i]), eps10, eps10);
    934958
    935959                return ok;
     
    941965                bool ok = true;
    942966                using CppAD::AD;
     967                using CppAD::NearEqual;
     968                double eps10 = 10.0 * std::numeric_limits<double>::epsilon();
    943969                size_t j;
    944970
     
    9751001
    9761002                y   = F.Forward(0, x);
    977                 ok &= ( y[0] == Value( Y[0] ) );
     1003                ok &= NearEqual(y[0], Value(Y[0]), eps10, eps10);
    9781004
    9791005                if( conditional_skip_ )
     
    9861012
    9871013                y   = F.Forward(0, x);
    988                 ok &= ( y[0] == Value( Y[0] ) );
     1014                ok &= NearEqual(y[0], Value(Y[0]), eps10, eps10);
    9891015
    9901016                return ok;
     
    9961022                bool ok = true;
    9971023                using CppAD::AD;
     1024                using CppAD::NearEqual;
     1025                double eps10 = 10.0 * std::numeric_limits<double>::epsilon();
    9981026                size_t i, j;
    9991027
     
    10411069                y   = F.Forward(0, x);
    10421070                for(i = 0; i < m; i++)
    1043                         ok &= ( y[i] == Value( Y[i] ) );
     1071                        ok &= NearEqual(y[i], Value(Y[i]), eps10, eps10);
    10441072
    10451073                if( conditional_skip_ )
     
    10531081                y   = F.Forward(0, x);
    10541082                for(i = 0; i < m; i++)
    1055                         ok &= ( y[i] == Value( Y[i] ) );
     1083                        ok &= NearEqual(y[i], Value(Y[i]), eps10, eps10);
    10561084
    10571085                return ok;
     
    10621090
    10631091                using namespace CppAD;
     1092                using CppAD::NearEqual;
     1093                double eps10 = 10.0 * std::numeric_limits<double>::epsilon();
    10641094
    10651095                // independent variable vector
     
    10881118                x0[1]    = 4.;
    10891119                y0       = F.Forward(0, x0);
    1090                 ok      &= NearEqual(y0[0] , x0[0]+x0[0]+x0[1], eps_, eps_);
     1120                ok      &= NearEqual(y0[0] , x0[0]+x0[0]+x0[1], eps10, eps10);
    10911121
    10921122                // evaluate derivative of F in X[0] direction
     
    10961126                x1[1]    = 0.;
    10971127                y1       = F.Forward(1, x1);
    1098                 ok      &= NearEqual(y1[0] , x1[0]+x1[0]+x1[1], eps_, eps_);
     1128                ok      &= NearEqual(y1[0] , x1[0]+x1[0]+x1[1], eps10, eps10);
    10991129
    11001130                // evaluate second derivative of F in X[0] direction
     
    11051135                y2          = F.Forward(2, x2);
    11061136                double F_00 = 2. * y2[0];
    1107                 ok         &= NearEqual(F_00, 0., eps_, eps_);
     1137                ok         &= NearEqual(F_00, 0., eps10, eps10);
    11081138
    11091139                return ok;
     
    11141144
    11151145                using namespace CppAD;
     1146                using CppAD::NearEqual;
     1147                double eps10 = 10.0 * std::numeric_limits<double>::epsilon();
    11161148
    11171149                // independent variable vector
     
    11401172                x0[1]    = 4.;
    11411173                y0       = F.Forward(0, x0);
    1142                 ok      &= NearEqual(y0[0] , x0[0]-x0[0]+x0[1], eps_, eps_);
     1174                ok      &= NearEqual(y0[0] , x0[0]-x0[0]+x0[1], eps10, eps10);
    11431175
    11441176                // evaluate derivative of F
     
    11471179                w[0]    = 1.;
    11481180                dF      = F.Reverse(1, w);
    1149                 ok     &= NearEqual(dF[0] , 0., eps_, eps_);
    1150                 ok     &= NearEqual(dF[1] , 1., eps_, eps_);
     1181                ok     &= NearEqual(dF[0] , 0., eps10, eps10);
     1182                ok     &= NearEqual(dF[1] , 1., eps10, eps10);
    11511183
    11521184                return ok;
     
    13001332                for(i = 0; i < m; i++)
    13011333                {       for(j = 0; j < m; j++)
    1302                                 Py[ i * m + j ] = (i == j);
     1334                                Py[ i * m + j ] = i == j;
    13031335                }
    13041336
     
    13101342                for(i = 0; i < m; i++)
    13111343                {       for(j = 0; j < n; j++)
    1312                                 ok &= (Px[i * n + j] == Check[i * n + j]);
     1344                                ok &= Px[i * n + j] == Check[i * n + j];
    13131345                }
    13141346
     
    13581390                for(i = 0; i < n; i++)
    13591391                        for(j = 0; j < n; j++)
    1360                                 Px[ i * n + j ] = (i == j);
     1392                                Px[ i * n + j ] = i == j;
    13611393
    13621394                // compute sparsity pattern for Jacobian of F(U(x))
     
    13791411        {       bool ok = true;
    13801412                using CppAD::AD;
     1413                using CppAD::NearEqual;
     1414                double eps10 = 10.0 * std::numeric_limits<double>::epsilon();
    13811415
    13821416                AD<double> zero(0.), one(1.), two(2.), three(3.);
     
    14101444
    14111445                if( x[0] + .5 < 1. )
    1412                         ok  &= y[0] == 2.;
    1413                 else    ok  &= y[0] == 3.;
     1446                        ok &= NearEqual(y[0], 2., eps10, eps10);
     1447                else    ok &= NearEqual(y[0], 3., eps10, eps10);
    14141448                if( 0. < x[1] + .5 )
    1415                         ok  &= y[1] == 2.;
    1416                 else    ok  &= y[1] == 3.;
    1417                 ok  &= y[2] == x[2] + .5;;
    1418                 ok  &= y[3] == 2.;
     1449                        ok &= NearEqual(y[1], 2., eps10, eps10);
     1450                else    ok &= NearEqual(y[1], 3., eps10, eps10);
     1451                ok &= NearEqual(y[2], x[2] + .5, eps10, eps10);;
     1452                ok &= NearEqual(y[3], 2., eps10, eps10);
    14191453
    14201454                return ok;
     
    14251459        {       bool ok = true;
    14261460                using CppAD::AD;
     1461                using CppAD::NearEqual;
     1462                double eps10 = 10.0 * std::numeric_limits<double>::epsilon();
    14271463                AD<double> zero(0.);
    14281464
     
    14481484                x[0] = 1.0;
    14491485                y    = f.Forward(0, x);
    1450                 ok &= NearEqual(y[0], false_case, eps_, eps_);
     1486                ok &= NearEqual(y[0], false_case, eps10, eps10);
    14511487
    14521488                w[0] = 1.0;
    14531489                dw   = f.Reverse(1, w);
    14541490                // derivative of cos is minus sin
    1455                 ok &= NearEqual(dw[0], - true_case, eps_, eps_);
     1491                ok &= NearEqual(dw[0], - true_case, eps10, eps10);
    14561492
    14571493                return ok;
     
    14801516
    14811517                if( vy.size() > 0 )
    1482                 {       vy[0] = (vx[0] | vx[1]);
    1483                         vy[1] = (vx[1] | vx[2]);
     1518                {       vy[0] = vx[0] | vx[1];
     1519                        vy[1] = vx[1] | vx[2];
    14841520                }
    14851521                return true;
     
    15541590
    15551591                using CppAD::AD;
     1592                using CppAD::NearEqual;
     1593                double eps10 = 10.0 * std::numeric_limits<double>::epsilon();
    15561594                size_t j;
    15571595                size_t n = 3;
     
    15811619                y = g.Forward(0, x);
    15821620                // y[0] = x[0] + x[1]
    1583                 ok &= (y[0] == x[0] + x[1]);
     1621                ok &= NearEqual(y[0], x[0] + x[1], eps10, eps10);
    15841622                // y[1] = x[1] + x[2]
    1585                 ok &= (y[0] == x[0] + x[1]);
     1623                ok &= NearEqual(y[0], x[0] + x[1], eps10, eps10);
    15861624
    15871625                return ok;
     
    16261664        {       bool ok = true;
    16271665                using CppAD::vector;
     1666                using CppAD::NearEqual;
     1667                double eps10 = 10.0 * std::numeric_limits<double>::epsilon();
    16281668
    16291669                vector< CppAD::AD<double> > ax(1), ay(1);
     
    16441684                x[0] = -2.2;
    16451685                y    = f.Forward(0, x);
    1646                 ok &= y[0] == -6.0;
     1686                ok &= NearEqual(y[0], -6.0, eps10, eps10);
    16471687
    16481688                return ok;
     
    16581698        {       bool ok = true;
    16591699                using CppAD::AD;
     1700                using CppAD::NearEqual;
     1701                double eps10 = 10.0 * std::numeric_limits<double>::epsilon();
    16601702                using CppAD::vector;
    16611703
     
    16941736                y_after   = f.Forward(0, x);
    16951737
    1696                 ok &= y_before[0] == y_after[0];
     1738                ok &= NearEqual(y_before[0], y_after[0], eps10, eps10);
    16971739
    16981740                return ok;
     
    17041746        {       bool ok = true;
    17051747                using CppAD::AD;
     1748                using CppAD::NearEqual;
     1749                double eps10 = 10.0 * std::numeric_limits<double>::epsilon();
    17061750                using CppAD::vector;
    17071751
     
    17391783                dy_after  = f.Forward(1, dx);
    17401784
    1741                 ok &= y_before[0]  == y_after[0];
    1742                 ok &= dy_before[0] == dy_after[0];
     1785                ok &= NearEqual(y_before[0] , y_after[0], eps10, eps10);
     1786                ok &= NearEqual(dy_before[0], dy_after[0], eps10, eps10);
    17431787
    17441788                return ok;
     
    17581802                using CppAD::vector;
    17591803                using CppAD::AD;
     1804                using CppAD::NearEqual;
     1805                double eps10 = 10.0 * std::numeric_limits<double>::epsilon();
    17601806
    17611807                vector< AD<double> > ax(n), ay(1);
     
    17791825                for(size_t j = 0; j < n; j++)
    17801826                {       if( j == n-1 )
    1781                                 ok &= dx[j] == 2.0;
     1827                                ok &= NearEqual(dx[j], 2.0, eps10, eps10);
    17821828                        else
    1783                                 ok &= dx[j] == 0.0;
     1829                                ok &= NearEqual(dx[j], 0.0, eps10, eps10);
    17841830                }
    17851831                return ok;
     
    17911837                using CppAD::vector;
    17921838                using CppAD::AD;
     1839                using CppAD::NearEqual;
     1840                double eps10 = 10.0 * std::numeric_limits<double>::epsilon();
    17931841
    17941842                // f(x) = x[0] + x[0] if x[0] >= 3
     
    18171865                x[1] = 2.0;
    18181866                y    = f.Forward(0, x);
    1819                 ok  &= y[0] == x[0] + x[1];
    1820                 ok  &= y[1] == x[0] - x[1];
    1821                 ok  &= y[2] == exp(x[0]);
     1867                ok &= NearEqual(y[0], x[0] + x[1], eps10, eps10);
     1868                ok &= NearEqual(y[1], x[0] - x[1], eps10, eps10);
     1869                ok &= NearEqual(y[2], exp(x[0]), eps10, eps10);
    18221870
    18231871                // check case where x[0] < 3
     
    18251873                x[1] = 2.0;
    18261874                y    = f.Forward(0, x);
    1827                 ok  &= y[0] == x[0] + x[1];
    1828                 ok  &= y[1] == x[0] - x[1];
    1829                 ok  &= y[2] == exp(x[0]);
     1875                ok &= NearEqual(y[0], x[0] + x[1], eps10, eps10);
     1876                ok &= NearEqual(y[1], x[0] - x[1], eps10, eps10);
     1877                ok &= NearEqual(y[2], exp(x[0]), eps10, eps10);
    18301878
    18311879                return ok;
  • trunk/test_more/pow.cpp

    r3779 r3856  
    11// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    2323        using CppAD::AD;
    2424        using CppAD::NearEqual;
     25        double eps99 = 99.0 * std::numeric_limits<double>::epsilon();
    2526
    2627        // domain space vector
     
    4950        size_t i;
    5051        for(i = 0; i < m; i++)
    51                 ok &= NearEqual(Z[i] , check,  1e-10 , 1e-10);
     52                ok &= NearEqual(Z[i] , check, eps99, eps99);
    5253
    5354        // forward computation of first partial w.r.t. x
     
    5859        dz    = f.Forward(1, dxy);
    5960        check = y * std::pow(x, y-1.);
    60         ok   &= NearEqual(dz[0], check, 1e-10, 1e-10);
    61         ok   &= NearEqual(dz[1], check, 1e-10, 1e-10);
    62         ok   &= NearEqual(dz[2],    0., 1e-10, 1e-10);
     61        ok   &= NearEqual(dz[0], check, eps99, eps99);
     62        ok   &= NearEqual(dz[1], check, eps99, eps99);
     63        ok   &= NearEqual(dz[2],    0., eps99, eps99);
    6364
    6465        // forward computation of first partial w.r.t. y
     
    6768        dz    = f.Forward(1, dxy);
    6869        check = std::log(x) * std::pow(x, y);
    69         ok   &= NearEqual(dz[0], check, 1e-10, 1e-10);
    70         ok   &= NearEqual(dz[1],    0., 1e-10, 1e-10);
    71         ok   &= NearEqual(dz[2], check, 1e-10, 1e-10);
     70        ok   &= NearEqual(dz[0], check, eps99, eps99);
     71        ok   &= NearEqual(dz[1],    0., eps99, eps99);
     72        ok   &= NearEqual(dz[2], check, eps99, eps99);
    7273
    7374        // reverse computation of derivative of z[0] + z[1] + z[2]
     
    7980        dw    = f.Reverse(1, w);
    8081        check = y * std::pow(x, y-1.);
    81         ok   &= NearEqual(dw[0], 2. * check, 1e-10, 1e-10);
     82        ok   &= NearEqual(dw[0], 2. * check, eps99, eps99);
    8283        check = std::log(x) * std::pow(x, y);
    83         ok   &= NearEqual(dw[1], 2. * check, 1e-10, 1e-10);
     84        ok   &= NearEqual(dw[1], 2. * check, eps99, eps99);
    8485
    8586        // use a VecAD<Base>::reference object with pow
     
    9091        v[one]            = XY[1];
    9192        AD<double> result = CppAD::pow(v[zero], v[one]);
    92         ok               &= NearEqual(result, Z[0], 1e-10, 1e-10);
     93        ok               &= NearEqual(result, Z[0], eps99, eps99);
    9394
    9495        return ok;
     
    101102        using CppAD::exp;
    102103        using namespace CppAD;
     104        using CppAD::NearEqual;
     105        double eps99 = 99.0 * std::numeric_limits<double>::epsilon();
    103106
    104107
     
    137140
    138141        // check values
    139         ok &= NearEqual(Z[x] , exp(2. * 3.),              1e-10 , 1e-10);
    140         ok &= NearEqual(Z[y] , exp( 2. * 3. * exp(2.) ),  1e-10 , 1e-10);
     142        ok &= NearEqual(Z[x] , exp(2. * 3.), eps99, eps99);
     143        ok &= NearEqual(Z[y] , exp( 2. * 3. * exp(2.) ), eps99, eps99);
    141144
    142145        // forward computation of partials w.r.t. s
     
    190193        using CppAD::AD;
    191194        using CppAD::NearEqual;
     195        double eps99 = 99.0 * std::numeric_limits<double>::epsilon();
    192196
    193197        // domain space vector
     
    225229        ok   &= (dy[0] == 0.);
    226230        ok   &= (dy[1] == 0.);
    227         ok   &= NearEqual(dy[2], 1., 1e-10, 1e-10);
     231        ok   &= NearEqual(dy[2], 1., eps99, eps99);
    228232        ok   &= (dy[3] == 0.);
    229233
     
    236240        w[3] = 1.;
    237241        dw   = f.Reverse(1, w);
    238         ok  &= NearEqual(dw[0], 1., 1e-10, 1e-10);
     242        ok  &= NearEqual(dw[0], 1., eps99, eps99);
    239243
    240244        return ok;
     
    246250        using CppAD::AD;
    247251        using CppAD::NearEqual;
     252        double eps99 = 99.0 * std::numeric_limits<double>::epsilon();
    248253
    249254        // domain space vector
     
    273278        for(i = 1; i < m; i++)
    274279        {       check = std::pow(x0, double(i-1));
    275                 ok   &= NearEqual(y[i], check, 1e-10, 1e-10);
     280                ok   &= NearEqual(y[i], check, eps99, eps99);
    276281        }
    277282
     
    287292                        check = 0.;
    288293                else    check = double(i-1) * std::pow(x0, double(i-2));
    289                 ok   &= NearEqual(dy[i], check, 1e-10, 1e-10);
     294                ok   &= NearEqual(dy[i], check, eps99, eps99);
    290295                sum  += check;
    291296        }
     
    297302                w[i] = 1.;
    298303        dw   = f.Reverse(1, w);
    299         ok  &= NearEqual(dw[0], sum, 1e-10, 1e-10);
     304        ok  &= NearEqual(dw[0], sum, eps99, eps99);
    300305
    301306        return ok;
     
    306311        using CppAD::AD;
    307312        using CppAD::NearEqual;
     313        double eps99 = 99.0 * std::numeric_limits<double>::epsilon();
    308314
    309315        // domain space vector
     
    336342        dx[0] = 1.;
    337343        dy    = f.Forward(1, dx);
    338         ok   &= NearEqual(dy[0], d1, 1e-10, 1e-10);
     344        ok   &= NearEqual(dy[0], d1, eps99, eps99);
    339345
    340346        // reverse mode computation of second partials
     
    345351        w[0] = 1.;
    346352        ddw  = f.Reverse(2, w);
    347         ok  &= NearEqual(ddw[0], d1, 1e-10, 1e-10);
    348         ok  &= NearEqual(ddw[1], d2, 1e-10, 1e-10);
     353        ok  &= NearEqual(ddw[0], d1, eps99, eps99);
     354        ok  &= NearEqual(ddw[1], d2, eps99, eps99);
    349355
    350356        return ok;
     
    355361        using CppAD::AD;
    356362        using CppAD::NearEqual;
     363        double eps99 = 99.0 * std::numeric_limits<double>::epsilon();
    357364
    358365        // domain space vector
     
    381388
    382389        // check function value
    383         ok  &= (Value( Value(Y[0]) ) == pow(x0, e) );
     390        ok  &= NearEqual(Value(Value(Y[0])), pow(x0, e), eps99, eps99);
    384391
    385392        // forward computation of first partial w.r.t. x[1]
     
    389396        dx[0] = 1.;
    390397        dy    = F.Forward(1, dx);
    391         ok   &= NearEqual(dy[0], d1, 1e-10, 1e-10);
     398        ok   &= NearEqual(dy[0], d1, eps99, eps99);
    392399
    393400        // reverse mode computation of second partials
     
    398405        w[0] = 1.;
    399406        ddw  = F.Reverse(2, w);
    400         ok  &= NearEqual(ddw[0], d1, 1e-10, 1e-10);
    401         ok  &= NearEqual(ddw[1], d2, 1e-10, 1e-10);
     407        ok  &= NearEqual(ddw[0], d1, eps99, eps99);
     408        ok  &= NearEqual(ddw[1], d2, eps99, eps99);
    402409
    403410        return ok;
  • trunk/test_more/rev_two.cpp

    r3757 r3856  
    11// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    1717        using CppAD::vector;
    1818        using CppAD::NearEqual;
     19        double eps99 = 99.0 * std::numeric_limits<double>::epsilon();
    1920
    2021
     
    4142        J[0] = 0;
    4243        H    = F.RevTwo(x, I, J);
    43         ok  &= NearEqual(H[0], 2., 1e-10, 1e-10);
    44         ok  &= NearEqual(H[1], 1., 1e-10, 1e-10);
     44        ok  &= NearEqual(H[0], 2., eps99, eps99);
     45        ok  &= NearEqual(H[1], 1., eps99, eps99);
    4546        J[0] = 1;
    4647        H    = F.RevTwo(x, I, J);
    47         ok  &= NearEqual(H[0], 1., 1e-10, 1e-10);
    48         ok  &= NearEqual(H[1], 4., 1e-10, 1e-10);
     48        ok  &= NearEqual(H[0], 1., eps99, eps99);
     49        ok  &= NearEqual(H[1], 4., eps99, eps99);
    4950
    5051        return ok;
  • trunk/test_more/rosen_34.cpp

    r3779 r3856  
    11// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    8181
    8282        using namespace CppAD;
     83        using CppAD::NearEqual;
     84        double eps99 = 99.0 * std::numeric_limits<double>::epsilon();
    8385
    8486        CPPAD_TESTVECTOR(AD<double>) x(3);
     
    121123
    122124        AD<double> x2 = w[2] * t1 * t1 / 2.;
    123         ok &= NearEqual(x[2],  x2, 1e-14, 1e-14);
     125        ok &= NearEqual(x[2],  x2, eps99, eps99);
    124126
    125127        // check dx[0] / dw[0]
     
    140142        q[2] = 1.;
    141143        r    = f.Forward(1, q);
    142         ok &= NearEqual(r[2], x2 / w[2],  1e-14, 1e-14 );
     144        ok &= NearEqual(r[2], x2 / w[2], eps99, eps99);
    143145
    144146        return ok;
  • trunk/test_more/runge_45.cpp

    r3779 r3856  
    11// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    5151
    5252        using namespace CppAD;
     53        using CppAD::NearEqual;
     54        double eps99 = 99.0 * std::numeric_limits<double>::epsilon();
    5355
    5456        size_t i;
     
    9193        AD<double> xi2 = exp(w[0]);
    9294        for(i = 0; i < n-1; i++)
    93         {       ok &= NearEqual(x[i],  xi2, 1e-14, 1e-14);
     95        {       ok &= NearEqual(x[i],  xi2, eps99, eps99);
    9496                if( i < n-2 )
    9597                        xi2 *= w[i+1] * 2. / double(i+1);
     
    98100        // x[n-1](2) = exp(2 * w[0]) * w[1] * 2^2 / 2
    99101        xi2 = exp(2. * w[0]) * w[1] * 2.;
    100         ok &= NearEqual(x[n-1], xi2, 1e-14, 1e-14);
     102        ok &= NearEqual(x[n-1], xi2, eps99, eps99);
    101103
    102104        // the partial of x[i](2) with respect to w[j] is
     
    117119                {       // check partial of x[i] w.r.t w[j]
    118120                        if (j == 0 )
    119                                 ok &= NearEqual(q[j], x[i], 1e-14, 1e-14);
     121                                ok &= NearEqual(q[j], x[i], eps99, eps99);
    120122                        else if( j <= i  )
    121123                                ok &= NearEqual(
    122124                                        q[j], x[i]/w[j], 1e-14, 1e-14);
    123                         else    ok &= NearEqual(q[j], 0., 1e-14, 1e-14);
     125                        else    ok &= NearEqual(q[j], 0., eps99, eps99);
    124126                }
    125127        }
     
    135137        {       // check partial of x[n-1] w.r.t w[j]
    136138                if (j == 0 )
    137                         ok &= NearEqual(q[j], 2.*x[i], 1e-14, 1e-14);
     139                        ok &= NearEqual(q[j], 2.*x[i], eps99, eps99);
    138140                else if( j == 1  )
    139141                        ok &= NearEqual(
    140142                                q[j], x[i]/w[1], 1e-14, 1e-14);
    141                 else    ok &= NearEqual(q[j], 0., 1e-14, 1e-14);
     143                else    ok &= NearEqual(q[j], 0., eps99, eps99);
    142144        }
    143145
  • trunk/test_more/sparse_hessian.cpp

    r3779 r3856  
    11// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    2323        using CppAD::NearEqual;
    2424        size_t i, j, k, ell;
    25         double eps = 10. * CppAD::epsilon<double>();
     25        double eps10 = 10. * CppAD::epsilon<double>();
    2626
    2727        size_t n = 12; // must be greater than or equal 3; see n_sweep.
     
    9191        for(k = 0; k < K; k++)
    9292        {       ell = r[k] * n + c[k];
    93                 ok &=  NearEqual(check[ell], hes[k], eps, eps);
     93                ok &=  NearEqual(check[ell], hes[k], eps10, eps10);
    9494                ell = c[k] * n + r[k];
    95                 ok &=  NearEqual(check[ell], hes[k], eps, eps);
     95                ok &=  NearEqual(check[ell], hes[k], eps10, eps10);
    9696        }
    9797
  • trunk/test_more/sparse_jacobian.cpp

    r3757 r3856  
    11// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    2323        using CppAD::NearEqual;
    2424        size_t i, j, k, ell;
    25         double eps = 10. * CppAD::epsilon<double>();
     25        double eps10 = 10. * CppAD::epsilon<double>();
    2626
    2727        // domain space vector
     
    9292        for(k = 0; k < K; k++)
    9393        {       ell = r[k] * n + c[k];
    94                 ok &=  NearEqual(check[ell], jac[k], eps, eps);
     94                ok &=  NearEqual(check[ell], jac[k], eps10, eps10);
    9595        }
    9696        work.clear();
     
    9999        for(k = 0; k < K; k++)
    100100        {       ell = r[k] * n + c[k];
    101                 ok &=  NearEqual(check[ell], jac[k], eps, eps);
     101                ok &=  NearEqual(check[ell], jac[k], eps10, eps10);
    102102        }
    103103
     
    111111        using CppAD::NearEqual;
    112112        size_t i, j, k, ell;
    113         double eps = 10. * CppAD::epsilon<double>();
     113        double eps10 = 10. * CppAD::epsilon<double>();
    114114
    115115        // domain space vector
     
    164164        for(k = 0; k < 3; k++)
    165165        {       ell = r[k] * n + c[k];
    166                 ok &=  NearEqual(check[ell], jac[k], eps, eps);
     166                ok &=  NearEqual(check[ell], jac[k], eps10, eps10);
    167167        }
    168168        ok &= (n_sweep == 1);
     
    179179        for(k = 0; k < 4; k++)
    180180        {       ell = r[k] * n + c[k];
    181                 ok &=  NearEqual(check[ell], jac[k], eps, eps);
     181                ok &=  NearEqual(check[ell], jac[k], eps10, eps10);
    182182        }
    183183        ok &= (n_sweep == 1);
     
    191191        using CppAD::NearEqual;
    192192        size_t j, k, ell;
    193         double eps = 10. * CppAD::epsilon<double>();
     193        double eps10 = 10. * CppAD::epsilon<double>();
    194194
    195195        // domain space vector
     
    242242        for(k = 0; k < 3; k++)
    243243        {       ell = r[k] * n + c[k];
    244                 ok &=  NearEqual(check[ell], jac[k], eps, eps);
     244                ok &=  NearEqual(check[ell], jac[k], eps10, eps10);
    245245        }
    246246        ok &= (n_sweep == 1);
     
    257257        for(k = 0; k < 4; k++)
    258258        {       ell = r[k] * n + c[k];
    259                 ok &=  NearEqual(check[ell], jac[k], eps, eps);
     259                ok &=  NearEqual(check[ell], jac[k], eps10, eps10);
    260260        }
    261261        ok &= (n_sweep == 1);
  • trunk/test_more/test_vector.cpp

    r3779 r3856  
    11// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    2121        using CppAD::AD;
    2222        using CppAD::NearEqual;
     23        double eps99 = 99.0 * std::numeric_limits<double>::epsilon();
    2324
    2425        // domain space vector
     
    4647
    4748        // check value
    48         ok &= NearEqual(y[0] , 2. * x0 + 10,  1e-10 , 1e-10);
     49        ok &= NearEqual(y[0] , 2. * x0 + 10, eps99, eps99);
    4950
    5051        // forward computation of partials w.r.t. x[0]
     
    5354        dx[0] = 1.;
    5455        dy    = f.Forward(1, dx);
    55         ok   &= NearEqual(dy[0], 2., 1e-10, 1e-10);
     56        ok   &= NearEqual(dy[0], 2., eps99, eps99);
    5657
    5758        // reverse computation of derivative of y[0]
     
    6061        w[0]  = 1.;
    6162        dw    = f.Reverse(1, w);
    62         ok   &= NearEqual(dw[0], 2., 1e-10, 1e-10);
     63        ok   &= NearEqual(dw[0], 2., eps99, eps99);
    6364
    6465        // use a VecAD<Base>::reference object with addition
  • trunk/test_more/vec_unary.cpp

    r3779 r3856  
    11// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    2828        using CppAD::log;
    2929        using CppAD::sqrt;
     30        using CppAD::NearEqual;
     31        double eps99 = 99.0 * std::numeric_limits<double>::epsilon();
    3032
    3133        bool ok  = true;
     
    8789        z    = f.Forward(0, x);
    8890
    89         ok  &= NearEqual(z[0],      - x[0],  1e-10, 1e-10);
    90         ok  &= NearEqual(z[1], sin( x[1] ),  1e-10, 1e-10);
    91         ok  &= NearEqual(z[2], abs( x[2] ),  1e-10, 1e-10);
    92         ok  &= NearEqual(z[3], atan(x[3] ),  1e-10, 1e-10);
    93         ok  &= NearEqual(z[4], cos( x[4] ),  1e-10, 1e-10);
    94         ok  &= NearEqual(z[5], exp( x[5] ),  1e-10, 1e-10);
    95         ok  &= NearEqual(z[6], log( x[6] ),  1e-10, 1e-10);
    96         ok  &= NearEqual(z[7], sqrt(x[7] ),  1e-10, 1e-10);
     91        ok  &= NearEqual(z[0],      - x[0], eps99, eps99);
     92        ok  &= NearEqual(z[1], sin( x[1] ), eps99, eps99);
     93        ok  &= NearEqual(z[2], abs( x[2] ), eps99, eps99);
     94        ok  &= NearEqual(z[3], atan(x[3] ), eps99, eps99);
     95        ok  &= NearEqual(z[4], cos( x[4] ), eps99, eps99);
     96        ok  &= NearEqual(z[5], exp( x[5] ), eps99, eps99);
     97        ok  &= NearEqual(z[6], log( x[6] ), eps99, eps99);
     98        ok  &= NearEqual(z[7], sqrt(x[7] ), eps99, eps99);
    9799
    98100        return ok;
Note: See TracChangeset for help on using the changeset viewer.