Changeset 1550 for trunk/test_more


Ignore:
Timestamp:
Oct 14, 2009 11:24:54 AM (11 years ago)
Author:
bradbell
Message:

trunk: Merge in changes from branches/sparsity.

Location:
trunk/test_more
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • trunk/test_more/for_sparse_jac.cpp

    r1532 r1550  
    7171namespace { // Begin empty namespace
    7272
    73 bool case_one(bool packed)
     73bool case_one()
    7474{       bool ok = true;
    7575        using namespace CppAD;
     
    149149        ADFun<double> F(X, Y);
    150150
     151        // ---------------------------------------------------------
    151152        // dependency matrix for the identity function W(x) = x
    152153        CPPAD_TEST_VECTOR< bool > Px(n * n);
     
    160161        // evaluate the dependency matrix for F(X(x))
    161162        CPPAD_TEST_VECTOR< bool > Py(m * n);
    162         Py = F.ForSparseJac(n, Px, packed);
     163        Py = F.ForSparseJac(n, Px);
    163164
    164165        // check values
     
    168169        }       
    169170
     171        // ---------------------------------------------------------
     172        // dependency matrix for the identity function W(x) = x
     173        CPPAD_TEST_VECTOR< std::set<size_t> > Sx(n);
     174        for(i = 0; i < n; i++)
     175        {       assert( Sx[i].empty() );
     176                Sx[i].insert(i);
     177        }
     178
     179        // evaluate the dependency matrix for F(X(x))
     180        CPPAD_TEST_VECTOR< std::set<size_t> > Sy(m);
     181        Sy = F.ForSparseJac(n, Sx);
     182
     183        // check values
     184        bool found;
     185        for(i = 0; i < m; i++)
     186        {       for(j = 0; j < n; j++)
     187                {       found = Sy[i].find(j) != Sy[i].end();
     188                        ok &= (found == Check[i * n + j]);
     189                }
     190        }       
     191
    170192        return ok;
    171193}
    172194
    173 bool case_two(bool packed)
     195bool case_two()
    174196{       bool ok = true;
    175197        using namespace CppAD;
     
    235257        ADFun<double> F(X, Y);
    236258
     259        // -----------------------------------------------------------------
    237260        // dependency matrix for the identity function W(x) = x
    238261        CPPAD_TEST_VECTOR< bool > Px(n * n);
     
    246269        // evaluate the dependency matrix for F(X(x))
    247270        CPPAD_TEST_VECTOR< bool > Py(m * n);
    248         Py = F.ForSparseJac(n, Px, packed);
     271        Py = F.ForSparseJac(n, Px);
    249272
    250273        // check values
     
    254277        }       
    255278
     279        // ---------------------------------------------------------
     280        // dependency matrix for the identity function W(x) = x
     281        CPPAD_TEST_VECTOR< std::set<size_t> > Sx(n);
     282        for(i = 0; i < n; i++)
     283        {       assert( Sx[i].empty() );
     284                Sx[i].insert(i);
     285        }
     286
     287        // evaluate the dependency matrix for F(X(x))
     288        CPPAD_TEST_VECTOR< std::set<size_t> > Sy(m);
     289        Sy = F.ForSparseJac(n, Sx);
     290
     291        // check values
     292        bool found;
     293        for(i = 0; i < m; i++)
     294        {       for(j = 0; j < n; j++)
     295                {       found = Sy[i].find(j) != Sy[i].end();
     296                        ok &= (found == Check[i * n + j]);
     297                }
     298        }       
     299
    256300        return ok;
    257301}
     
    262306{       bool ok = true;
    263307
    264         ok &= case_one(true);
    265         ok &= case_two(true);
    266 
    267         ok &= case_one(false);
    268         ok &= case_two(false);
     308        ok &= case_one();
     309        ok &= case_two();
    269310
    270311        return ok;
  • trunk/test_more/rev_sparse_hes.cpp

    r1533 r1550  
    1616namespace { // Begin empty namespace
    1717
    18 bool case_one(bool packed)
     18bool case_one()
    1919{       bool ok = true;
    2020        using namespace CppAD;
     
    7171        ADFun<double> F(X, Y);
    7272
     73        // ------------------------------------------------------------------
    7374        // sparsity pattern for the identity function U(x) = x
    7475        CPPAD_TEST_VECTOR<bool> Px(n * n);
     
    8081
    8182        // compute sparsity pattern for Jacobian of F(U(x))
    82         F.ForSparseJac(n, Px, packed);
     83        F.ForSparseJac(n, Px);
    8384
    8485        // compute sparsity pattern for Hessian of F_0 ( U(x) )
     
    100101                ok &= (! Pxx[j]);  // Hessian is identically zero
    101102
     103        // ------------------------------------------------------------------
     104        // sparsity pattern for the identity function U(x) = x
     105        CPPAD_TEST_VECTOR< std::set<size_t> > Sx(n);
     106        for(i = 0; i < n; i++)
     107                Sx[i].insert(i);
     108
     109        // compute sparsity pattern for Jacobian of F(U(x))
     110        F.ForSparseJac(n, Sx);
     111
     112        // compute sparsity pattern for Hessian of F_0 ( U(x) )
     113        CPPAD_TEST_VECTOR< std::set<size_t> > Sy(1);
     114        Sy[0].insert(0);
     115        CPPAD_TEST_VECTOR< std::set<size_t> > Sxx(n);
     116        Sxx = F.RevSparseHes(n, Sy);
     117
     118        // check values
     119        for(i = 0; i < n; i++)
     120        {       for(j = 0; j < n; j++)
     121                {       bool found = Sxx[i].find(j) != Sxx[i].end();
     122                        ok &= (found == Check[i * n + j]);
     123                }
     124        }
     125
     126        // compute sparsity pattern for Hessian of F_1 ( U(x) )
     127        Sy[0].clear();
     128        Sy[0].insert(1);
     129        Sxx = F.RevSparseHes(n, Sy);
     130        for(i = 0; i < n; i++)
     131        {       for(j = 0; j < n; j++)
     132                {       bool found = Sxx[i].find(j) != Sxx[i].end();
     133                        ok &= ! found;
     134                }
     135        }
     136
    102137        return ok;
    103138}
    104139
    105 bool case_two(bool packed)
     140bool case_two()
    106141{       bool ok = true;
    107142        using namespace CppAD;
     
    143178        ADFun<double> F(X, Y);
    144179
     180        // -----------------------------------------------------------------
    145181        // sparsity pattern for the identity function U(x) = x
    146182        CPPAD_TEST_VECTOR<bool> Px(n * n);
     
    152188
    153189        // compute sparsity pattern for Jacobian of F(U(x))
    154         F.ForSparseJac(n, Px, packed);
     190        F.ForSparseJac(n, Px);
    155191
    156192        // compute sparsity pattern for Hessian of F_0 ( U(x) )
     
    164200                ok &= (Pxx[j] == Check[j]);
    165201
     202        // ------------------------------------------------------------------
     203        // sparsity pattern for the identity function U(x) = x
     204        CPPAD_TEST_VECTOR< std::set<size_t> > Sx(n);
     205        for(i = 0; i < n; i++)
     206                Sx[i].insert(i);
     207
     208        // compute sparsity pattern for Jacobian of F(U(x))
     209        F.ForSparseJac(n, Sx);
     210
     211        // compute sparsity pattern for Hessian of F_0 ( U(x) )
     212        CPPAD_TEST_VECTOR< std::set<size_t> > Sy(1);
     213        Sy[0].insert(0);
     214        CPPAD_TEST_VECTOR< std::set<size_t> > Sxx(n);
     215        Sxx = F.RevSparseHes(n, Sy);
     216
     217        // check values
     218        for(i = 0; i < n; i++)
     219        {       for(j = 0; j < n; j++)
     220                {       bool found = Sxx[i].find(j) != Sxx[i].end();
     221                        ok &= (found == Check[i * n + j]);
     222                }
     223        }
     224
    166225        return ok;
    167226}
    168227
    169 bool case_three(bool packed)
     228bool case_three()
    170229{       bool ok = true;
    171230        using CppAD::AD;
     
    190249        CppAD::ADFun<double> f(X, Y);
    191250
     251        // ------------------------------------------------------------------
    192252        // sparsity pattern for the identity matrix
    193253        CppAD::vector<bool> r(n * n);
     
    200260
    201261        // compute sparsity pattern for J(x) = F^{(1)} (x)
    202         f.ForSparseJac(n, r, packed);
     262        f.ForSparseJac(n, r);
    203263
    204264        // compute sparsity pattern for H(x) = F_0^{(2)} (x)
     
    213273        ok  &= (h[ 0 * n + 0 ] == true);  // second partial w.r.t x[0], x[0]
    214274
     275        // ------------------------------------------------------------------
     276        // sparsity pattern for the identity function U(x) = x
     277        CPPAD_TEST_VECTOR< std::set<size_t> > Sx(n);
     278        for(i = 0; i < n; i++)
     279                Sx[i].insert(i);
     280
     281        // compute sparsity pattern for Jacobian of F(U(x))
     282        f.ForSparseJac(n, Sx);
     283
     284        // compute sparsity pattern for Hessian of F_0 ( U(x) )
     285        CPPAD_TEST_VECTOR< std::set<size_t> > Sy(1);
     286        Sy[0].insert(0);
     287        CPPAD_TEST_VECTOR< std::set<size_t> > Sxx(n);
     288        Sxx = f.RevSparseHes(n, Sy);
     289
     290        // check value
     291        bool found = Sxx[0].find(0) != Sxx[0].end();
     292        ok &= (found == true);
     293
    215294        return ok;
    216295}
    217296
    218 bool case_four(bool packed)
     297bool case_four()
    219298{       bool ok = true;
    220299        using namespace CppAD;
     
    268347        ADFun<double> F(X, Y);
    269348
     349        // -----------------------------------------------------
    270350        // compute the forward Jacobian sparsity pattern for F
    271351        CPPAD_TEST_VECTOR< bool > r(n * n);
     
    276356                r[ i * n + i ] = true;
    277357        }
    278         F.ForSparseJac(n, r, packed);
     358        F.ForSparseJac(n, r);
    279359
    280360        // compute the reverse Hessian sparsity pattern for F
     
    289369        }       
    290370
     371        // ------------------------------------------------------------------
     372        // sparsity pattern for the identity function U(x) = x
     373        CPPAD_TEST_VECTOR< std::set<size_t> > Sx(n);
     374        for(i = 0; i < n; i++)
     375                Sx[i].insert(i);
     376
     377        // compute sparsity pattern for Jacobian of F(U(x))
     378        F.ForSparseJac(n, Sx);
     379
     380        // compute sparsity pattern for Hessian of F_0 ( U(x) )
     381        CPPAD_TEST_VECTOR< std::set<size_t> > Sy(1);
     382        Sy[0].insert(0);
     383        CPPAD_TEST_VECTOR< std::set<size_t> > Sxx(n);
     384        Sxx = F.RevSparseHes(n, Sy);
     385
     386        // check values
     387        for(i = 0; i < n; i++)
     388        {       for(j = 0; j < n; j++)
     389                {       bool found = Sxx[i].find(j) != Sxx[i].end();
     390                        ok &= (found == Check[i * n + j]);
     391                }
     392        }
     393
    291394        return ok;
    292395}
     
    297400{       bool ok = true;
    298401
    299         ok &= case_one(true);
    300         ok &= case_two(true);
    301         ok &= case_three(true);
    302         ok &= case_four(true);
    303 
    304         ok &= case_one(false);
    305         ok &= case_two(false);
    306         ok &= case_three(false);
    307         ok &= case_four(false);
     402        ok &= case_one();
     403        ok &= case_two();
     404        ok &= case_three();
     405        ok &= case_four();
    308406
    309407        return ok;
  • trunk/test_more/rev_sparse_jac.cpp

    r1532 r1550  
    7070namespace { // BEGIN empty namespace
    7171
    72 bool case_one(bool packed)
     72bool case_one()
    7373{       bool ok = true;
    7474        using namespace CppAD;
     
    149149        ADFun<double> F(X, Y);
    150150
     151        // --------------------------------------------------------
    151152        // dependency matrix for the identity function U(y) = y
    152153        CPPAD_TEST_VECTOR< bool > Py(m * m);
     
    160161        // evaluate the dependency matrix for U(F(x))
    161162        CPPAD_TEST_VECTOR< bool > Px(m * n);
    162         Px = F.RevSparseJac(m, Py, packed);
     163        Px = F.RevSparseJac(m, Py);
    163164
    164165        // check values
     
    167168                        ok &= (Px[i * n + j] == Check[i * n + j]);
    168169        }       
     170        // --------------------------------------------------------
     171        // dependency matrix for the identity function U(y) = y
     172        CPPAD_TEST_VECTOR< std::set<size_t> > Sy(m);
     173        for(i = 0; i < m; i++)
     174        {       assert( Sy[i].empty() );
     175                Sy[i].insert(i);
     176        }
     177
     178        // evaluate the dependency matrix for U(F(x))
     179        CPPAD_TEST_VECTOR< std::set<size_t> > Sx(m);
     180        Sx = F.RevSparseJac(m, Sy);
     181
     182        // check values
     183        std::set<size_t>::iterator itr;
     184        bool found;
     185        for(i = 0; i < m; i++)
     186        {       for(j = 0; j < n; j++)
     187                {       found = Sx[i].find(j) != Sx[i].end();
     188                        ok    &= (found == Check[i * n + j]);
     189                }
     190        }       
    169191
    170192        return ok;
    171193}
    172194
    173 bool case_two(bool packed)
     195bool case_two()
    174196{       bool ok = true;
    175197        using namespace CppAD;
     
    246268        // evaluate the dependency matrix for S [ F(x) ]
    247269        CPPAD_TEST_VECTOR< bool > Px(m * n);
    248         Px = F.RevSparseJac(m, Py, packed);
     270        Px = F.RevSparseJac(m, Py);
    249271
    250272        // check values
     
    253275                        ok &= (Px[i * n + j] == Check[i * n + j]);
    254276        }       
     277        // --------------------------------------------------------
     278        // dependency matrix for the identity function U(y) = y
     279        CPPAD_TEST_VECTOR< std::set<size_t> > Sy(m);
     280        for(i = 0; i < m; i++)
     281        {       assert( Sy[i].empty() );
     282                Sy[i].insert(i);
     283        }
     284
     285        // evaluate the dependency matrix for U(F(x))
     286        CPPAD_TEST_VECTOR< std::set<size_t> > Sx(m);
     287        Sx = F.RevSparseJac(m, Sy);
     288
     289        // check values
     290        std::set<size_t>::iterator itr;
     291        bool found;
     292        for(i = 0; i < m; i++)
     293        {       for(j = 0; j < n; j++)
     294                {       found = Sx[i].find(j) != Sx[i].end();
     295                        ok    &= (found == Check[i * n + j]);
     296                }
     297        }       
    255298
    256299        return ok;
     
    262305{       bool ok = true;
    263306
    264         ok &= case_one(true);
    265         ok &= case_two(true);
    266 
    267         ok &= case_one(false);
    268         ok &= case_two(false);
     307        ok &= case_one();
     308        ok &= case_two();
    269309
    270310        return ok;
Note: See TracChangeset for help on using the changeset viewer.