Changeset 3889 for trunk/test_more


Ignore:
Timestamp:
Feb 18, 2017 12:14:05 PM (3 years ago)
Author:
bradbell
Message:

merge to branch: trunk
from repository: https://github.com/coin-or/CppAD
start hash code: 78a12fb9c876c4417bb993424cda7de3b00f3673
end hash code: 36fb03a25eb4a0e78e926a7ab7c52b2937bd1f6a

commit 36fb03a25eb4a0e78e926a7ab7c52b2937bd1f6a
Author: Brad Bell <bradbell@…>
Date: Sat Feb 18 08:06:53 2017 -0700

atomic_base.hpp: fix atomic clear (include new temporaries).

commit fb0094a2bb312a9afae9266af1711d8265dfe141
Author: Brad Bell <bradbell@…>
Date: Sat Feb 18 07:41:15 2017 -0700

Remove function parameter q where it is not needed.

commit 01b5007e0daff2382994315d2152380f47e00e55
Author: Brad Bell <bradbell@…>
Date: Sat Feb 18 07:23:55 2017 -0700

Move splitting into sparsity cases from rev_hes_sweep to atomic_base.

commit 39e7e66c0f406fbfe5bf245649d73bc7ddd953d0
Author: Brad Bell <bradbell@…>
Date: Sat Feb 18 05:24:05 2017 -0700

atomic_base.hpp: remove one level of indentation (no longer used).

commit 483571744a5b661fbd5f7dcec2773ff926a034d6
Author: Brad Bell <bradbell@…>
Date: Sat Feb 18 05:20:54 2017 -0700

Move some error reporting from sweeps to atomic_base.

commit 3e359ed7d20805efcef43391ed1378a011b28b85
Author: Brad Bell <bradbell@…>
Date: Sat Feb 18 05:11:53 2017 -0700

Advance to cppad-20170218.

commit 3cfb8bc9cc79f2451356644360c23261ddf24f43
Author: Brad Bell <bradbell@…>
Date: Sat Feb 18 05:10:57 2017 -0700

for_hes_sweep.hpp: fix tracing of user atomic functions.

commit 54788b7b741bb4ed7bf363e60f8ee066429ff0cd
Author: Brad Bell <bradbell@…>
Date: Fri Feb 17 07:07:51 2017 -0700

Move split of for_sparse_hes cases from for_hes_sweep to atomic_base.
for_jac_sweep.hpp: add some assets and improve some comments.
rev_jac_sweep.hpp: add some comments.
wish_list.omh: add a for_sparse_hes item to atomic list.

commit 145716172219131f120e353c38bd91f105c36770
Author: Brad Bell <bradbell@…>
Date: Fri Feb 17 04:40:11 2017 -0700

Advance to cppad-20170217.
atomic_sparsity.cpp: more testing of atomic for_sparse_hes.

commit 02ef42a50d9c9b5cfbb3d2a9ae32b3ed971c7642
Author: Brad Bell <bradbell@…>
Date: Thu Feb 16 05:25:58 2017 -0700

new_release.sh: Advance to 20170000.2

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/test_more/atomic_sparsity.cpp

    r3884 r3889  
    1212Atomic function
    1313g( x ) = [ x_2, x_0 * x_1 ]
    14 
    15 f(u) = g( u_0 + u_1, u_0 + u_1, u_2 )
    1614\] $$
    1715*/
     
    197195        }
    198196}; // End of atomic_set_sparsity class
    199 }  // End empty namespace
    200 
    201 bool atomic_sparsity(void)
     197
     198
     199// f(u) = g( u_0 + u_1 , u_0 + u_1 , u_2 )
     200//      = [ u_2 , (u_0 + u_1)^2 ]
     201bool test_one(void)
    202202{       bool ok = true;
    203203        using CppAD::AD;
     
    252252                        ok &= s[i] == check_s[i];
    253253        }
    254         // correct Hessian result
     254        // correct Hessian result for w_0 * f_0 (u) + w_1 * f_1(u)
    255255        set_vector check_h(n);
    256256        check_h[0].insert(0);
     
    278278        return ok;
    279279}
     280
     281// f(u) = g( u_0 + u_1 , u_1 + u_2 , u_2 + u_0 )
     282//      = [ u_2 + u_0 , (u_0 + u_1)*(u_1 + u_2) ]
     283bool test_two(void)
     284{       bool ok = true;
     285        using CppAD::AD;
     286        using CppAD::NearEqual;
     287        double eps = 10. * std::numeric_limits<double>::epsilon();
     288        // Create the atomic get_started object
     289        atomic_set_sparsity afun("atomic_set_sparsity");
     290        size_t n = 3;
     291        size_t m = 2;
     292        vector< AD<double> > au(n), ay(m);
     293        for(size_t j = 0; j < n; j++)
     294                au[j] = double(j + 1);
     295
     296        // declare independent variables and start tape recording
     297        CppAD::Independent(au);
     298
     299        // ax
     300        vector< AD<double> > ax(n);
     301        ax[0] = au[0] + au[1];
     302        ax[1] = au[1] + au[2];
     303        ax[2] = au[2] + au[0];
     304
     305        // call user function
     306        afun(ax, ay);
     307
     308        // create f: u -> y and stop tape recording
     309        CppAD::ADFun<double> f(au, ay);
     310
     311        // check function value
     312        ok &= NearEqual(ay[0] , au[2] + au[0],  eps, eps);
     313        ok &= NearEqual(ay[1] , (au[0] + au[1]) * (au[1] + au[2]),  eps, eps);
     314
     315        // correct Jacobian result
     316        set_vector check_s(m);
     317        check_s[0].insert(2);
     318        check_s[0].insert(0);
     319        check_s[1].insert(0);
     320        check_s[1].insert(1);
     321        check_s[1].insert(2);
     322        // compute and test forward mode
     323        {       set_vector r(n), s(m);
     324                for(size_t i = 0; i < n; i++)
     325                        r[i].insert(i);
     326                s = f.ForSparseJac(n, r);
     327                for(size_t i = 0; i < m; i++)
     328                        ok &= s[i] == check_s[i];
     329        }
     330        // compute and test reverse mode
     331        {       set_vector r(m), s(m);
     332                for(size_t i = 0; i < m; i++)
     333                        r[i].insert(i);
     334                s = f.RevSparseJac(m, r);
     335                for(size_t i = 0; i < m; i++)
     336                        ok &= s[i] == check_s[i];
     337        }
     338        // ----------------------------------------------------------------------
     339        // correct Hessian result for f_0 (u)
     340        set_vector check_h(n), s(1);
     341        s[0].insert(0);
     342        // compute and test forward mode
     343        {       set_vector r(1), h(n);
     344                for(size_t j = 0; j < n; j++)
     345                        r[0].insert(j);
     346                h = f.ForSparseHes(r, s);
     347                for(size_t i = 0; i < n; i++)
     348                        ok &= h[i] == check_h[i];
     349        }
     350        // compute and test reverse mode
     351        {       set_vector h(n);
     352                h = f.RevSparseHes(n, s);
     353                for(size_t i = 0; i < n; i++)
     354                        ok &= h[i] == check_h[i];
     355        }
     356        // ----------------------------------------------------------------------
     357        // correct Hessian result for f_1 (u)
     358        s[0].clear();
     359        s[0].insert(1);
     360        check_h[0].insert(1);
     361        check_h[0].insert(2);
     362        check_h[1].insert(0);
     363        check_h[1].insert(1);
     364        check_h[1].insert(2);
     365        check_h[2].insert(0);
     366        check_h[2].insert(1);
     367        // compute and test forward mode
     368        {       set_vector r(1), h(n);
     369                for(size_t j = 0; j < n; j++)
     370                        r[0].insert(j);
     371                h = f.ForSparseHes(r, s);
     372                for(size_t i = 0; i < n; i++)
     373                        ok &= h[i] == check_h[i];
     374        }
     375        // compute and test reverse mode
     376        {       set_vector h(n);
     377                h = f.RevSparseHes(n, s);
     378                for(size_t i = 0; i < n; i++)
     379                        ok &= h[i] == check_h[i];
     380        }
     381        return ok;
     382}
     383
     384}  // End empty namespace
     385
     386bool atomic_sparsity(void)
     387{       bool ok = true;
     388        ok     &= test_one();
     389        ok     &= test_two();
     390        return ok;
     391}
Note: See TracChangeset for help on using the changeset viewer.