Changeset 1865 for trunk/test_more


Ignore:
Timestamp:
Feb 6, 2011 5:17:22 PM (9 years ago)
Author:
bradbell
Message:

Merge -r:1836:1864 from branches/user_atomic into trunk

Location:
trunk
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • trunk

  • trunk/test_more/optimize.cpp

    r1661 r1865  
    11/* $Id$ */
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-10 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-11 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    936936                return ok;
    937937        }
    938 
     938        // -------------------------------------------------------------------
     939        void my_union(
     940                std::set<size_t>&         result  ,
     941                const std::set<size_t>&   left    ,
     942                const std::set<size_t>&   right   )
     943        {       std::set<size_t> temp;
     944                std::set_union(
     945                        left.begin()              ,
     946                        left.end()                ,
     947                        right.begin()             ,
     948                        right.end()               ,
     949                        std::inserter(temp, temp.begin())
     950                );
     951                result.swap(temp);
     952        }
     953
     954        bool user_atomic_forward(
     955                size_t                         id ,
     956                size_t                          k ,
     957                size_t                          n ,
     958                size_t                          m ,
     959                const CppAD::vector<bool>&     vx ,
     960                CppAD::vector<bool>&           vy ,
     961                const CppAD::vector<double>&   tx ,
     962                CppAD::vector<double>&         ty )
     963        {       assert(n == 3 && m == 2);
     964                if( k > 0 )
     965                        return false;
     966
     967                // y[0] = x[0] + x[1]
     968                ty[0] = tx[0] + tx[1];
     969
     970                // y[1] = x[1] + x[2]
     971                ty[1] = tx[1] + tx[2];
     972               
     973                if( vy.size() > 0 )
     974                {       vy[0] = (vx[0] | vx[1]);
     975                        vy[1] = (vx[1] | vx[2]);
     976                }
     977                return true;
     978        }
     979
     980        bool user_atomic_reverse(
     981                size_t                         id ,
     982                size_t                          k ,
     983                size_t                          n ,
     984                size_t                          m ,
     985                const CppAD::vector<double>&   tx ,
     986                const CppAD::vector<double>&   ty ,
     987                CppAD::vector<double>&         px ,
     988                const CppAD::vector<double>&   py )
     989        {       return false; }
     990
     991        bool user_atomic_for_jac_sparse(
     992                size_t                                  id ,
     993                size_t                                   n ,
     994                size_t                                   m ,
     995                size_t                                   q ,
     996                const CppAD::vector< std::set<size_t> >& r ,
     997                CppAD::vector< std::set<size_t>  >&      s )
     998        {       return false; }
     999
     1000        bool user_atomic_rev_jac_sparse(
     1001                size_t                                  id ,
     1002                size_t                                   n ,
     1003                size_t                                   m ,
     1004                size_t                                   q ,
     1005                CppAD::vector< std::set<size_t> >&       r ,
     1006                const CppAD::vector< std::set<size_t> >& s )
     1007        {       assert(n == 3 && m == 2);
     1008                r[0].clear();
     1009                r[1].clear();
     1010                r[2].clear();
     1011                // y[0] = x[0] + x[1]
     1012                my_union(r[0], r[0], s[0]);
     1013                my_union(r[1], r[1], s[0]);
     1014                // y[1] = x[1] + x[2]
     1015                my_union(r[1], r[1], s[1]);
     1016                my_union(r[2], r[2], s[1]);
     1017
     1018                return true;
     1019        }
     1020
     1021        bool user_atomic_rev_hes_sparse(
     1022                size_t                                  id ,
     1023                size_t                                   n ,
     1024                size_t                                   m ,
     1025                size_t                                   q ,
     1026                const CppAD::vector< std::set<size_t> >& r ,
     1027                const CppAD::vector<bool>&               s ,
     1028                CppAD::vector<bool>&                     t ,
     1029                const CppAD::vector< std::set<size_t> >& u ,
     1030                CppAD::vector< std::set<size_t> >&       v )
     1031        {       return false; }
     1032
     1033        CPPAD_USER_ATOMIC(
     1034                my_user_atomic             ,
     1035                CPPAD_TEST_VECTOR          ,
     1036                double                     ,
     1037                user_atomic_forward        ,
     1038                user_atomic_reverse        ,
     1039                user_atomic_for_jac_sparse ,
     1040                user_atomic_rev_jac_sparse ,
     1041                user_atomic_rev_hes_sparse
     1042        )
     1043
     1044        bool user_atomic_test(void)
     1045        {       bool ok = true;
     1046
     1047                using CppAD::AD;
     1048                size_t j;
     1049                size_t n = 3;
     1050                size_t m = 2;
     1051                CPPAD_TEST_VECTOR< AD<double> > ax(n), ay(m), az(m);
     1052                for(j = 0; j < n; j++)
     1053                        ax[j] = AD<double>(j + 1);
     1054                CppAD::Independent(ax);
     1055
     1056                size_t id = 0;
     1057                // first call should stay in the tape
     1058                my_user_atomic(id++, ax, ay);
     1059                // second call will not get used
     1060                my_user_atomic(id++, ax, az);
     1061                // create function
     1062                CppAD::ADFun<double> g(ax, ay);
     1063                // should have 1 + n + m + m varaibles
     1064                ok &= g.size_var() == (1 + n + m + m);
     1065                g.optimize();
     1066                // should have 1 + n + m varaibles
     1067                ok &= g.size_var() == (1 + n + m);
     1068
     1069                // now test that the optimized function gives same results
     1070                CPPAD_TEST_VECTOR<double> x(n), y(m);
     1071                for(j = 0; j < n; j++)
     1072                        x[j] = (j + 1) * (j + 1);
     1073                y = g.Forward(0, x);
     1074                // y[0] = x[0] + x[1]
     1075                ok &= (y[0] == x[0] + x[1]);
     1076                // y[1] = x[1] + x[2]
     1077                ok &= (y[0] == x[0] + x[1]);
     1078
     1079                return ok;
     1080        }
    9391081}
    9401082
     
    9591101        // check that CondExp properly detects dependencies
    9601102        ok     &= cond_exp_depend();
    961 
     1103        // check user_atomic functions
     1104        ok     &= user_atomic_test();
     1105
     1106        CppAD::user_atomic<double>::clear();
    9621107        return ok;
    9631108}
Note: See TracChangeset for help on using the changeset viewer.