Changeset 3805 for trunk/test_more


Ignore:
Timestamp:
Mar 22, 2016 4:01:22 PM (4 years ago)
Author:
bradbell
Message:

merge to branch: trunk
from repository: https://github.com/coin-or/CppAD
start hash code: 624601e5e709d2872b5873f628fae76d5f575a9b
end hash code: 256147abd1ffb46688686cc6cd53908c9a64d957

commit 256147abd1ffb46688686cc6cd53908c9a64d957
Author: Brad Bell <bradbell@…>
Date: Tue Mar 22 12:56:16 2016 -0700

Change atomic_ode.cpp -> checkpoint_ode.cpp,
and atomic_extended_ode.cpp -> checkpoint_extended_ode.cpp.

commit 42eb37c2c38a377bf165ea2dcdd9721d251da800
Author: Brad Bell <bradbell@…>
Date: Tue Mar 22 09:05:32 2016 -0700

Add the eigen_mat_mul.cpp example (still under construction).


ode.cpp: minor corrections to typos in documentation.

commit 6126e82c2a9b3f10d15ee792bf9d32796eb9561c
Author: Brad Bell <bradbell@…>
Date: Tue Mar 22 04:57:55 2016 -0700

Reduce level of indent on public and private commands in atomic examples.

commit 50b8a65b81a0d4e3b0d9d03b188966eb5b366bec
Author: Brad Bell <bradbell@…>
Date: Tue Mar 22 04:46:22 2016 -0700

  1. Advance version to 20160322.
  2. Move atomic_mat_mul_xam.cpp -> atomic_mat_mul.cpp.

commit bb5a5300f882891dafff643ab6899a131fa477b0
Author: Brad Bell <bradbell@…>
Date: Mon Mar 21 05:40:28 2016 -0700

test_one.sh.in: use path to file instead of dir file.
mat_mul.hpp: add missing virtual (did not matter).

commit 955919bc43857a7f9b953af96be30f0cf524ae1c
Merge: ceb9087 3eece08
Author: Brad Bell <bradbell@…>
Date: Sun Mar 20 12:52:01 2016 -0700

Do not know how master got out of sync with local copy, but this merge
does not see to have any changes.

commit ceb9087c686d99279687134dc0af4da0150a0bc5
Author: Brad Bell <bradbell@…>
Date: Sun Mar 20 11:23:46 2016 -0700

Use utility/set_union to simplify atomic examples and tests.

commit 60e9db895ee11bddfb02b1e2f8a96b9dd8a01e49
Author: Brad Bell <bradbell@…>
Date: Sun Mar 20 11:02:21 2016 -0700

  1. Sort some lists.
  2. Add some references to set_union (missing in previous commit).

commit 3eece08b8e9af5f9cf2633bc300c4e5477acd2b1
Author: Brad Bell <bradbell@…>
Date: Sun Mar 20 10:00:56 2016 -0700

  1. Sort some lists.
  2. Add some references to set_union (missing in previous commit).

commit 309e461bf32d95b9330f65bbffaf4fa24d5f11d6
Author: Brad Bell <bradbell@…>
Date: Sun Mar 20 09:34:14 2016 -0700

Add utility/set_union.hpp.

Location:
trunk/test_more
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • trunk/test_more/old_mat_mul.cpp

    r3804 r3805  
    2121$head Deprecated 2013-05-27$$
    2222This example has been deprecated;
    23 use $cref atomic_mat_mul_xam.cpp$$ instead.
     23use $cref atomic_mat_mul.cpp$$ instead.
    2424
    2525$children%
  • trunk/test_more/old_mat_mul.hpp

    r3804 r3805  
    184184$head Set Union$$
    185185$srccode%cpp% */
    186         void my_union(
    187                 std::set<size_t>&         result  ,
    188                 const std::set<size_t>&   left    ,
    189                 const std::set<size_t>&   right   )
    190         {       std::set<size_t> temp;
    191                 std::set_union(
    192                         left.begin()              ,
    193                         left.end()                ,
    194                         right.begin()             ,
    195                         right.end()               ,
    196                         std::inserter(temp, temp.begin())
    197                 );
    198                 result.swap(temp);
    199         }
     186        using CppAD::set_union;
    200187/* %$$
    201188
     
    315302
    316303                                        // s[ij_result] = union( s[ij_result], r[im_left] )
    317                                         my_union(s[ij_result], s[ij_result], r[im_left]);
     304                                        s[ij_result] = set_union(s[ij_result], r[im_left]);
    318305
    319306                                        // s[ij_result] = union( s[ij_result], r[mj_right] )
    320                                         my_union(s[ij_result], s[ij_result], r[mj_right]);
     307                                        s[ij_result] = set_union(s[ij_result], r[mj_right]);
    321308                                }
    322309                        }
     
    348335
    349336                                        // r[im_left] = union( r[im_left], s[ij_result] )
    350                                         my_union(r[im_left], r[im_left], s[ij_result]);
     337                                        r[im_left] = set_union(r[im_left], s[ij_result]);
    351338
    352339                                        // r[mj_right] = union( r[mj_right], s[ij_result] )
    353                                         my_union(r[mj_right], r[mj_right], s[ij_result]);
     340                                        r[mj_right] = set_union(r[mj_right], s[ij_result]);
    354341                                }
    355342                        }
     
    397384                                        // v[im_left]  = union( v[im_left],  u[ij_result] )
    398385                                        // v[mj_right] = union( v[mj_right], u[ij_result] )
    399                                         my_union(v[im_left],  v[im_left],  u[ij_result] );
    400                                         my_union(v[mj_right], v[mj_right], u[ij_result] );
     386                                        v[im_left] = set_union(v[im_left],  u[ij_result] );
     387                                        v[mj_right] = set_union(v[mj_right], u[ij_result] );
    401388
    402389                                        // Check for case where the (i,j) result element
     
    405392                                        if(s[ij_result] & (*vx_)[im_left] & (*vx_)[mj_right])
    406393                                        {       // v[im_left] = union( v[im_left], r[mj_right] )
    407                                                 my_union(v[im_left], v[im_left], r[mj_right] );
     394                                                v[im_left] = set_union(v[im_left], r[mj_right] );
    408395                                                // v[mj_right] = union( v[mj_right], r[im_left] )
    409                                                 my_union(v[mj_right], v[mj_right], r[im_left] );
     396                                                v[mj_right] = set_union(v[mj_right], r[im_left] );
    410397                                        }
    411398                                }
  • trunk/test_more/old_reciprocal.cpp

    r3788 r3805  
    3737        // ----------------------------------------------------------------------
    3838        // a utility to compute the union of two sets.
    39         void my_union(
    40                 std::set<size_t>&         result  ,
    41                 const std::set<size_t>&   left    ,
    42                 const std::set<size_t>&   right   )
    43         {       std::set<size_t> temp;
    44                 std::set_union(
    45                         left.begin()              ,
    46                         left.end()                ,
    47                         right.begin()             ,
    48                         right.end()               ,
    49                         std::inserter(temp, temp.begin())
    50                 );
    51                 result.swap(temp);
    52         }
     39        using CppAD::set_union;
    5340
    5441        // ----------------------------------------------------------------------
     
    242229                // because second derivative of reciprocal may be non-zero
    243230                if( s[0] )
    244                         my_union(v[0], v[0], r[0] );
     231                        v[0] = set_union(v[0], r[0] );
    245232
    246233
  • trunk/test_more/old_tan.cpp

    r3788 r3805  
    4141
    4242        // a utility to compute the union of two sets.
    43         void my_union(
    44                 std::set<size_t>&         result  ,
    45                 const std::set<size_t>&   left    ,
    46                 const std::set<size_t>&   right   )
    47         {       std::set<size_t> temp;
    48                 std::set_union(
    49                         left.begin()              ,
    50                         left.end()                ,
    51                         right.begin()             ,
    52                         right.end()               ,
    53                         std::inserter(temp, temp.begin())
    54                 );
    55                 result.swap(temp);
    56         }
     43        using CppAD::set_union;
    5744
    5845        // ----------------------------------------------------------------------
     
    216203                // note that, if the users code only uses z, and not y,
    217204                // we could just set r[0] = s[0]
    218                 my_union(r[0], s[0], s[1]);
     205                r[0] = set_union(s[0], s[1]);
    219206                return true;
    220207        }
     
    246233
    247234                // back propagate Hessian sparsity, ...
    248                 my_union(v[0], u[0], u[1]);
     235                v[0] = set_union(u[0], u[1]);
    249236
    250237                // convert forward Jacobian sparsity to Hessian sparsity
    251238                // because tan and tanh are nonlinear
    252239                if( t[0] )
    253                         my_union(v[0], v[0], r[0]);
     240                        v[0] = set_union(v[0], r[0]);
    254241
    255242                return true;
  • trunk/test_more/optimize.cpp

    r3735 r3805  
    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
     
    13851385        }
    13861386        // -------------------------------------------------------------------
    1387         void my_union(
    1388                 std::set<size_t>&         result  ,
    1389                 const std::set<size_t>&   left    ,
    1390                 const std::set<size_t>&   right   )
    1391         {       std::set<size_t> temp;
    1392                 std::set_union(
    1393                         left.begin()              ,
    1394                         left.end()                ,
    1395                         right.begin()             ,
    1396                         right.end()               ,
    1397                         std::inserter(temp, temp.begin())
    1398                 );
    1399                 result.swap(temp);
    1400         }
     1387        using CppAD::set_union;
    14011388
    14021389        bool old_atomic_forward(
     
    14581445                r[2].clear();
    14591446                // y[0] = x[0] + x[1]
    1460                 my_union(r[0], r[0], s[0]);
    1461                 my_union(r[1], r[1], s[0]);
     1447                r[0] = set_union(r[0], s[0]);
     1448                r[1] = set_union(r[1], s[0]);
    14621449                // y[1] = x[1] + x[2]
    1463                 my_union(r[1], r[1], s[1]);
    1464                 my_union(r[2], r[2], s[1]);
     1450                r[1] = set_union(r[1], s[1]);
     1451                r[2] = set_union(r[2], s[1]);
    14651452
    14661453                return true;
Note: See TracChangeset for help on using the changeset viewer.