Changeset 1588 for trunk/test_more


Ignore:
Timestamp:
Nov 24, 2009 3:26:48 PM (11 years ago)
Author:
bradbell
Message:

trunk: merge in branches/multiple_result:1584-158

Location:
trunk/test_more
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • trunk/test_more/for_sparse_jac.cpp

    r1550 r1588  
    301301}
    302302
     303bool case_three()
     304{       bool ok = true;
     305        using namespace CppAD;
     306
     307        // dimension of the domain space
     308        size_t n = 2;
     309
     310        // dimension of the range space
     311        size_t m = 3;
     312
     313        // independent variable vector
     314        CPPAD_TEST_VECTOR< AD<double> > X(n);
     315        X[0] = 2.;
     316        X[1] = 3.;
     317        Independent(X);
     318
     319        // dependent variable vector
     320        CPPAD_TEST_VECTOR< AD<double> > Y(m);
     321
     322        // check results vector
     323        CPPAD_TEST_VECTOR< bool >       Check(m * n);
     324
     325        // initialize index into Y
     326        size_t index = 0;
     327
     328        // Y[0] only depends on X[0];
     329        Y[index]             = pow(X[0], 2.);
     330        Check[index * n + 0] = true;
     331        Check[index * n + 1] = false;
     332        index++;
     333
     334        // Y[1] depends on X[1]
     335        Y[index]             = pow(2., X[1]);
     336        Check[index * n + 0] = false;
     337        Check[index * n + 1] = true;
     338        index++;
     339
     340        // Y[2] depends on X[0] and X[1]
     341        Y[index]             = pow(X[0], X[1]);
     342        Check[index * n + 0] = true;
     343        Check[index * n + 1] = true;
     344        index++;
     345
     346        // check final index
     347        assert( index == m );
     348
     349        // create function object F : X -> Y
     350        ADFun<double> F(X, Y);
     351
     352        // -----------------------------------------------------------------
     353        // dependency matrix for the identity function
     354        CPPAD_TEST_VECTOR< bool > Px(n * n);
     355        size_t i, j;
     356        for(i = 0; i < n; i++)
     357        {       for(j = 0; j < n; j++)
     358                        Px[ i * n + j ] = false;
     359                Px[ i * n + i ] = true;
     360        }
     361
     362        // evaluate the dependency matrix for F(X(x))
     363        CPPAD_TEST_VECTOR< bool > Py(m * n);
     364        Py = F.ForSparseJac(n, Px);
     365
     366        // check values
     367        for(i = 0; i < m; i++)
     368        {       for(j = 0; j < n; j++)
     369                        ok &= (Py[i * n + j] == Check[i * n + j]);
     370        }       
     371
     372        // ---------------------------------------------------------
     373        // dependency matrix for the identity function
     374        CPPAD_TEST_VECTOR< std::set<size_t> > Sx(n);
     375        for(i = 0; i < n; i++)
     376        {       assert( Sx[i].empty() );
     377                Sx[i].insert(i);
     378        }
     379
     380        // evaluate the dependency matrix for F(X(x))
     381        CPPAD_TEST_VECTOR< std::set<size_t> > Sy(m);
     382        Sy = F.ForSparseJac(n, Sx);
     383
     384        // check values
     385        bool found;
     386        for(i = 0; i < m; i++)
     387        {       for(j = 0; j < n; j++)
     388                {       found = Sy[i].find(j) != Sy[i].end();
     389                        ok &= (found == Check[i * n + j]);
     390                }
     391        }       
     392
     393        return ok;
     394}
     395
    303396} // End empty namespace
    304397
     
    308401        ok &= case_one();
    309402        ok &= case_two();
     403        ok &= case_three();
    310404
    311405        return ok;
  • trunk/test_more/rev_sparse_hes.cpp

    r1579 r1588  
    409409        CPPAD_TEST_VECTOR< AD<double> > Y(m);
    410410        Y[0] = pow(X[0], 2.);
    411         Y[1] = pow(2., X[0]);
     411        Y[1] = pow(2., X[1]);
    412412
    413413        // create function object F : X -> Y
     
    433433                for(i = 0; i < n; i++)
    434434                {       for(j = 0; j < n; j++)
    435                         {       bool check = (i == 0) & (j == 0);
     435                        {       bool check = (i == k) & (j == k);
    436436                                ok        &= Pxx[i * n + j] == check;
    437437                        }
  • trunk/test_more/rev_sparse_jac.cpp

    r1550 r1588  
    159159        }
    160160
    161         // evaluate the dependency matrix for U(F(x))
     161        // evaluate the dependency matrix for F(x)
    162162        CPPAD_TEST_VECTOR< bool > Px(m * n);
    163163        Px = F.RevSparseJac(m, Py);
     
    300300}
    301301
     302bool case_three()
     303{       bool ok = true;
     304        using namespace CppAD;
     305
     306        // dimension of the domain space
     307        size_t n = 2;
     308
     309        // dimension of the range space
     310        size_t m = 3;
     311
     312        // independent variable vector
     313        CPPAD_TEST_VECTOR< AD<double> > X(n);
     314        X[0] = 2.;
     315        X[1] = 3.;
     316        Independent(X);
     317
     318        // dependent variable vector
     319        CPPAD_TEST_VECTOR< AD<double> > Y(m);
     320
     321        // check results vector
     322        CPPAD_TEST_VECTOR< bool >       Check(m * n);
     323
     324        // initialize index into Y
     325        size_t index = 0;
     326
     327        // Y[0] only depends on X[0];
     328        Y[index]             = pow(X[0], 2.);
     329        Check[index * n + 0] = true;
     330        Check[index * n + 1] = false;
     331        index++;
     332
     333        // Y[1] depends on X[1]
     334        Y[index]             = pow(2., X[1]);
     335        Check[index * n + 0] = false;
     336        Check[index * n + 1] = true;
     337        index++;
     338
     339        // Y[2] depends on X[0] and X[1]
     340        Y[index]             = pow(X[0], X[1]);
     341        Check[index * n + 0] = true;
     342        Check[index * n + 1] = true;
     343        index++;
     344
     345        // check final index
     346        assert( index == m );
     347
     348        // create function object F : X -> Y
     349        ADFun<double> F(X, Y);
     350
     351        // -----------------------------------------------------------------
     352        // dependency matrix for the identity function
     353        CPPAD_TEST_VECTOR< bool > Py(m * m);
     354        size_t i, j;
     355        for(i = 0; i < m; i++)
     356        {       for(j = 0; j < m; j++)
     357                        Py[ i * m + j ] = (i == j);
     358        }
     359
     360        // evaluate the dependency matrix for F(x)
     361        CPPAD_TEST_VECTOR< bool > Px(m * n);
     362        Px = F.RevSparseJac(m, Py);
     363
     364        // check values
     365        for(i = 0; i < m; i++)
     366        {       for(j = 0; j < n; j++)
     367                        ok &= (Px[i * n + j] == Check[i * n + j]);
     368        }       
     369
     370        // ---------------------------------------------------------
     371        // dependency matrix for the identity function
     372        CPPAD_TEST_VECTOR< std::set<size_t> > Sy(m);
     373        for(i = 0; i < m; i++)
     374        {       assert( Sy[i].empty() );
     375                Sy[i].insert(i);
     376        }
     377
     378        // evaluate the dependency matrix for F(x)
     379        CPPAD_TEST_VECTOR< std::set<size_t> > Sx(m);
     380        Sx = F.RevSparseJac(m, Sy);
     381
     382        // check values
     383        bool found;
     384        for(i = 0; i < m; i++)
     385        {       for(j = 0; j < n; j++)
     386                {       found = Sx[i].find(j) != Sx[i].end();
     387                        ok &= (found == Check[i * n + j]);
     388                }
     389        }       
     390
     391        return ok;
     392}
     393
    302394} // END empty namespace
    303395
     
    307399        ok &= case_one();
    308400        ok &= case_two();
     401        ok &= case_three();
    309402
    310403        return ok;
Note: See TracChangeset for help on using the changeset viewer.