Changeset 3812


Ignore:
Timestamp:
Mar 27, 2016 12:48:08 PM (4 years ago)
Author:
bradbell
Message:

merge to branch: trunk
from repository: https://github.com/coin-or/CppAD
start hash code: 33d1f5b8d837d83c8baf656045d85d8b45f0b297
end hash code: 30860e98aa7f7b69ac6deb83ed8e564a46ef96a1

commit 30860e98aa7f7b69ac6deb83ed8e564a46ef96a1
Author: Brad Bell <bradbell@…>
Date: Sun Mar 27 09:09:58 2016 -0700

eigen_mat_inv.hpp: use a simple over estimate of output variables.
eigen_mat_inv.cpp: remove test of output variable information.
eigen_mat_inv.cpp: prepare for more tests.

Location:
trunk
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • trunk/cppad/example/eigen_mat_inv.hpp

    r3811 r3812  
    268268                        return true;
    269269                // ------------------------------------------------------------------
    270                 // compute variable information for y; i.e., vy
    271                 // (note that the constant zero times a variable is a constant)
    272                 scalar zero(0.0);
    273                 assert( n_order == 1 );
    274                 for(size_t j = 0; j < nr_; j++)
    275                 {       // only row j of this column of the identity is non-zero
    276                         // initialize which elements of column j of result are variables
    277                         for(size_t i = 0; i < nr_; i++)
    278                         {       // initialize vy as false
    279                                 size_t index = i * nr_ + j;
    280                                 vy[index]    = false;
    281                         }
    282                         // determine if any elements in row j of argument are variables
    283                         bool row_var = false;
    284                         for(size_t ell = 0; ell < nr_; ell++)
    285                         {       // arg information
    286                                 size_t index  = j * nr_ + ell;
    287                                 row_var      |= vx[index];
    288                         }
    289                         if( row_var )
    290                         {       for(size_t ell = 0; ell < nr_; ell++)
    291                                 {       // arg information
    292                                         size_t index = j * nr_ + ell;
    293                                         bool not_zero = f_arg_[0](j, ell) != scalar(0.0);
    294                                         bool var      = vx[index];
    295                                         if( not_zero | var )
    296                                         {       // result information
    297                                                 index = ell * nr_ + j;
    298                                                 vy[index] = true;
    299                                         }
    300                                 }
    301                         }
    302                 }
     270                // This is a very dumb algorithm that over estimates which
     271                // elements of the inverse are variables (which is not efficient).
     272                bool var = false;
     273                for(size_t i = 0; i < nx_; i++)
     274                        var |= vx[i];
     275                for(size_t i = 0; i < nx_; i++)
     276                        vy[i] = var;
    303277                return true;
    304278        }
  • trunk/example/atomic/eigen_mat_inv.cpp

    r3811 r3812  
    105105        ad_matrix ad_result   = mat_mul.op(ad_left_inv, ad_right);
    106106        // -------------------------------------------------------------------
    107         // check that first component of result is a parameter
    108         // and the second component is a varaible.
    109         ok &= Parameter( ad_result(0, 0) );
    110         ok &= Variable(  ad_result(1, 0) );
    111         // -------------------------------------------------------------------
    112107        // declare the dependent variable vector y
    113108        size_t m = 2;
  • trunk/omh/whats_new/whats_new_16.omh

    r3811 r3812  
    4141
    4242$head 03-27$$
     43$list number$$
    4344Fix a bug in the calculation of the $cref atomic_eigen_mat_inv.hpp$$
    4445$cref/reverse/atomic_eigen_mat_inv.hpp/Private/reverse/$$ example.
     46$lnext
     47Use a very simple method (that over estimates variables) for calculating
     48$cref/vy/atomic_forward/vy/$$ in the $cref atomic_eigen_mat_inv.hpp$$
     49$cref/forward/atomic_eigen_mat_inv.hpp/Private/forward/$$ example.
     50$lend
    4551
    4652$head 03-26$$
  • trunk/test_more/eigen_mat_inv.cpp

    r3811 r3812  
    1010Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
    1111-------------------------------------------------------------------------- */
     12# include <cppad/cppad.hpp>
     13# include <cppad/example/eigen_mat_inv.hpp>
     14
     15namespace { // BEGIN_EMPTY_NAMESPACE
     16
     17typedef double                                            scalar;
     18typedef CppAD::AD<scalar>                                 ad_scalar;
     19typedef typename atomic_eigen_mat_inv<scalar>::ad_matrix  ad_matrix;
     20
     21scalar eps = 10. * std::numeric_limits<scalar>::epsilon();
     22using CppAD::NearEqual;
     23// --------------------------------------------------------------------------
    1224/*
    1325Test atomic_eigen_mat_inv using a non-symetric matrix
     
    2436y[3] = x[0] / (x[0] * x[1] + 2)
    2537*/
    26 # include <cppad/cppad.hpp>
    27 # include <cppad/example/eigen_mat_inv.hpp>
    28 
    29 
    30 bool eigen_mat_inv(void)
     38bool non_symmetric(void)
    3139{
    32         typedef double                                            scalar;
    33         typedef CppAD::AD<scalar>                                 ad_scalar;
    34         typedef typename atomic_eigen_mat_inv<scalar>::ad_matrix  ad_matrix;
    35         //
    3640        bool ok    = true;
    37         scalar eps = 10. * std::numeric_limits<scalar>::epsilon();
    38         using CppAD::NearEqual;
    3941        // -------------------------------------------------------------------
    40         // object that computes invers of a 2x2 matrix
     42        // object that computes inverse of a 2x2 matrix
    4143        size_t nr  = 2;
    4244        atomic_eigen_mat_inv<scalar> mat_inv(nr);
     
    157159        return ok;
    158160}
     161
     162} // END_EMPTY_NAMESPACE
     163
     164bool eigen_mat_inv(void)
     165{       bool ok = true;
     166        ok     &= non_symmetric();
     167        return ok;
     168}
Note: See TracChangeset for help on using the changeset viewer.