Fadbad Speed: Gradient of Determinant Using Lu Factorization
Keywords: fadbad speed: gradient determinant using lu factorization link_det_lu speed matrix factor specifications implementation

| Prev | Next |  |  |  |  |  | fadbad_det_lu.cpp |

Fadbad Speed: Gradient of Determinant Using Lu Factorization
Specifications
See link_det_lu .
Implementation `

    # include <FADBAD++/badiff.h>
    # include <cppad/speed/det_by_lu.hpp>
    # include <cppad/speed/uniform_01.hpp>
    # include <cppad/utility/vector.hpp>

    // list of possible options
    extern bool global_memory, global_onetape, global_atomic, global_optimize;

    bool link_det_lu(
         size_t                     size     ,
         size_t                     repeat   ,
         CppAD::vector<double>     &matrix   ,
         CppAD::vector<double>     &gradient )
    {
         // speed test global option values
         if( global_onetape || global_atomic )
              return false;
         if( global_memory || global_optimize )
              return false;
         // -----------------------------------------------------
         // setup
         //
         // object for computing determinant
         typedef fadbad::B<double>       ADScalar;
         typedef CppAD::vector<ADScalar> ADVector;
         CppAD::det_by_lu<ADScalar>      Det(size);

         size_t i;                // temporary index
         size_t m = 1;            // number of dependent variables
         size_t n = size * size;  // number of independent variables
         ADScalar   detA;         // AD value of the determinant
         ADVector   A(n);         // AD version of matrix

         // ------------------------------------------------------
         while(repeat--)
           {  // get the next matrix
              CppAD::uniform_01(n, matrix);

              // set independent variable values
              for(i = 0; i < n; i++)
                   A[i] = matrix[i];

              // compute the determinant
              detA = Det(A);

              // create function object f : A -> detA
              detA.diff(0, m);  // index 0 of m dependent variables

              // evaluate and return gradient using reverse mode
              for(i =0; i < n; i++)
                   gradient[i] = A[i].d(0); // partial detA w.r.t A[i]
         }
         // ---------------------------------------------------------
         return true;
    }

`

Input File: speed/fadbad/det_lu.cpp