Prev Next sparse_evaluate.hpp Headings

Source: sparse_evaluate
# ifndef CPPAD_SPARSE_EVALUATE_INCLUDED
# define CPPAD_SPARSE_EVALUATE_INCLUDED
# include <cppad/local/cppad_assert.hpp>
# include <cppad/check_numeric_type.hpp>
# include <cppad/vector.hpp>

namespace CppAD {
     template <class Float>
     void sparse_evaluate(
          const CppAD::vector<Float>  &x  ,
          const CppAD::vector<size_t> &i  , 
          const CppAD::vector<size_t> &j  , 
          size_t                       m  ,
          CppAD::vector<Float>       &fm  )
     {
          // check numeric type specifications
          CheckNumericType<Float>();

          size_t k;
          size_t n    = x.size();
          size_t size = 1;
          for(k = 0; k < m; k++)
               size *= n;
          CPPAD_ASSERT_KNOWN(
               fm.size() == size,
               "sparse_evaluate: size of fm not equal n^m"
          );
          for(k = 0; k < size; k++)
               fm[k] = Float(0);

          size_t ell = i.size();
          Float t;
          Float dt_i;
          Float dt_j;
          for(k = 0; k < ell; k++)
          {    t    = exp( x[i[k]] * x[j[k]] );   
               dt_i = t * x[j[k]];
               dt_j = t * x[i[k]];
               switch(m)
               {    case 0:
                    fm[0] += t;
                    break;

                    case 1:
                    fm[i[k]] += dt_i;
                    fm[j[k]] += dt_j;
                    break;

                    case 2:
                    fm[i[k] * n + i[k]] += dt_i * x[j[k]];
                    fm[i[k] * n + j[k]] += t + dt_j * x[j[k]];
                    fm[j[k] * n + i[k]] += t + dt_i * x[i[k]];
                    fm[j[k] * n + j[k]] += dt_j * x[i[k]];
                    break;
               }
          }
               
     }
}
# endif

Input File: omh/sparse_evaluate.omh