void integrateVector( int n, double * y, double kappa, int m, double * vertices, double tol, int fdim, double * result ) { double * val = new double[fdim]; double * err = new double[fdim]; double * xmin = new double[n ]; double * xmax = new double[n ]; for (int i = 0; i < n ; i++ ) { xmin[i] = 0; xmax[i] = 1; } double * fdata = new double[1 + 1 + n + m]; fdata[0] = kappa; fdata[1] = detA( vertices, n ); memcpy( fdata + 2, y, n * sizeof(double) ); memcpy( fdata + 2 + n, vertices, m * sizeof(double) ); hcubature( fdim, //unsigned fdim FUNCTION_NAME, //integrand f - need to replace this line, ow won't compile!! fdata, //void *fdata n, //unsigned dim xmin, //const double *xmin xmax, //const double *xmax 0, //size_t maxEval tol, //double reqAbsError tol, //double reqRelError ERROR_INDIVIDUAL, //error_norm norm val, //double *valx err ); //double *err for (int i = 0; i < fdim ; i++ ) { result[i] = result[i] + val[i]; if isnan( val[i] ) { printf( "NaN! Vertices = \n" ); printData( fdata, 2 ); } } delete[] fdata; delete[] val; delete[] err; delete[] xmin; delete[] xmax; }
bool link_det_minor( size_t size , size_t repeat , CppAD::vector<double> &matrix , CppAD::vector<double> &gradient ) { // ----------------------------------------------------- // setup // object for computing determinant typedef CppAD::AD<double> ADScalar; typedef CppAD::vector<ADScalar> ADVector; CppAD::det_by_minor<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 ADVector A(n); // AD domain space vector ADVector detA(m); // AD range space vector // vectors of reverse mode weights CppAD::vector<double> w(1); w[0] = 1.; // the AD function object CppAD::ADFun<double> f; static bool printed = false; bool print_this_time = (! printed) & (repeat > 1) & (size >= 3); extern bool global_retape; if( global_retape ) while(repeat--) { // choose a matrix CppAD::uniform_01(n, matrix); for( i = 0; i < size * size; i++) A[i] = matrix[i]; // declare independent variables Independent(A); // AD computation of the determinant detA[0] = Det(A); // create function object f : A -> detA f.Dependent(A, detA); extern bool global_optimize; if( global_optimize ) { size_t before, after; before = f.size_var(); f.optimize(); if( print_this_time ) { after = f.size_var(); std::cout << "cppad_det_minor_optimize_size_" << int(size) << " = [ " << int(before) << ", " << int(after) << "]" << std::endl; printed = true; print_this_time = false; } } // get the next matrix CppAD::uniform_01(n, matrix); // evaluate the determinant at the new matrix value f.Forward(0, matrix); // evaluate and return gradient using reverse mode gradient = f.Reverse(1, w); } else { // choose a matrix CppAD::uniform_01(n, matrix); for( i = 0; i < size * size; i++) A[i] = matrix[i]; // declare independent variables Independent(A); // AD computation of the determinant detA[0] = Det(A); // create function object f : A -> detA CppAD::ADFun<double> f; f.Dependent(A, detA); extern bool global_optimize; if( global_optimize ) { size_t before, after; before = f.size_var(); f.optimize(); if( print_this_time ) { after = f.size_var(); std::cout << "optimize: size = " << size << ": size_var() = " << before << "(before) " << after << "(after) " << std::endl; printed = true; print_this_time = false; } } // ------------------------------------------------------ while(repeat--) { // get the next matrix CppAD::uniform_01(n, matrix); // evaluate the determinant at the new matrix value f.Forward(0, matrix); // evaluate and return gradient using reverse mode gradient = f.Reverse(1, w); } } return true; }
bool link_det_minor( size_t size , size_t repeat , CppAD::vector<double> &matrix , CppAD::vector<double> &gradient ) { // speed test global option values if( global_option["atomic"] ) return false; // ----------------------------------------------------- // setup // object for computing determinant typedef CppAD::AD<double> ADScalar; typedef CppAD::vector<ADScalar> ADVector; CppAD::det_by_minor<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 ADVector A(n); // AD domain space vector ADVector detA(m); // AD range space vector // vectors of reverse mode weights CppAD::vector<double> w(1); w[0] = 1.; // the AD function object CppAD::ADFun<double> f; // --------------------------------------------------------------------- if( ! global_option["onetape"] ) while(repeat--) { // choose a matrix CppAD::uniform_01(n, matrix); for( i = 0; i < size * size; i++) A[i] = matrix[i]; // declare independent variables Independent(A); // AD computation of the determinant detA[0] = Det(A); // create function object f : A -> detA f.Dependent(A, detA); if( global_option["optimize"] ) f.optimize(); // skip comparison operators f.compare_change_count(0); // evaluate the determinant at the new matrix value f.Forward(0, matrix); // evaluate and return gradient using reverse mode gradient = f.Reverse(1, w); } else { // choose a matrix CppAD::uniform_01(n, matrix); for( i = 0; i < size * size; i++) A[i] = matrix[i]; // declare independent variables Independent(A); // AD computation of the determinant detA[0] = Det(A); // create function object f : A -> detA f.Dependent(A, detA); if( global_option["optimize"] ) f.optimize(); // skip comparison operators f.compare_change_count(0); // ------------------------------------------------------ while(repeat--) { // get the next matrix CppAD::uniform_01(n, matrix); // evaluate the determinant at the new matrix value f.Forward(0, matrix); // evaluate and return gradient using reverse mode gradient = f.Reverse(1, w); } } return true; }