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;
}
