Changeset 3869 for trunk/test_more


Ignore:
Timestamp:
Jan 19, 2017 12:15:34 PM (3 years ago)
Author:
bradbell
Message:

merge to branch: trunk
from repository: https://github.com/coin-or/CppAD
start hash code: 3e11637d2e790028f4b85c26be60baeb03999032
end hash code: 0c9a72f937c85198e73fb532438dcd274c4db9c0

commit 0c9a72f937c85198e73fb532438dcd274c4db9c0
Author: Brad Bell <bradbell@…>
Date: Thu Jan 19 10:12:43 2017 -0700

  1. Convert rest of 1e-10 checks, not in introduction, to a multiple of machine epsilon.
  2. Advance version to 20170119.

commit 53f92f04439c2c44a001e6f99e0b282316d098e7
Author: Brad Bell <bradbell@…>
Date: Thu Jan 19 05:40:03 2017 -0700

Advance stable release from 20170000.0 -> 20170000.1
new_release.sh: check that changes get correct date in stable versions.

Location:
trunk/test_more
Files:
30 edited

Legend:

Unmodified
Added
Removed
  • trunk/test_more/acos.cpp

    r3680 r3869  
    1 /* $Id$ */
    21/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     2CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-17 Bradley M. Bell
    43
    54CppAD is distributed under multiple licenses. This distribution is under
     
    1817bool acos(void)
    1918{       bool ok = true;
    20 
    2119        using CppAD::acos;
    2220        using namespace CppAD;
     21        double eps99 = 99.0 * std::numeric_limits<double>::epsilon();
    2322
    2423        // independent variable vector
     
    4039
    4140        // check value
    42         ok &= NearEqual(U[0] , Z[0],  1e-10 , 1e-10);
     41        ok &= NearEqual(U[0] , Z[0],  eps99 , eps99);
    4342
    4443        // forward computation of partials w.r.t. u
     
    5150        {       jfac *= j;
    5251                w     = f.Forward(j, v);
    53                 ok &= NearEqual(jfac*w[0], value, 1e-10 , 1e-10); // d^jz/du^j
     52                ok &= NearEqual(jfac*w[0], value, jfac*eps99 , jfac*eps99);// d^jz/du^j
    5453                v[0]  = 0.;
    5554                value = 0.;
     
    6362        value = 1.;
    6463        for(j = 0; j < p; j++)
    65         {       ok &= NearEqual(jfac*r[j], value, 1e-10 , 1e-10); // d^jz/du^j
     64        {       ok &= NearEqual(jfac*r[j], value, jfac*eps99 , jfac*eps99);// d^jz/du^j
    6665                jfac *= (j + 1);
    6766                value = 0.;
  • trunk/test_more/add.cpp

    r3779 r3869  
    1 // $Id$
    21/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     2CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-17 Bradley M. Bell
    43
    54CppAD is distributed under multiple licenses. This distribution is under
     
    7574bool AddTestTwo(void)
    7675{       bool ok = true;
    77 
    7876        using namespace CppAD;
     77        double eps99 = 99.0 * std::numeric_limits<double>::epsilon();
    7978
    8079        // independent variable vector
     
    9998
    10099        // check value
    101         ok &= NearEqual(Z[0] , 2 * u0 + 10,  1e-10 , 1e-10);
     100        ok &= NearEqual(Z[0] , 2 * u0 + 10,  eps99 , eps99);
    102101
    103102        // forward computation of partials w.r.t. u
     
    110109        {       jfac *= j;
    111110                w     = f.Forward(j, v);
    112                 ok &= NearEqual(jfac*w[0], value, 1e-10 , 1e-10); // d^jz/du^j
     111                ok &= NearEqual(jfac*w[0], value, eps99 , eps99); // d^jz/du^j
    113112                v[0]  = 0.;
    114113                value = 0.;
     
    122121        value = 2.;
    123122        for(j = 0; j < p; j++)
    124         {       ok &= NearEqual(jfac*r[j], value, 1e-10 , 1e-10); // d^jz/du^j
     123        {       ok &= NearEqual(jfac*r[j], value, eps99 , eps99); // d^jz/du^j
    125124                jfac *= (j + 1);
    126125                value = 0.;
  • trunk/test_more/add_eq.cpp

    r3779 r3869  
    1 // $Id$
    21/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     2CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-17 Bradley M. Bell
    43
    54CppAD is distributed under multiple licenses. This distribution is under
     
    7574bool AddEqTwo(void)
    7675{       bool ok = true;
    77 
    7876        using namespace CppAD;
     77        double eps99 = 99.0 * std::numeric_limits<double>::epsilon();
    7978
    8079        // independent variable vector
     
    9796
    9897        // check value
    99         ok &= NearEqual(Z[0] , u0+2+4+u0,  1e-10 , 1e-10);
     98        ok &= NearEqual(Z[0] , u0+2+4+u0,  eps99 , eps99);
    10099
    101100        // forward computation of partials w.r.t. u
     
    108107        {       jfac *= j;
    109108                w     = f.Forward(j, v);
    110                 ok &= NearEqual(jfac*w[0], value, 1e-10 , 1e-10); // d^jz/du^j
     109                ok &= NearEqual(jfac*w[0], value, eps99 , eps99); // d^jz/du^j
    111110                v[0]  = 0.;
    112111                value = 0.;
     
    120119        value = 2.;
    121120        for(j = 0; j < p; j++)
    122         {       ok &= NearEqual(jfac*r[j], value, 1e-10 , 1e-10); // d^jz/du^j
     121        {       ok &= NearEqual(jfac*r[j], value, eps99 , eps99); // d^jz/du^j
    123122                jfac *= (j + 1);
    124123                value = 0.;
  • trunk/test_more/asin.cpp

    r3675 r3869  
    1 /* $Id$ */
    21/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     2CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-17 Bradley M. Bell
    43
    54CppAD is distributed under multiple licenses. This distribution is under
     
    1918bool asin(void)
    2019{       bool ok = true;
    21 
    2220        using CppAD::asin;
    2321        using namespace CppAD;
     22        double eps99 = 99.0 * std::numeric_limits<double>::epsilon();
    2423
    2524        // independent variable vector
     
    4140
    4241        // check value
    43         ok &= NearEqual(U[0] , Z[0],  1e-10 , 1e-10);
     42        ok &= NearEqual(U[0] , Z[0],  eps99 , eps99);
    4443
    4544        // forward computation of partials w.r.t. u
     
    5251        {       jfac *= j;
    5352                w     = f.Forward(j, v);
    54                 ok &= NearEqual(jfac*w[0], value, 1e-10 , 1e-10); // d^jz/du^j
     53                ok &= NearEqual(jfac*w[0], value, eps99 , eps99); // d^jz/du^j
    5554                v[0]  = 0.;
    5655                value = 0.;
     
    6463        value = 1.;
    6564        for(j = 0; j < p; j++)
    66         {       ok &= NearEqual(jfac*r[j], value, 1e-10 , 1e-10); // d^jz/du^j
     65        {       ok &= NearEqual(jfac*r[j], value, eps99 , eps99); // d^jz/du^j
    6766                jfac *= (j + 1);
    6867                value = 0.;
  • trunk/test_more/atan.cpp

    r3682 r3869  
    1 /* $Id$ */
    21/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     2CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-17 Bradley M. Bell
    43
    54CppAD is distributed under multiple licenses. This distribution is under
     
    2524        using CppAD::atan;
    2625        using namespace CppAD;
     26        double eps99 = 99.0 * std::numeric_limits<double>::epsilon();
    2727
    2828        // independent variable vector, indices, values, and declaration
     
    5050
    5151        // check value
    52         ok &= NearEqual(U[s] , Z[a],  1e-10 , 1e-10);
     52        ok &= NearEqual(U[s] , Z[a],  eps99 , eps99);
    5353
    5454        // forward computation of partials w.r.t. s
    5555        v[s] = 1.;
    5656        w    = f.Forward(1, v);
    57         ok &= NearEqual(w[a], 1e0, 1e-10 , 1e-10);  // da/ds
     57        ok &= NearEqual(w[a], 1e0, eps99 , eps99);  // da/ds
    5858
    5959        // reverse computation of first order partial of a
    6060        w[a] = 1.;
    6161        v    = f.Reverse(1, w);
    62         ok &= NearEqual(v[s], 1e0, 1e-10 , 1e-10);  // da/ds
     62        ok &= NearEqual(v[s], 1e0, eps99 , eps99);  // da/ds
    6363
    6464        // forward computation of second partials w.r.t. s and s
     
    6767        v[s] = 0.;
    6868        w    = f.Forward(2, v);
    69         ok &= NearEqual(2. * w[a], 0e0, 1e-10 , 1e-10);     // d^2 a / (ds ds)
     69        ok &= NearEqual(2. * w[a], 0e0, eps99 , eps99);     // d^2 a / (ds ds)
    7070
    7171        // reverse computation of second partials of a
     
    7373        w[a] = 1.;
    7474        r    = f.Reverse(2, w);
    75         ok &= NearEqual(r[2 * s + 1] ,0e0, 1e-10 , 1e-10 ); // d^2 a / (ds ds)
     75        ok &= NearEqual(r[2 * s + 1] ,0e0, eps99 , eps99 ); // d^2 a / (ds ds)
    7676
    7777        return ok;
     
    8585        using CppAD::cos;
    8686        using namespace CppAD;
     87        double eps99 = 99.0 * std::numeric_limits<double>::epsilon();
    8788
    8889        // independent variable vector
     
    104105
    105106        // check value
    106         ok &= NearEqual(U[0] , Z[0],  1e-10 , 1e-10);
     107        ok &= NearEqual(U[0] , Z[0],  eps99 , eps99);
    107108
    108109        // forward computation of partials w.r.t. u
     
    115116        {       jfac *= j;
    116117                w     = f.Forward(j, v);
    117                 ok &= NearEqual(jfac*w[0], value, 1e-10 , 1e-10); // d^jz/du^j
     118                ok &= NearEqual(jfac*w[0], value, jfac*eps99 , jfac*eps99);// d^jz/du^j
    118119                v[0]  = 0.;
    119120                value = 0.;
     
    127128        value = 1.;
    128129        for(j = 0; j < p; j++)
    129         {       ok &= NearEqual(jfac*r[j], value, 1e-10 , 1e-10); // d^jz/du^j
     130        {       ok &= NearEqual(jfac*r[j], value, jfac*eps99 , jfac*eps99);// d^jz/du^j
    130131                jfac *= (j + 1);
    131132                value = 0.;
  • trunk/test_more/cos.cpp

    r3779 r3869  
    1 // $Id$
    21/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     2CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-17 Bradley M. Bell
    43
    54CppAD is distributed under multiple licenses. This distribution is under
     
    1817bool Cos(void)
    1918{       bool ok = true;
    20 
    2119        using CppAD::sin;
    2220        using CppAD::cos;
    2321        using namespace CppAD;
     22        double eps99 = 99.0 * std::numeric_limits<double>::epsilon();
    2423
    2524        // independent variable vector
     
    4140        double cos_u = cos( Value(U[0]) );
    4241
    43         ok &= NearEqual(cos_u, Value(Z[0]),  1e-10 , 1e-10);
     42        ok &= NearEqual(cos_u, Value(Z[0]),  eps99 , eps99);
    4443
    4544        // forward computation of partials w.r.t. u
     
    6160
    6261                jfac *= j;
    63                 ok &= NearEqual(jfac*w[0], value, 1e-10 , 1e-10); // d^jz/du^j
     62                ok &= NearEqual(jfac*w[0], value, eps99 , eps99); // d^jz/du^j
    6463                v[0]  = 0.;
    6564        }
     
    8180                else    value = cos_u;
    8281
    83                 ok &= NearEqual(jfac*r[j], value, 1e-10 , 1e-10); // d^jz/du^j
     82                ok &= NearEqual(jfac*r[j], value, eps99 , eps99); // d^jz/du^j
    8483
    8584                jfac *= (j + 1);
  • trunk/test_more/cosh.cpp

    r3779 r3869  
    1 // $Id$
    21/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     2CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-17 Bradley M. Bell
    43
    54CppAD is distributed under multiple licenses. This distribution is under
     
    1817bool Cosh(void)
    1918{       bool ok = true;
    20 
    2119        using CppAD::sinh;
    2220        using CppAD::cosh;
    2321        using namespace CppAD;
     22        double eps99 = 99.0 * std::numeric_limits<double>::epsilon();
    2423
    2524        // independent variable vector
     
    4140        double cosh_u = cosh( Value(U[0]) );
    4241
    43         ok &= NearEqual(cosh_u, Value(Z[0]),  1e-10 , 1e-10);
     42        ok &= NearEqual(cosh_u, Value(Z[0]),  eps99 , eps99);
    4443
    4544        // forward computation of partials w.r.t. u
     
    5756
    5857                jfac *= j;
    59                 ok &= NearEqual(jfac*w[0], value, 1e-10 , 1e-10); // d^jz/du^j
     58                ok &= NearEqual(jfac*w[0], value, eps99 , eps99); // d^jz/du^j
    6059                v[0]  = 0.;
    6160        }
     
    7372                else    value = cosh_u;
    7473
    75                 ok &= NearEqual(jfac*r[j], value, 1e-10 , 1e-10); // d^jz/du^j
     74                ok &= NearEqual(jfac*r[j], value, eps99 , eps99); // d^jz/du^j
    7675
    7776                jfac *= (j + 1);
  • trunk/test_more/div.cpp

    r3856 r3869  
    1 // $Id$
    21/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
     2CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-17 Bradley M. Bell
    43
    54CppAD is distributed under multiple licenses. This distribution is under
     
    9998                Q[s * f.Domain() + 1],
    10099                - 1. / (U[t] * U[t]),
    101                 1e-10,
    102                 1e-10
     100                eps99,
     101                eps99
    103102        );
    104103
  • trunk/test_more/div_eq.cpp

    r3856 r3869  
    1 // $Id$
    21/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
     2CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-17 Bradley M. Bell
    43
    54CppAD is distributed under multiple licenses. This distribution is under
     
    8281        r    = f.Reverse(2, w);
    8382        ok &= NearEqual(r[2 * s + 1]                 // d^2 x / (dt ds)
    84                  , - 1. / (U[t] * U[t])     , 1e-10 , 1e-10 );
     83                 , - 1. / (U[t] * U[t])     , eps99 , eps99 );
    8584        ok &= NearEqual(r[2 * t + 1]                 // d^2 x / (dt dt)
    86                 , 2. * U[s] / (U[t] * U[t] * U[t])  , 1e-10 , 1e-10 );
     85                , 2. * U[s] / (U[t] * U[t] * U[t])  , eps99 , eps99 );
    8786
    8887        return ok;
  • trunk/test_more/div_zero_one.cpp

    r3779 r3869  
    1 // $Id$
    21/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     2CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-17 Bradley M. Bell
    43
    54CppAD is distributed under multiple licenses. This distribution is under
     
    2120
    2221bool DivZeroOne(void)
    23 {
     22{       bool ok = true;
    2423        using namespace CppAD;
    25 
    26         bool ok = true;
     24        double eps99 = 99.0 * std::numeric_limits<double>::epsilon();
    2725
    2826        size_t i;
     
    6563                        ADdouble check = - double(i) / double(j * j);
    6664                        if( j != 0 ) ok &= NearEqual(
    67                                 v[0], check, 1e-10, 1e-10 );
     65                                v[0], check, eps99, eps99 );
    6866
    6967                        check = 1. / double(i * i);
    7068                        if( i != 0 ) ok &= NearEqual(
    71                                 v[1], check, 1e-10, 1e-10);
     69                                v[1], check, eps99, eps99);
    7270
    7371                        // g(x) = f'(y) = {-x/y^2 , 1/(x * x)}
     
    8280                        // check derivatives of g
    8381                        if( j != 0 ) ok &= NearEqual(
    84                                 b[0], - 1./double(j*j), 1e-10, 1e-10 );
     82                                b[0], - 1./double(j*j), eps99, eps99 );
    8583                        if( i != 0 ) ok &= NearEqual(
    86                                 b[1], -2./double(i*i*i), 1e-10, 1e-10);
     84                                b[1], -2./double(i*i*i), eps99, eps99);
    8785
    8886                }
  • trunk/test_more/exp.cpp

    r3779 r3869  
    1 // $Id$
    21/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     2CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-17 Bradley M. Bell
    43
    54CppAD is distributed under multiple licenses. This distribution is under
     
    2221bool ExpTestOne(void)
    2322{       bool ok = true;
    24 
    2523        using CppAD::exp;
    2624        using namespace CppAD;
     25        double eps99 = 99.0 * std::numeric_limits<double>::epsilon();
    2726
    2827        // independent variable vector, indices, values, and declaration
     
    4544
    4645        // check values
    47         ok &= NearEqual(Z[x] , exp(1.),         1e-10 , 1e-10);
    48         ok &= NearEqual(Z[y] , exp( exp(1.) ),  1e-10 , 1e-10);
     46        ok &= NearEqual(Z[x] , exp(1.),         eps99 , eps99);
     47        ok &= NearEqual(Z[y] , exp( exp(1.) ),  eps99 , eps99);
    4948
    5049        // forward computation of partials w.r.t. s
    5150        v[s] = 1.;
    5251        w    = f.Forward(1, v);
    53         ok &= NearEqual(w[x], Z[x],            1e-10 , 1e-10); // dx/ds
    54         ok &= NearEqual(w[y], Z[y] * Z[x],     1e-10 , 1e-10); // dy/ds
     52        ok &= NearEqual(w[x], Z[x],            eps99 , eps99); // dx/ds
     53        ok &= NearEqual(w[y], Z[y] * Z[x],     eps99 , eps99); // dy/ds
    5554
    5655        // reverse computation of partials of y
     
    5857        w[y] = 1.;
    5958        v    = f.Reverse(1,w);
    60         ok &= NearEqual(v[s], Z[y] * Z[x],     1e-10 , 1e-10); // dy/ds
     59        ok &= NearEqual(v[s], Z[y] * Z[x],     eps99 , eps99); // dy/ds
    6160
    6261        // forward computation of second partials w.r.t s
     
    6867                2. * w[y] ,
    6968                Z[y] * Z[x] * Z[x] + Z[y] * Z[x],
    70                 1e-10 ,
    71                 1e-10
     69                eps99 ,
     70                eps99
    7271        );
    7372
     
    8079                r[2 * s + 1] ,
    8180                Z[y] * Z[x] * Z[x] + Z[y] * Z[x],
    82                 1e-10 ,
    83                 1e-10
     81                eps99 ,
     82                eps99
    8483        );
    8584
     
    8887bool ExpTestTwo(void)
    8988{       bool ok = true;
    90 
    9189        using CppAD::exp;
    9290        using namespace CppAD;
     91        double eps99 = 99.0 * std::numeric_limits<double>::epsilon();
    9392
    9493        // independent variable vector
     
    108107        // check value
    109108        double exp_u = exp( Value(U[0]) );
    110         ok &= NearEqual(exp_u, Value(Z[0]),  1e-10 , 1e-10);
     109        ok &= NearEqual(exp_u, Value(Z[0]),  eps99 , eps99);
    111110
    112111        // forward computation of partials w.r.t. u
     
    118117        {       w     = f.Forward(j, v);
    119118                jfac *= j;
    120                 ok &= NearEqual(jfac*w[0], exp_u, 1e-10 , 1e-10); // d^jz/du^j
     119                ok &= NearEqual(jfac*w[0], exp_u, eps99 , eps99); // d^jz/du^j
    121120                v[0]  = 0.;
    122121        }
     
    128127        jfac  = 1.;
    129128        for(j = 0; j < p; j++)
    130         {       ok &= NearEqual(jfac*r[j], exp_u, 1e-10 , 1e-10); // d^jz/du^j
     129        {       ok &= NearEqual(jfac*r[j], exp_u, eps99 , eps99); // d^jz/du^j
    131130                jfac *= (j + 1);
    132131        }
  • trunk/test_more/forward.cpp

    r3856 r3869  
    1 // $Id$
    21/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
     2CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-17 Bradley M. Bell
    43
    54CppAD is distributed under multiple licenses. This distribution is under
     
    151150        // compare values
    152151        ok &= NearEqual(v1[0] ,
    153                 g0[0]*u1[0] + g0[1]*u1[1] + g0[2]*u1[2] , 1e-10, 1e-10);
     152                g0[0]*u1[0] + g0[1]*u1[1] + g0[2]*u1[2] , eps99, eps99);
    154153        ok &= NearEqual(v1[1] ,
    155                 g1[0]*u1[0] + g1[1]*u1[1] + g1[2]*u1[2] , 1e-10, 1e-10);
     154                g1[0]*u1[0] + g1[1]*u1[1] + g1[2]*u1[2] , eps99, eps99);
    156155
    157156        // use ADFun object to evaluate ------------------------------------
     
    172171        // compare values
    173172        ok &= NearEqual(v2[0] ,
    174                 g0[0]*u2[0] + g0[1]*u2[1] + g0[2]*u2[2] , 1e-10, 1e-10);
     173                g0[0]*u2[0] + g0[1]*u2[1] + g0[2]*u2[2] , eps99, eps99);
    175174
    176175        size_t j;
  • trunk/test_more/fun_check.cpp

    r3779 r3869  
    1 // $Id$
    21/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     2CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-17 Bradley M. Bell
    43
    54CppAD is distributed under multiple licenses. This distribution is under
     
    4746        using CppAD::ADFun;
    4847        using CppAD::Independent;
     48        double eps99 = 99.0 * std::numeric_limits<double>::epsilon();
    4949
    5050        // use the ADFun default constructor
     
    8181        for(j = 0; j < n; j++)
    8282                x[j] = Value(X[j]);
    83         double r = 1e-10;
    84         double a = 1e-10;
     83        double r = eps99;
     84        double a = eps99;
    8585        ok      &= FunCheck(f, g, x, a, r);
    8686
  • trunk/test_more/log.cpp

    r3684 r3869  
    1 /* $Id$ */
    21/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     2CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-17 Bradley M. Bell
    43
    54CppAD is distributed under multiple licenses. This distribution is under
     
    2221bool LogTestOne(void)
    2322{       bool ok = true;
    24 
    2523        using CppAD::log;
    2624        using namespace CppAD;
     25        double eps99 = 99.0 * std::numeric_limits<double>::epsilon();
    2726
    2827        // independent variable vector, indices, values, and declaration
     
    4544
    4645        // check values
    47         ok &= NearEqual(Z[x] , log(2.),  1e-10 , 1e-10);
    48         ok &= NearEqual(Z[y] , log( log(2.) ),  1e-10 , 1e-10);
     46        ok &= NearEqual(Z[x] , log(2.),  eps99 , eps99);
     47        ok &= NearEqual(Z[y] , log( log(2.) ),  eps99 , eps99);
    4948
    5049        // forward computation of partials w.r.t. s
    5150        v[s] = 1.;
    5251        w    = f.Forward(1, v);
    53         ok &= NearEqual(w[x], 1. / U[s],          1e-10 , 1e-10); // dx/ds
    54         ok &= NearEqual(w[y], 1. / (U[s] * Z[x]), 1e-10 , 1e-10); // dy/ds
     52        ok &= NearEqual(w[x], 1. / U[s],          eps99 , eps99); // dx/ds
     53        ok &= NearEqual(w[y], 1. / (U[s] * Z[x]), eps99 , eps99); // dy/ds
    5554
    5655        // reverse computation of partials of y
     
    5857        w[y] = 1.;
    5958        v    = f.Reverse(1,w);
    60         ok &= NearEqual(v[s], 1. / (U[s] * Z[x]), 1e-10 , 1e-10); // dy/ds
     59        ok &= NearEqual(v[s], 1. / (U[s] * Z[x]), eps99 , eps99); // dy/ds
    6160
    6261        // forward computation of second partials w.r.t. s
     
    6867                2. * w[y] ,
    6968                - 1. / (Z[x]*Z[x]*U[s]*U[s]) - 1. / (Z[x]*U[s]*U[s]),
    70                 1e-10 ,
    71                 1e-10
     69                eps99 ,
     70                eps99
    7271        );
    7372
     
    8079                r[2 * s + 1] ,
    8180                - 1. / (Z[x]*Z[x]*U[s]*U[s]) - 1. / (Z[x]*U[s]*U[s]),
    82                 1e-10 ,
    83                 1e-10
     81                eps99 ,
     82                eps99
    8483        );
    8584
     
    8887bool LogTestTwo(void)
    8988{       bool ok = true;
    90 
    9189        using CppAD::log;
    9290        using namespace CppAD;
     91        double eps99 = 99.0 * std::numeric_limits<double>::epsilon();
    9392
    9493        // independent variable vector
     
    110109
    111110        // check value
    112         ok &= NearEqual(U[0] , Z[0],  1e-10 , 1e-10);
     111        ok &= NearEqual(U[0] , Z[0],  eps99 , eps99);
    113112
    114113        // forward computation of partials w.r.t. u
     
    121120        {       jfac *= j;
    122121                w     = f.Forward(j, v);
    123                 ok &= NearEqual(jfac*w[0], value, 1e-10 , 1e-10); // d^jz/du^j
     122                ok &= NearEqual(jfac*w[0], value, eps99 , eps99); // d^jz/du^j
    124123                v[0]  = 0.;
    125124                value = 0.;
     
    133132        value = 1.;
    134133        for(j = 0; j < p; j++)
    135         {       ok &= NearEqual(jfac*r[j], value, 1e-10 , 1e-10); // d^jz/du^j
     134        {       ok &= NearEqual(jfac*r[j], value, eps99 , eps99); // d^jz/du^j
    136135                jfac *= (j + 1);
    137136                value = 0.;
  • trunk/test_more/log10.cpp

    r3684 r3869  
    1 /* $Id$ */
    21/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     2CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-17 Bradley M. Bell
    43
    54CppAD is distributed under multiple licenses. This distribution is under
     
    1817bool log10(void)
    1918{       bool ok = true;
    20 
    2119        using CppAD::log10;
    2220        using CppAD::log;
    2321        using namespace CppAD;
     22        double eps99 = 99.0 * std::numeric_limits<double>::epsilon();
    2423
    2524        // independent variable vector, indices, values, and declaration
     
    4241
    4342        // check values
    44         ok &= NearEqual(Z[x] , 1.,  1e-10 , 1e-10);
    45         ok &= NearEqual(Z[y] , 0.,  1e-10 , 1e-10);
     43        ok &= NearEqual(Z[x] , 1.,  eps99 , eps99);
     44        ok &= NearEqual(Z[y] , 0.,  eps99 , eps99);
    4645
    4746        // forward computation of partials w.r.t. s
     
    4948        v[s] = 1.;
    5049        w    = f.Forward(1, v);
    51         ok &= NearEqual(w[x], 1./(U[s]*l10)         , 1e-10 , 1e-10); // dx/ds
    52         ok &= NearEqual(w[y], 1./(U[s]*Z[x]*l10*l10), 1e-10 , 1e-10); // dy/ds
     50        ok &= NearEqual(w[x], 1./(U[s]*l10)         , eps99 , eps99); // dx/ds
     51        ok &= NearEqual(w[y], 1./(U[s]*Z[x]*l10*l10), eps99 , eps99); // dy/ds
    5352
    5453        // reverse computation of partials of y
     
    5655        w[y] = 1.;
    5756        v    = f.Reverse(1,w);
    58         ok &= NearEqual(v[s], 1./(U[s]*Z[x]*l10*l10), 1e-10 , 1e-10); // dy/ds
     57        ok &= NearEqual(v[s], 1./(U[s]*Z[x]*l10*l10), eps99 , eps99); // dy/ds
    5958
    6059        return ok;
  • trunk/test_more/mul.cpp

    r3779 r3869  
    1 // $Id$
    21/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     2CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-17 Bradley M. Bell
    43
    54CppAD is distributed under multiple licenses. This distribution is under
     
    9695bool MulTestTwo(void)
    9796{       bool ok = true;
    98 
    9997        using namespace CppAD;
     98        double eps99 = 99.0 * std::numeric_limits<double>::epsilon();
    10099
    101100        // independent variable vector
     
    120119
    121120        // check value
    122         ok &= NearEqual(Value(Z[0]) , u0*4*3*2*u0,  1e-10 , 1e-10);
     121        ok &= NearEqual(Value(Z[0]) , u0*4*3*2*u0,  eps99 , eps99);
    123122
    124123        // forward computation of partials w.r.t. u
     
    137136                jfac *= j;
    138137                w     = f.Forward(j, v);
    139                 ok &= NearEqual(jfac*w[0], value, 1e-10 , 1e-10); // d^jz/du^j
     138                ok &= NearEqual(jfac*w[0], value, eps99 , eps99); // d^jz/du^j
    140139                v[0]  = 0.;
    141140        }
     
    154153                else    value = 0.;
    155154
    156                 ok &= NearEqual(jfac*r[j], value, 1e-10 , 1e-10); // d^jz/du^j
     155                ok &= NearEqual(jfac*r[j], value, eps99 , eps99); // d^jz/du^j
    157156                jfac *= (j + 1);
    158157        }
  • trunk/test_more/mul_eq.cpp

    r3779 r3869  
    1 // $Id$
    21/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     2CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-17 Bradley M. Bell
    43
    54CppAD is distributed under multiple licenses. This distribution is under
     
    8281bool MulEqTestTwo(void)
    8382{       bool ok = true;
    84 
    8583        using namespace CppAD;
     84        double eps99 = 99.0 * std::numeric_limits<double>::epsilon();
    8685
    8786        // independent variable vector
     
    104103
    105104        // check value
    106         ok &= NearEqual(Z[0] , u0*2*4*u0,  1e-10 , 1e-10);
     105        ok &= NearEqual(Z[0] , u0*2*4*u0,  eps99 , eps99);
    107106
    108107        // forward computation of partials w.r.t. u
     
    121120                jfac *= j;
    122121                w     = f.Forward(j, v);
    123                 ok &= NearEqual(jfac*w[0], value, 1e-10 , 1e-10); // d^jz/du^j
     122                ok &= NearEqual(jfac*w[0], value, eps99 , eps99); // d^jz/du^j
    124123                v[0]  = 0.;
    125124        }
     
    138137                else    value = 0.;
    139138
    140                 ok &= NearEqual(jfac*r[j], value, 1e-10 , 1e-10); // d^jz/du^j
     139                ok &= NearEqual(jfac*r[j], value, eps99 , eps99); // d^jz/du^j
    141140                jfac *= (j + 1);
    142141        }
  • trunk/test_more/mul_level.cpp

    r3864 r3869  
    102102bool Two(void)
    103103{       bool ok = true;                          // initialize test result
     104        double eps99 = 99.0 * std::numeric_limits<double>::epsilon();
    104105
    105106        typedef CppAD::AD<double>   ADdouble;    // for one level of taping
     
    148149        // f''(x) * v = ( v[0], v[1],  ... , x[n-1] )
    149150        for(j = 0; j < n; j++)
    150                 ok &= CppAD::NearEqual(ddf_v[j], v[j], 1e-10, 1e-10);
     151                ok &= CppAD::NearEqual(ddf_v[j], v[j], eps99, eps99);
    151152
    152153        return ok;
     
    157158bool adolc(void)
    158159{       bool ok = true;                   // initialize test result
     160        double eps99 = 99.0 * std::numeric_limits<double>::epsilon();
    159161
    160162        typedef adouble      ADdouble;         // for first level of taping
     
    213215        // f''(x) * v = ( v[0], v[1],  ... , x[n-1] )
    214216        for(j = 0; j < n; j++)
    215                 ok &= CppAD::NearEqual(ddf_v[j], v[j], 1e-10, 1e-10);
     217                ok &= CppAD::NearEqual(ddf_v[j], v[j], eps99, eps99);
    216218
    217219        CPPAD_TRACK_DEL_VEC(v);                 // check usage of delete
  • trunk/test_more/pow.cpp

    r3856 r3869  
    1 // $Id$
    21/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
     2CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-17 Bradley M. Bell
    43
    54CppAD is distributed under multiple licenses. This distribution is under
     
    181180                (1. + U[s]) * u * Z[y] +
    182181                        (1. + U[s]) * U[t] * u * U[s] * u * Z[y],
    183                 1e-10 ,
    184                 1e-10
     182                eps99 ,
     183                eps99
    185184        );
    186185
  • trunk/test_more/pow_int.cpp

    r3779 r3869  
    1 // $Id$
    21/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     2CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-17 Bradley M. Bell
    43
    54CppAD is distributed under multiple licenses. This distribution is under
     
    1918bool PowInt(void)
    2019{       bool ok = true;
    21 
    2220        using CppAD::pow;
    2321        using CppAD::exp;
    2422        using CppAD::log;
    2523        using namespace CppAD;
     24        double eps99 = 99.0 * std::numeric_limits<double>::epsilon();
    2625
    2726
     
    5049        // check function values values
    5150        double u = Value(U[0]);
    52         ok &= NearEqual(Z[0] , exp( log(u) * 5.),              1e-10 , 1e-10);
    53         ok &= NearEqual(Z[1] , exp( - log(u) * 5.),            1e-10 , 1e-10);
     51        ok &= NearEqual(Z[0] , exp( log(u) * 5.),              eps99 , eps99);
     52        ok &= NearEqual(Z[1] , exp( - log(u) * 5.),            eps99 , eps99);
    5453
    5554        // forward computation of partials
    5655        v[0] = 1.;
    5756        w = f.Forward(1, v);
    58         ok &= NearEqual(w[0] , 5. * exp( log(u) * 4.),         1e-10 , 1e-10);
    59         ok &= NearEqual(w[1] , - 5. * exp( - log(u) * 6.),     1e-10 , 1e-10);
     57        ok &= NearEqual(w[0] , 5. * exp( log(u) * 4.),         eps99 , eps99);
     58        ok &= NearEqual(w[1] , - 5. * exp( - log(u) * 6.),     eps99 , eps99);
    6059
    6160        return ok;
  • trunk/test_more/reverse.cpp

    r3799 r3869  
    1 // $Id$
    21/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
     2CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-17 Bradley M. Bell
    43
    54CppAD is distributed under multiple licenses. This distribution is under
     
    2019bool reverse_one(void)
    2120{       bool ok = true;
    22 
    2321        using namespace CppAD;
     22        double eps99 = 99.0 * std::numeric_limits<double>::epsilon();
    2423
    2524        // independent variable vector
     
    6362        for(i = 0; i < 3; i++)
    6463        {       ok &= NearEqual(r1[i] ,
    65                         v[0] * g0[i] + v[1] * g1[i], 1e-10, 1e-10);
     64                        v[0] * g0[i] + v[1] * g1[i], eps99, eps99);
    6665        }
    6766
     
    8786        for(i = 0; i < 3; i++)
    8887        {       ok &= NearEqual(r2[p * i + 0] ,
    89                         v[0] * g0[i] + v[1] * g1[i], 1e-10, 1e-10);
     88                        v[0] * g0[i] + v[1] * g1[i], eps99, eps99);
    9089        }
    9190
     
    115114
    116115                // note term corresponding to v[0] is zero
    117                 ok &= NearEqual(r2[p * i + 1], v[1] * sum, 1e-10, 1e-10);
     116                ok &= NearEqual(r2[p * i + 1], v[1] * sum, eps99, eps99);
    118117        }
    119118
     
    127126        using CppAD::AD;
    128127        using CppAD::NearEqual;
     128        double eps99 = 99.0 * std::numeric_limits<double>::epsilon();
    129129
    130130        // domain space vector
     
    155155        double check;
    156156        check   =  u[0]*u[1]*u[2];
    157         ok     &= NearEqual(W0[0] , check, 1e-10, 1e-10);
     157        ok     &= NearEqual(W0[0] , check, eps99, eps99);
    158158
    159159        // define W_t(t, u) = partial W(t, u) w.r.t t
     
    168168        W1    = f.Forward(1, dx);
    169169        check =  u[0]*u[1]*dx[2] + u[0]*u[2]*dx[1] + u[1]*u[2]*dx[0];
    170         ok   &= NearEqual(W1[0], check, 1e-10, 1e-10);
     170        ok   &= NearEqual(W1[0], check, eps99, eps99);
    171171
    172172        // define W_tt (t, u) = partial W_t(t, u) w.r.t t
     
    179179        W2     = f.Forward(2, ddx);
    180180        check  =  u[0]*dx[1]*dx[2] + u[1]*dx[0]*dx[2] + u[2]*dx[0]*dx[1];
    181         ok    &= NearEqual(W2[0], check, 1e-10, 1e-10);
     181        ok    &= NearEqual(W2[0], check, eps99, eps99);
    182182
    183183        // use third order reverse mode to evaluate derivatives
     
    188188
    189189        // check derivative of W0(u) w.r.t. u
    190         ok    &= NearEqual(dw[0*p+0], u[1]*u[2], 1e-10, 1e-10);
    191         ok    &= NearEqual(dw[1*p+0], u[0]*u[2], 1e-10, 1e-10);
    192         ok    &= NearEqual(dw[2*p+0], u[0]*u[1], 1e-10, 1e-10);
     190        ok    &= NearEqual(dw[0*p+0], u[1]*u[2], eps99, eps99);
     191        ok    &= NearEqual(dw[1*p+0], u[0]*u[2], eps99, eps99);
     192        ok    &= NearEqual(dw[2*p+0], u[0]*u[1], eps99, eps99);
    193193
    194194        // check derivative of W1(u) w.r.t. u
    195         ok    &= NearEqual(dw[0*p+1], u[1]*dx[2] + u[2]*dx[1], 1e-10, 1e-10);
    196         ok    &= NearEqual(dw[1*p+1], u[0]*dx[2] + u[2]*dx[0], 1e-10, 1e-10);
    197         ok    &= NearEqual(dw[2*p+1], u[0]*dx[1] + u[1]*dx[0], 1e-10, 1e-10);
     195        ok    &= NearEqual(dw[0*p+1], u[1]*dx[2] + u[2]*dx[1], eps99, eps99);
     196        ok    &= NearEqual(dw[1*p+1], u[0]*dx[2] + u[2]*dx[0], eps99, eps99);
     197        ok    &= NearEqual(dw[2*p+1], u[0]*dx[1] + u[1]*dx[0], eps99, eps99);
    198198
    199199        // check derivative of W2(u) w.r.t u
    200         ok    &= NearEqual(dw[0*p+2], dx[1]*dx[2], 1e-10, 1e-10);
    201         ok    &= NearEqual(dw[1*p+2], dx[0]*dx[2], 1e-10, 1e-10);
    202         ok    &= NearEqual(dw[2*p+2], dx[0]*dx[1], 1e-10, 1e-10);
     200        ok    &= NearEqual(dw[0*p+2], dx[1]*dx[2], eps99, eps99);
     201        ok    &= NearEqual(dw[1*p+2], dx[0]*dx[2], eps99, eps99);
     202        ok    &= NearEqual(dw[2*p+2], dx[0]*dx[1], eps99, eps99);
    203203
    204204        return ok;
  • trunk/test_more/sin.cpp

    r3779 r3869  
    1 // $Id$
    21/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     2CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-17 Bradley M. Bell
    43
    54CppAD is distributed under multiple licenses. This distribution is under
     
    1817bool Sin(void)
    1918{       bool ok = true;
    20 
    2119        using CppAD::sin;
    2220        using CppAD::cos;
    2321        using namespace CppAD;
     22        double eps99 = 99.0 * std::numeric_limits<double>::epsilon();
    2423
    2524        // independent variable vector
     
    4140        double cos_u = cos( Value(U[0]) );
    4241
    43         ok &= NearEqual(sin_u, Value(Z[0]),  1e-10 , 1e-10);
     42        ok &= NearEqual(sin_u, Value(Z[0]),  eps99 , eps99);
    4443
    4544        // forward computation of partials w.r.t. u
     
    6160
    6261                jfac *= j;
    63                 ok &= NearEqual(jfac*w[0], value, 1e-10 , 1e-10); // d^jz/du^j
     62                ok &= NearEqual(jfac*w[0], value, eps99 , eps99); // d^jz/du^j
    6463                v[0]  = 0.;
    6564        }
     
    8180                else    value = sin_u;
    8281
    83                 ok &= NearEqual(jfac*r[j], value, 1e-10 , 1e-10); // d^jz/du^j
     82                ok &= NearEqual(jfac*r[j], value, eps99 , eps99); // d^jz/du^j
    8483
    8584                jfac *= (j + 1);
  • trunk/test_more/sin_cos.cpp

    r3779 r3869  
    1 // $Id$
    21/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     2CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-17 Bradley M. Bell
    43
    54CppAD is distributed under multiple licenses. This distribution is under
     
    2221bool Sin(void)
    2322{       bool ok = true;
    24 
    2523        using CppAD::sin;
    2624        using CppAD::cos;
    2725        using namespace CppAD;
     26        double eps99 = 99.0 * std::numeric_limits<double>::epsilon();
    2827
    2928        // independent variable vector
     
    5049        double cos_u = cos( Value(U) );
    5150
    52         ok &= NearEqual(sin_u, Value(Z[0]),  1e-10 , 1e-10);
     51        ok &= NearEqual(sin_u, Value(Z[0]),  eps99 , eps99);
    5352
    5453        // forward computation of partials w.r.t. u
     
    7877
    7978                // check j-th derivative of z w.r.t x
    80                 ok &= NearEqual(jfac*w[0], sinj * yj, 1e-10 , 1e-10);
     79                ok &= NearEqual(jfac*w[0], sinj * yj, eps99 , eps99);
    8180
    8281                v[0]  = 0.;
     
    104103
    105104                // derivative w.r.t x of sin^{(j)} (x * y) * y^j
    106                 ok &= NearEqual(jfac*r[0+j], sinjp * yj * y, 1e-10 , 1e-10);
     105                ok &= NearEqual(jfac*r[0+j], sinjp * yj * y, eps99 , eps99);
    107106
    108107                // derivative w.r.t y of sin^{(j)} (x * y) * y^j
    109108                double value = sinjp * yj * x + j * sinj * yj / y;
    110                 ok &= NearEqual(jfac*r[p+j], value , 1e-10 , 1e-10);
     109                ok &= NearEqual(jfac*r[p+j], value , eps99 , eps99);
    111110
    112111                jfac  *= (j + 1);
     
    119118bool Cos(void)
    120119{       bool ok = true;
    121 
    122120        using CppAD::sin;
    123121        using CppAD::cos;
    124122        using namespace CppAD;
     123        double eps99 = 99.0 * std::numeric_limits<double>::epsilon();
    125124
    126125        // independent variable vector
     
    147146        double cos_u = cos( Value(U) );
    148147
    149         ok &= NearEqual(cos_u, Value(Z[0]),  1e-10 , 1e-10);
     148        ok &= NearEqual(cos_u, Value(Z[0]),  eps99 , eps99);
    150149
    151150        // forward computation of partials w.r.t. u
     
    175174
    176175                // check j-th derivative of z w.r.t x
    177                 ok &= NearEqual(jfac*w[0], cosj * yj, 1e-10 , 1e-10);
     176                ok &= NearEqual(jfac*w[0], cosj * yj, eps99 , eps99);
    178177
    179178                v[0]  = 0.;
     
    201200
    202201                // derivative w.r.t x of cos^{(j)} (x * y) * y^j
    203                 ok &= NearEqual(jfac*r[0+j], cosjp * yj * y, 1e-10 , 1e-10);
     202                ok &= NearEqual(jfac*r[0+j], cosjp * yj * y, eps99 , eps99);
    204203
    205204                // derivative w.r.t y of cos^{(j)} (x * y) * y^j
    206205                double value = cosjp * yj * x + j * cosj * yj / y;
    207                 ok &= NearEqual(jfac*r[p+j], value , 1e-10 , 1e-10);
     206                ok &= NearEqual(jfac*r[p+j], value , eps99 , eps99);
    208207
    209208                jfac  *= (j + 1);
     
    216215bool Cosh(void)
    217216{       bool ok = true;
    218 
    219217        using CppAD::sinh;
    220218        using CppAD::cosh;
    221219        using namespace CppAD;
     220        double eps99 = 99.0 * std::numeric_limits<double>::epsilon();
    222221
    223222        // independent variable vector
     
    244243        double cosh_u = cosh( Value(U) );
    245244
    246         ok &= NearEqual(cosh_u, Value(Z[0]),  1e-10 , 1e-10);
     245        ok &= NearEqual(cosh_u, Value(Z[0]),  eps99 , eps99);
    247246
    248247        // forward computation of partials w.r.t. u
     
    268267
    269268                // check j-th derivative of z w.r.t x
    270                 ok &= NearEqual(jfac*w[0], coshj * yj, 1e-10 , 1e-10);
     269                ok &= NearEqual(jfac*w[0], coshj * yj, eps99 , eps99);
    271270
    272271                v[0]  = 0.;
     
    290289
    291290                // derivative w.r.t x of cosh^{(j)} (x * y) * y^j
    292                 ok &= NearEqual(jfac*r[0+j], coshjp * yj * y, 1e-10 , 1e-10);
     291                ok &= NearEqual(jfac*r[0+j], coshjp * yj * y, eps99 , eps99);
    293292
    294293                // derivative w.r.t y of cosh^{(j)} (x * y) * y^j
    295294                double value = coshjp * yj * x + j * coshj * yj / y;
    296                 ok &= NearEqual(jfac*r[p+j], value , 1e-10 , 1e-10);
     295                ok &= NearEqual(jfac*r[p+j], value , eps99 , eps99);
    297296
    298297                jfac  *= (j + 1);
     
    305304bool Sinh(void)
    306305{       bool ok = true;
    307 
    308306        using CppAD::sinh;
    309307        using CppAD::cosh;
    310308        using namespace CppAD;
     309        double eps99 = 99.0 * std::numeric_limits<double>::epsilon();
    311310
    312311        // independent variable vector
     
    333332        double cosh_u = cosh( Value(U) );
    334333
    335         ok &= NearEqual(sinh_u, Value(Z[0]),  1e-10 , 1e-10);
     334        ok &= NearEqual(sinh_u, Value(Z[0]),  eps99 , eps99);
    336335
    337336        // forward computation of partials w.r.t. u
     
    357356
    358357                // check j-th derivative of z w.r.t x
    359                 ok &= NearEqual(jfac*w[0], sinhj * yj, 1e-10 , 1e-10);
     358                ok &= NearEqual(jfac*w[0], sinhj * yj, eps99 , eps99);
    360359
    361360                v[0]  = 0.;
     
    379378
    380379                // derivative w.r.t x of sinh^{(j)} (x * y) * y^j
    381                 ok &= NearEqual(jfac*r[0+j], sinhjp * yj * y, 1e-10 , 1e-10);
     380                ok &= NearEqual(jfac*r[0+j], sinhjp * yj * y, eps99 , eps99);
    382381
    383382                // derivative w.r.t y of sinh^{(j)} (x * y) * y^j
    384383                double value = sinhjp * yj * x + j * sinhj * yj / y;
    385                 ok &= NearEqual(jfac*r[p+j], value , 1e-10 , 1e-10);
     384                ok &= NearEqual(jfac*r[p+j], value , eps99 , eps99);
    386385
    387386                jfac  *= (j + 1);
  • trunk/test_more/sinh.cpp

    r3779 r3869  
    1 // $Id$
    21/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     2CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-17 Bradley M. Bell
    43
    54CppAD is distributed under multiple licenses. This distribution is under
     
    1817bool Sinh(void)
    1918{       bool ok = true;
    20 
    2119        using CppAD::sinh;
    2220        using CppAD::cosh;
    2321        using namespace CppAD;
     22        double eps99 = 99.0 * std::numeric_limits<double>::epsilon();
    2423
    2524        // independent variable vector
     
    4140        double cos_u = cosh( Value(U[0]) );
    4241
    43         ok &= NearEqual(sin_u, Value(Z[0]),  1e-10 , 1e-10);
     42        ok &= NearEqual(sin_u, Value(Z[0]),  eps99 , eps99);
    4443
    4544        // forward computation of partials w.r.t. u
     
    5756
    5857                jfac *= j;
    59                 ok &= NearEqual(jfac*w[0], value, 1e-10 , 1e-10); // d^jz/du^j
     58                ok &= NearEqual(jfac*w[0], value, eps99 , eps99); // d^jz/du^j
    6059                v[0]  = 0.;
    6160        }
     
    7372                else    value = sin_u;
    7473
    75                 ok &= NearEqual(jfac*r[j], value, 1e-10 , 1e-10); // d^jz/du^j
     74                ok &= NearEqual(jfac*r[j], value, eps99 , eps99); // d^jz/du^j
    7675
    7776                jfac *= (j + 1);
  • trunk/test_more/sparse_hessian.cpp

    r3856 r3869  
    1 // $Id$
    21/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
     2CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-17 Bradley M. Bell
    43
    54CppAD is distributed under multiple licenses. This distribution is under
     
    106105        using CppAD::NearEqual;
    107106        size_t i, j, k;
     107        double eps99 = 99.0 * std::numeric_limits<double>::epsilon();
    108108
    109109        // domain space vector
     
    143143        check[6] = 0.; check[7] = 0.; check[8] = 2.;
    144144        for(k = 0; k < n * n; k++)
    145                 ok &=  NearEqual(check[k], h[k], 1e-10, 1e-10 );
     145                ok &=  NearEqual(check[k], h[k], eps99, eps99 );
    146146
    147147        // determine the sparsity pattern p for Hessian of w^T F
     
    162162        h = f.SparseHessian(x, w, p);
    163163        for(k = 0; k < n * n; k++)
    164                 ok &=  NearEqual(check[k], h[k], 1e-10, 1e-10 );
     164                ok &=  NearEqual(check[k], h[k], eps99, eps99 );
    165165
    166166        return ok;
     
    172172        using CppAD::NearEqual;
    173173        size_t i, j, k;
     174        double eps99 = 99.0 * std::numeric_limits<double>::epsilon();
    174175
    175176        // domain space vector
     
    209210        check[6] = 0.; check[7] = 0.; check[8] = 2.;
    210211        for(k = 0; k < n * n; k++)
    211                 ok &=  NearEqual(check[k], h[k], 1e-10, 1e-10 );
     212                ok &=  NearEqual(check[k], h[k], eps99, eps99 );
    212213
    213214        // determine the sparsity pattern p for Hessian of w^T F
     
    226227        h = f.SparseHessian(x, w, p);
    227228        for(k = 0; k < n * n; k++)
    228                 ok &=  NearEqual(check[k], h[k], 1e-10, 1e-10 );
     229                ok &=  NearEqual(check[k], h[k], eps99, eps99 );
    229230
    230231        return ok;
  • trunk/test_more/sparse_jacobian.cpp

    r3856 r3869  
    1 // $Id$
    21/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
     2CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-17 Bradley M. Bell
    43
    54CppAD is distributed under multiple licenses. This distribution is under
     
    271270        using CppAD::NearEqual;
    272271        size_t i, j, k;
     272        double eps99 = 99.0 * std::numeric_limits<double>::epsilon();
    273273
    274274        // domain space vector
     
    308308        check[8] = 5.; check[9] = 6.; check[10] = 7.; check[11] = 8.*x[3];
    309309        for(k = 0; k < 12; k++)
    310                 ok &=  NearEqual(check[k], jac[k], 1e-10, 1e-10 );
     310                ok &=  NearEqual(check[k], jac[k], eps99, eps99 );
    311311
    312312        // test passing sparsity pattern
     
    321321        jac = f.SparseJacobian(x, p);
    322322        for(k = 0; k < 12; k++)
    323                 ok &=  NearEqual(check[k], jac[k], 1e-10, 1e-10 );
     323                ok &=  NearEqual(check[k], jac[k], eps99, eps99 );
    324324
    325325        return ok;
     
    332332        using CppAD::NearEqual;
    333333        size_t i, j, k;
     334        double eps99 = 99.0 * std::numeric_limits<double>::epsilon();
    334335
    335336        // domain space vector
     
    369370        check[8] = 1.; check[9] = 1.; check[10] = 1.; check[11] = x[3];
    370371        for(k = 0; k < 12; k++)
    371                 ok &=  NearEqual(check[k], jac[k], 1e-10, 1e-10 );
     372                ok &=  NearEqual(check[k], jac[k], eps99, eps99 );
    372373
    373374        // test passing sparsity pattern
     
    378379        jac = f.SparseJacobian(x, p);
    379380        for(k = 0; k < 12; k++)
    380                 ok &=  NearEqual(check[k], jac[k], 1e-10, 1e-10 );
     381                ok &=  NearEqual(check[k], jac[k], eps99, eps99 );
    381382
    382383        return ok;
     
    389390        using CppAD::NearEqual;
    390391        size_t j, k;
     392        double eps99 = 99.0 * std::numeric_limits<double>::epsilon();
    391393
    392394        // domain space vector
     
    429431        check[9] = 0.; check[10] = 1.; check[11] = x[2];
    430432        for(k = 0; k < 12; k++)
    431                 ok &=  NearEqual(check[k], jac[k], 1e-10, 1e-10 );
     433                ok &=  NearEqual(check[k], jac[k], eps99, eps99 );
    432434
    433435        // test passing sparsity pattern
     
    442444        jac = f.SparseJacobian(x, p);
    443445        for(k = 0; k < 12; k++)
    444                 ok &=  NearEqual(check[k], jac[k], 1e-10, 1e-10 );
     446                ok &=  NearEqual(check[k], jac[k], eps99, eps99 );
    445447
    446448        return ok;
     
    453455        using CppAD::NearEqual;
    454456        size_t j, k;
     457        double eps99 = 99.0 * std::numeric_limits<double>::epsilon();
    455458
    456459        // domain space vector
     
    493496        check[9] = 0.; check[10] = 1.; check[11] = x[2];
    494497        for(k = 0; k < 12; k++)
    495                 ok &=  NearEqual(check[k], jac[k], 1e-10, 1e-10 );
     498                ok &=  NearEqual(check[k], jac[k], eps99, eps99 );
    496499
    497500        // test passing sparsity pattern
     
    502505        jac = f.SparseJacobian(x, p);
    503506        for(k = 0; k < 12; k++)
    504                 ok &=  NearEqual(check[k], jac[k], 1e-10, 1e-10 );
     507                ok &=  NearEqual(check[k], jac[k], eps99, eps99 );
    505508
    506509        return ok;
  • trunk/test_more/sqrt.cpp

    r3779 r3869  
    1 // $Id$
    21/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     2CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-17 Bradley M. Bell
    43
    54CppAD is distributed under multiple licenses. This distribution is under
     
    2120bool SqrtTestOne(void)
    2221{       bool ok = true;
    23 
    2422        using CppAD::sqrt;
    2523        using CppAD::pow;
    2624        using namespace CppAD;
     25        double eps99 = 99.0 * std::numeric_limits<double>::epsilon();
    2726
    2827        // independent variable vector, indices, values, and declaration
     
    4544
    4645        // check values
    47         ok &= NearEqual(Z[x] , 2.,        1e-10 , 1e-10);
    48         ok &= NearEqual(Z[y] , sqrt(2.),  1e-10 , 1e-10);
     46        ok &= NearEqual(Z[x] , 2.,        eps99 , eps99);
     47        ok &= NearEqual(Z[y] , sqrt(2.),  eps99 , eps99);
    4948
    5049        // forward computation of partials w.r.t. s
    5150        v[s] = 1.;
    5251        w    = f.Forward(1, v);
    53         ok &= NearEqual(w[x], .5  * pow(4., -.5),   1e-10 , 1e-10); // dx/ds
    54         ok &= NearEqual(w[y], .25 * pow(4., -.75),  1e-10 , 1e-10); // dy/ds
     52        ok &= NearEqual(w[x], .5  * pow(4., -.5),   eps99 , eps99); // dx/ds
     53        ok &= NearEqual(w[y], .25 * pow(4., -.75),  eps99 , eps99); // dy/ds
    5554
    5655        // reverse computation of partials of y
     
    5857        w[y] = 1.;
    5958        v    = f.Reverse(1,w);
    60         ok &= NearEqual(v[s], .25 * pow(4., -.75),  1e-10 , 1e-10); // dy/ds
     59        ok &= NearEqual(v[s], .25 * pow(4., -.75),  eps99 , eps99); // dy/ds
    6160
    6261        // forward computation of second partials w.r.t s
     
    6867                2. * w[y] ,
    6968                -.75 * .25 * pow(4., -1.75),
    70                 1e-10 ,
    71                 1e-10
     69                eps99 ,
     70                eps99
    7271        );
    7372
     
    8079                r[2 * s + 1] ,
    8180                -.75 * .25 * pow(4., -1.75),
    82                 1e-10 ,
    83                 1e-10
     81                eps99 ,
     82                eps99
    8483        );
    8584
     
    9089{       bool ok = true;
    9190        using namespace CppAD;
     91        double eps99 = 99.0 * std::numeric_limits<double>::epsilon();
    9292
    9393        // independent variable vector
     
    109109
    110110        // check value
    111         ok &= NearEqual(U[0] , Z[0],  1e-10 , 1e-10);
     111        ok &= NearEqual(U[0] , Z[0],  eps99 , eps99);
    112112
    113113        // forward computation of partials w.r.t. u
     
    120120        {       jfac *= j;
    121121                w     = f.Forward(j, v);
    122                 ok &= NearEqual(jfac*w[0], value, 1e-10 , 1e-10); // d^jz/du^j
     122                ok &= NearEqual(jfac*w[0], value, eps99 , eps99); // d^jz/du^j
    123123                v[0]  = 0.;
    124124                value = 0.;
     
    132132        value = 1.;
    133133        for(j = 0; j < p; j++)
    134         {       ok &= NearEqual(jfac*r[j], value, 1e-10 , 1e-10); // d^jz/du^j
     134        {       ok &= NearEqual(jfac*r[j], value, eps99 , eps99); // d^jz/du^j
    135135                jfac *= (j + 1);
    136136                value = 0.;
     
    141141bool SqrtTestThree(void)
    142142{       bool ok = true;
    143 
    144143        using CppAD::sqrt;
    145144        using CppAD::exp;
    146145        using namespace CppAD;
     146        double eps99 = 99.0 * std::numeric_limits<double>::epsilon();
    147147
    148148        // independent variable vector, indices, values, and declaration
     
    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.,   eps99 , eps99);
    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., eps99 , eps99 );
    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., eps99 , eps99 );
    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., eps99 , eps99);
     188        ok   &= NearEqual(r[1], exp(x/2.)/4., eps99 , eps99 );
     189        ok   &= NearEqual(2.*r[2], exp(x/2.)/8., eps99 , eps99 );
     190        ok   &= NearEqual(6.*r[3], exp(x/2.)/16., eps99 , eps99 );
    191191
    192192        return ok;
  • trunk/test_more/sub.cpp

    r3779 r3869  
    1 // $Id$
    21/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     2CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-17 Bradley M. Bell
    43
    54CppAD is distributed under multiple licenses. This distribution is under
     
    7776bool Two(void)
    7877{       bool ok = true;
    79 
    8078        using namespace CppAD;
     79        double eps99 = 99.0 * std::numeric_limits<double>::epsilon();
    8180
    8281        // independent variable vector
     
    101100
    102101        // check value
    103         ok &= NearEqual(Value(Z[0]) , u0-4+3-2*u0+1+2,  1e-10 , 1e-10);
     102        ok &= NearEqual(Value(Z[0]) , u0-4+3-2*u0+1+2,  eps99 , eps99);
    104103
    105104        // forward computation of partials w.r.t. u
     
    112111        {       jfac *= j;
    113112                w     = f.Forward(j, v);
    114                 ok &= NearEqual(jfac*w[0], value, 1e-10 , 1e-10); // d^jz/du^j
     113                ok &= NearEqual(jfac*w[0], value, eps99 , eps99); // d^jz/du^j
    115114                v[0]  = 0.;
    116115                value = 0.;
     
    124123        value = -1.;
    125124        for(j = 0; j < p; j++)
    126         {       ok &= NearEqual(jfac*r[j], value, 1e-10 , 1e-10); // d^jz/du^j
     125        {       ok &= NearEqual(jfac*r[j], value, eps99 , eps99); // d^jz/du^j
    127126                jfac *= (j + 1);
    128127                value = 0.;
  • trunk/test_more/sub_eq.cpp

    r3779 r3869  
    1 // $Id$
    21/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     2CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-17 Bradley M. Bell
    43
    54CppAD is distributed under multiple licenses. This distribution is under
     
    7170bool SubEqTestTwo(void)
    7271{       bool ok = true;
    73 
    7472        using namespace CppAD;
     73        double eps99 = 99.0 * std::numeric_limits<double>::epsilon();
    7574
    7675        // independent variable vector
     
    9392
    9493        // check value
    95         ok &= NearEqual(Z[0] , u0-2-4-2*u0,  1e-10 , 1e-10);
     94        ok &= NearEqual(Z[0] , u0-2-4-2*u0,  eps99 , eps99);
    9695
    9796        // forward computation of partials w.r.t. u
     
    104103        {       jfac *= j;
    105104                w     = f.Forward(j, v);
    106                 ok &= NearEqual(jfac*w[0], value, 1e-10 , 1e-10); // d^jz/du^j
     105                ok &= NearEqual(jfac*w[0], value, eps99 , eps99); // d^jz/du^j
    107106                v[0]  = 0.;
    108107                value = 0.;
     
    116115        value = -1.;
    117116        for(j = 0; j < p; j++)
    118         {       ok &= NearEqual(jfac*r[j], value, 1e-10 , 1e-10); // d^jz/du^j
     117        {       ok &= NearEqual(jfac*r[j], value, eps99 , eps99); // d^jz/du^j
    119118                jfac *= (j + 1);
    120119                value = 0.;
  • trunk/test_more/vec_ad.cpp

    r3779 r3869  
    1 // $Id$
    21/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     2CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-17 Bradley M. Bell
    43
    54CppAD is distributed under multiple licenses. This distribution is under
     
    2423bool VecADTestOne(void)
    2524{       bool ok = true;
    26 
    2725        using namespace CppAD;
    2826        using CppAD::sin;
    2927        using CppAD::cos;
     28        double eps99 = 99.0 * std::numeric_limits<double>::epsilon();
    3029
    3130
     
    8786                z    = f.Forward(0, x);
    8887                vx   = double(n - i);
    89                 ok  &= NearEqual(z[0], sin(x[0]) * vx, 1e-10, 1e-10);
     88                ok  &= NearEqual(z[0], sin(x[0]) * vx, eps99, eps99);
    9089
    9190                // note that derivative of v[x] w.r.t. x is zero
    9291                dx[0] = 1.;
    9392                dz    = f.Forward(1, dx);
    94                 ok   &= NearEqual(dz[0], cos(x[0]) * vx, 1e-10, 1e-10);
     93                ok   &= NearEqual(dz[0], cos(x[0]) * vx, eps99, eps99);
    9594
    9695                // reverse mode calculation of same value
    9796                dz[0] = 1.;
    9897                dx    = f.Reverse(1, dz);
    99                 ok   &= NearEqual(dx[0], cos(x[0]) * vx, 1e-10, 1e-10);
     98                ok   &= NearEqual(dx[0], cos(x[0]) * vx, eps99, eps99);
    10099        }
    101100
     
    112111{       bool ok = true;
    113112        using namespace CppAD;
     113        double eps99 = 99.0 * std::numeric_limits<double>::epsilon();
    114114
    115115        double pi    = 4. * CppAD::atan(1.);
     
    161161        x[0] = xStep / 2.;
    162162        y    = f.Forward(0, x);
    163         ok  &= NearEqual(y[0], (Data[0] + Data[1])/2., 1e-10, 1e-10);
     163        ok  &= NearEqual(y[0], (Data[0] + Data[1])/2., eps99, eps99);
    164164
    165165        // evalute the derivative with respect to x
     
    168168        dx[0] = 1.;
    169169        dy    = f.Forward(1, dx);
    170         ok   &= NearEqual(dy[0], (Data[1] - Data[0]) / xStep, 1e-10, 1e-10);
     170        ok   &= NearEqual(dy[0], (Data[1] - Data[0]) / xStep, eps99, eps99);
    171171
    172172        return ok;
Note: See TracChangeset for help on using the changeset viewer.