SEXP R_split_up_2sample(SEXP scores, SEXP m, SEXP obs, SEXP tol) {
/*
R interface to the split-up algorithm.
'scores' is a REAL vector giving the scores of the total sample
and 'm' is a scalar integer with the sample size of one group.
'obs' is the scalar observed test statistic, namely the
sum of the 'm' scores measured in one group.
*/
int b, c, u;
double tot, bino, prob;
double ob;
SEXP ans;
celW **W1;
celW **W2;
double *rs;
b = LENGTH(scores);
rs = REAL(scores);
c = INTEGER(m)[0];
/* d = b - INTEGER(m)[0]; not used */
ob = REAL(obs)[0];
/* total number of possible permutations */
bino = binomi(b, c);
/* allocate and initialise memory */
W1 = reserveW(c, (b+1)/2);
initW(c, (b+1)/2, W1);
W2 = reserveW(c, (b+1)/2);
initW(c, (b+1)/2, W2);
makeW(W1, c, b/2, 0, rs, REAL(tol)[0]);
makeW(W2, c, (b+1)/2, b/2, rs, REAL(tol)[0]);
for (u = 0; u <= c; u++) cumulcoef(W2, u, (b+1)/2);
/* number of permutations <= ob */
tot = numbersmall(c, b, ob, W1, W2, REAL(tol)[0]);
/* probability */
prob = tot/bino;
/* free memory: this will _not_ take place
in case of an error */
FreeW(c, W1);
FreeW(c, W2);
/* return to R */
PROTECT(ans = allocVector(REALSXP, 1));
REAL(ans)[0] = prob;
UNPROTECT(1);
return(ans);
}
/*--------------------------------------------------------------------------*/
int address( int d, int* im ) {
int i,
add = 0;
for (i=0; i<d; i++)
add += binomi(im[i]+i,i+1);
return add;
}
/* MAIN PROGRAM */
int main() {
int i, j, k;
int tag = 1; /* tape tag */
int taskCount = 0;
int pFW, pRV, pTR, degree, keep; /* forward/reverse parameters */
int evalCount; /* # of evaluations */
/****************************************************************************/
/* READ CONTROL PARAMETERS FROM FILE */
int controlParameters[cpCount];
FILE* controlFile;
/*------------------------------------------------------------------------*/
/* open file to read */
if ((controlFile = fopen(controlFileName,"r")) == NULL) {
fprintf(stdout,"ERROR: Could not open control file %s\n",
controlFileName);
exit(-1);
}
/*------------------------------------------------------------------------*/
/* read all values */
for (i=0; i<cpCount; i++)
fscanf(controlFile,"%d%*[^\n]",&controlParameters[i]);
indepDim = controlParameters[cpDimension];
pFW = controlParameters[cpVecCountFW];
pRV = controlParameters[cpVecCountRV];
pTR = controlParameters[cpVecCountTR];
degree = controlParameters[cpDegree];
evalCount = controlParameters[cpAverageCount];
/*------------------------------------------------------------------------*/
/* close control file */
fclose(controlFile);
/****************************************************************************/
/* VARIABLES & INITIALIZATION */
/*------------------------------------------------------------------------*/
/* Initialize all problem parameters (including dimension) */
initProblemParameters();
/*------------------------------------------------------------------------*/
/* Initialize the independent variables */
double* indeps = new double[indepDim];
initIndependents(indeps);
/*------------------------------------------------------------------------*/
/* Check main parameters */
if (evalCount <= 0) {
fprintf(stdout," # of evaluations to average over = ? ");
fscanf(stdin,"%d",&evalCount);
fprintf(stdout,"\n");
}
if ((degree <= 1) &&
(controlParameters[cpHosFW] || controlParameters[cpHovFW] ||
controlParameters[cpHosRV] || controlParameters[cpHovRV] ||
controlParameters[cpTensor])) {
fprintf(stdout," degree = ? ");
fscanf(stdin,"%d",°ree);
fprintf(stdout,"\n");
}
keep = degree + 1;
if ((pFW < 1) &&
(controlParameters[cpFovFW] || controlParameters[cpHovFW])) {
fprintf(stdout," # of vectors in vector forward mode = ? ");
fscanf(stdin,"%d",&pFW);
fprintf(stdout,"\n");
}
if ((pRV < 1) &&
(controlParameters[cpFovRV] || controlParameters[cpHovRV])) {
fprintf(stdout," # of vectors in vector reverse mode = ? ");
fscanf(stdin,"%d",&pRV);
fprintf(stdout,"\n");
}
if ((pTR < 1) &&
(controlParameters[cpTensor])) {
fprintf(stdout," # of vectors in tensor mode = ? ");
fscanf(stdin,"%d",&pTR);
fprintf(stdout,"\n");
}
/*------------------------------------------------------------------------*/
/* Necessary variable */
double depOrig=0.0, depTape; /* function value */
double ***XPPP, **XPP;
double ***YPPP, **YPP, *YP;
double ***ZPPP, **ZPP, *ZP;
double *UP, u;
double *VP;
double *WP;
double *JP;
short **nzPP;
int retVal=0; /* return value */
double t00, t01, t02, t03; /* time values */
double **TPP;
double **SPP;
double **HPP;
int dim;
/****************************************************************************/
/* NORMALIZE TIMER */
/****************************************************************************/
/* 0. ORIGINAL FUNCTION EVALUATION */
/* ---> always */
fprintf(stdout,"\nTASK %d: Original function evaluation\n",
taskCount++);
t00 = myclock();
for (i=0; i<evalCount; i++)
depOrig = originalScalarFunction(indeps);
t01 = myclock();
double timeUnit;
if (t01-t00) {
timeUnit = 1.0/(t01-t00);
fprintf(stdout," ");
fprintf(stdout,TIMEFORMAT,1.0,
(t01-t00)/evalCount);
} else {
fprintf(stdout," !!! zero timing !!!\n");
fprintf(stdout," set time unit to 1.0\n");
timeUnit = 1;
}
/****************************************************************************/
/* 1. TAPING THE FUNCTION */
/* ---> always */
fprintf(stdout,"--------------------------------------------------------");
fprintf(stdout,"\nTASK %d: Taping the function\n",
taskCount++);
t00 = myclock();
/* NOTE: taping will be performed ONCE only */
depTape = tapingScalarFunction(tag,indeps);
t01 = myclock();
size_t tape_stats[STAT_SIZE];
tapestats(tag,tape_stats);
fprintf(stdout,"\n independents %zu\n",tape_stats[NUM_INDEPENDENTS]);
fprintf(stdout," dependents %zu\n",tape_stats[NUM_DEPENDENTS]);
fprintf(stdout," operations %zu\n",tape_stats[NUM_OPERATIONS]);
fprintf(stdout," operations buffer size %zu\n",tape_stats[OP_BUFFER_SIZE]);
fprintf(stdout," locations buffer size %zu\n",tape_stats[LOC_BUFFER_SIZE]);
fprintf(stdout," constants buffer size %zu\n",tape_stats[VAL_BUFFER_SIZE]);
fprintf(stdout," maxlive %zu\n",tape_stats[NUM_MAX_LIVES]);
fprintf(stdout," valstack size %zu\n\n",tape_stats[TAY_STACK_SIZE]);
fprintf(stdout," ");
fprintf(stdout,TIMEFORMAT,(t01-t00)*timeUnit*evalCount,
(t01-t00));
/****************************************************************************/
/* 2. ZOS_FORWARD */
if (controlParameters[cpZosFW]) {
fprintf(stdout,"--------------------------------------------------------");
fprintf(stdout,"\nTASK %d: forward(tag, m=1, n=%d, keep, X[n], Y[m])\n",
taskCount++,indepDim);
fprintf(stdout," ---> zos_forward\n");
/*----------------------------------------------------------------------*/
/* NO KEEP */
t00 = myclock();
for (i=0; i<evalCount; i++)
retVal = forward(tag,1,indepDim,0,indeps,&depTape);
t01 = myclock();
fprintf(stdout," NO KEEP");
fprintf(stdout,TIMEFORMAT,(t01-t00)*timeUnit,
(t01-t00)/evalCount);
/*----------------------------------------------------------------------*/
/* KEEP */
t02 = myclock();
for (i=0; i<evalCount; i++)
retVal = forward(tag,1,indepDim,1,indeps,&depTape);
t03 = myclock();
fprintf(stdout," KEEP ");
fprintf(stdout,TIMEFORMAT,(t03-t02)*timeUnit,
(t03-t02)/evalCount);
/*----------------------------------------------------------------------*/
/* Debug infos */
if (controlParameters[cpZosFW] > 1) {
fprintf(stdout,"\n Return value: %d\n",retVal);
fprintf(stdout," Should be the same values:\n");
fprintf(stdout," (original) %12.8E =? %12.8E (forward from tape)\n",
depOrig,depTape);
}
}
/****************************************************************************/
/* 3. FOS_FORWARD */
if (controlParameters[cpFosFW]) {
fprintf(stdout,"--------------------------------------------------------");
fprintf(stdout,"\nTASK %d: forward(tag, m=1, n=%d, d=1, keep, X[n][d+1], Y[d+1])\n",
taskCount++,indepDim);
fprintf(stdout," ---> fos_forward\n");
/*----------------------------------------------------------------------*/
/* Allocation & initialisation of tensors */
XPP = new double*[indepDim];
for (i=0; i<indepDim; i++) {
XPP[i] = new double[2];
XPP[i][0] = indeps[i];
XPP[i][1] = (double)rand();
}
YP = new double[2];
/*----------------------------------------------------------------------*/
/* NO KEEP */
t00 = myclock();
for (i=0; i<evalCount; i++)
retVal = forward(tag,1,indepDim,1,0,XPP,YP);
t01 = myclock();
fprintf(stdout," NO KEEP");
fprintf(stdout,TIMEFORMAT,(t01-t00)*timeUnit,
(t01-t00)/evalCount);
/*----------------------------------------------------------------------*/
/* KEEP */
t02 = myclock();
for (i=0; i<evalCount; i++)
retVal = forward(tag,1,indepDim,1,2,XPP,YP);
t03 = myclock();
fprintf(stdout," KEEP ");
fprintf(stdout,TIMEFORMAT,(t03-t02)*timeUnit,
(t03-t02)/evalCount);
/*----------------------------------------------------------------------*/
/* Debug infos */
if (controlParameters[cpFosFW] > 1) {
fprintf(stdout,"\n Return value: %d\n",retVal);
fprintf(stdout," Should be the same values:\n");
fprintf(stdout," (original) %12.8E =? %12.8E (forward from tape)\n",
depOrig,YP[0]);
}
/*----------------------------------------------------------------------*/
/* Free tensors */
for (i=0; i<indepDim; i++)
delete[] XPP[i];
delete[] XPP;
delete[] YP;
}
/****************************************************************************/
/* 4. HOS_FORWARD */
if (controlParameters[cpHosFW]) {
fprintf(stdout,"--------------------------------------------------------");
fprintf(stdout,"\nTASK %d: forward(tag, m=1, n=%d, d=%d, keep, X[n][d+1], Y[d+1])\n",
taskCount++,indepDim,degree);
fprintf(stdout," ---> hos_forward\n");
/*----------------------------------------------------------------------*/
/* Allocation & initialisation of tensors */
XPP = new double*[indepDim];
for (i=0; i<indepDim; i++) {
XPP[i] = new double[1+degree];
XPP[i][0] = indeps[i];
for (j=1; j<=degree; j++)
XPP[i][j] = (double)rand();
}
YP = new double[1+degree];
/*----------------------------------------------------------------------*/
/* NO KEEP */
t00 = myclock();
for (i=0; i<evalCount; i++)
retVal = forward(tag,1,indepDim,degree,0,XPP,YP);
t01 = myclock();
fprintf(stdout," NO KEEP");
fprintf(stdout,TIMEFORMAT,(t01-t00)*timeUnit,
(t01-t00)/evalCount);
/*----------------------------------------------------------------------*/
/* KEEP */
t02 = myclock();
for (i=0; i<evalCount; i++)
retVal = forward(tag,1,indepDim,degree,keep,XPP,YP);
t03 = myclock();
fprintf(stdout," KEEP ");
fprintf(stdout,TIMEFORMAT,(t03-t02)*timeUnit,
(t03-t02)/evalCount);
/*----------------------------------------------------------------------*/
/* Debug infos */
if (controlParameters[cpHosFW] > 1) {
fprintf(stdout,"\n Return value: %d\n",retVal);
fprintf(stdout," Should be the same values:\n");
fprintf(stdout," (original) %12.8E =? %12.8E (forward from tape)\n",
depOrig,YP[0]);
}
/*----------------------------------------------------------------------*/
/* Free tensors */
for (i=0; i<indepDim; i++)
delete[] XPP[i];
delete[] XPP;
delete[] YP;
}
/****************************************************************************/
/* 5. FOV_FORWARD */
if (controlParameters[cpFovFW]) {
fprintf(stdout,"--------------------------------------------------------");
fprintf(stdout,"\nTASK %d: forward(tag, m=1, n=%d, p=%d, x[n], X[n][p], y[m], Y[m][p])\n",
taskCount++,indepDim,pFW);
fprintf(stdout," ---> fov_forward\n");
/*----------------------------------------------------------------------*/
/* Allocation & initialisation of tensors */
XPP = new double*[indepDim];
for (i=0; i<indepDim; i++) {
XPP[i] = new double[pFW];
for (j=0; j<pFW; j++)
XPP[i][j] = (double)rand();
}
YP = new double[1];
YPP = new double*[1];
YPP[0] = new double[pFW];
/*----------------------------------------------------------------------*/
/* always NO KEEP */
t00 = myclock();
for (i=0; i<evalCount; i++)
retVal = forward(tag,1,indepDim,pFW,indeps,XPP,YP,YPP);
t01 = myclock();
fprintf(stdout," (NO KEEP)");
fprintf(stdout,TIMEFORMAT,(t01-t00)*timeUnit,
(t01-t00)/evalCount);
/*----------------------------------------------------------------------*/
/* Debug infos */
if (controlParameters[cpFovFW] > 1) {
fprintf(stdout,"\n Return value: %d\n",retVal);
}
/*----------------------------------------------------------------------*/
/* Free tensors */
for (i=0; i<indepDim; i++)
delete[] XPP[i];
delete[] XPP;
delete[] YP;
delete[] YPP[0];
delete[] YPP;
}
/****************************************************************************/
/* 6. HOV_FORWARD */
if (controlParameters[cpHovFW]) {
fprintf(stdout,"--------------------------------------------------------");
fprintf(stdout,"\nTASK %d: forward(tag, m=1, n=%d, d=%d, p=%d, x[n], X[n][p][d], y[m], Y[m][p][d])\n",
taskCount++,indepDim,degree,pFW);
fprintf(stdout," ---> hov_forward\n");
/*----------------------------------------------------------------------*/
/* Allocation & initialisation of tensors */
XPPP = new double**[indepDim];
for (i=0; i<indepDim; i++) {
XPPP[i] = new double*[pFW];
for (j=0; j<pFW; j++) {
XPPP[i][j] = new double[degree];
for (k=0; k<degree; k++)
XPPP[i][j][k] = (double)rand();
}
}
YP = new double[1];
YPPP = new double**[1];
YPPP[0] = new double*[pFW];
for (j=0; j<pFW; j++)
YPPP[0][j] = new double[degree];
/*----------------------------------------------------------------------*/
/* always NO KEEP */
t00 = myclock();
for (i=0; i<evalCount; i++)
retVal = forward(tag,1,indepDim,degree,pFW,indeps,XPPP,YP,YPPP);
t01 = myclock();
fprintf(stdout," (NO KEEP)");
fprintf(stdout,TIMEFORMAT,(t01-t00)*timeUnit,
(t01-t00)/evalCount);
/*----------------------------------------------------------------------*/
/* Debug infos */
if (controlParameters[cpHovFW] > 1) {
fprintf(stdout,"\n Return value: %d\n",retVal);
}
/*----------------------------------------------------------------------*/
/* Free tensors */
for (i=0; i<indepDim; i++) {
for (j=0; j<pFW; j++)
delete[] XPPP[i][j];
delete[] XPPP[i];
}
delete[] XPPP;
delete[] YP;
for (j=0; j<pFW; j++)
delete[] YPPP[0][j];
delete[] YPPP[0];
delete[] YPPP;
}
/****************************************************************************/
/* 7. FOS_REVERSE */
if (controlParameters[cpFosRV]) {
fprintf(stdout,"--------------------------------------------------------");
fprintf(stdout,"\nTASK %d: reverse(tag, m=1, n=%d, d=0, u, Z[n])\n",
taskCount++,indepDim);
fprintf(stdout," ---> fos_reverse\n");
/*----------------------------------------------------------------------*/
/* Allocation & initialisation of tensors */
ZP = new double[indepDim];
u = (double)rand();
/*----------------------------------------------------------------------*/
/* Forward with keep*/
forward(tag,1,indepDim,1,indeps,&depTape);
/*----------------------------------------------------------------------*/
/* Reverse */
t00 = myclock();
for (i=0; i<evalCount; i++)
retVal = reverse(tag,1,indepDim,0,u,ZP);
t01 = myclock();
fprintf(stdout," ");
fprintf(stdout,TIMEFORMAT,(t01-t00)*timeUnit,
(t01-t00)/evalCount);
/*----------------------------------------------------------------------*/
/* Debug infos */
if (controlParameters[cpFosRV] > 1) {
fprintf(stdout,"\n Return value: %d\n",retVal);
}
/*----------------------------------------------------------------------*/
/* Free tensors */
delete[] ZP;
}
/****************************************************************************/
/* 8. HOS_REVERSE */
if (controlParameters[cpHosRV]) {
fprintf(stdout,"--------------------------------------------------------");
fprintf(stdout,"\nTASK %d: reverse(tag, m=1, n=%d, d=%d, u, Z[n][d+1])\n",
taskCount++,indepDim,degree);
fprintf(stdout," ---> hos_reverse\n");
/*----------------------------------------------------------------------*/
/* Allocation & initialisation of tensors */
ZPP = new double*[indepDim];
for (i=0; i<indepDim; i++)
ZPP[i] = new double[degree+1];
u = (double)rand();
XPP = new double*[indepDim];
for (i=0; i<indepDim; i++) {
XPP[i] = new double[1+degree];
XPP[i][0] = indeps[i];
for (j=1; j<=degree; j++)
XPP[i][j] = (double)rand();
}
YP = new double[1+degree];
/*----------------------------------------------------------------------*/
/* Forward with keep*/
forward(tag,1,indepDim,degree,keep,XPP,YP);
/*----------------------------------------------------------------------*/
/* Reverse */
t00 = myclock();
for (i=0; i<evalCount; i++)
retVal = reverse(tag,1,indepDim,degree,u,ZPP);
t01 = myclock();
fprintf(stdout," ");
fprintf(stdout,TIMEFORMAT,(t01-t00)*timeUnit,
(t01-t00)/evalCount);
/*----------------------------------------------------------------------*/
/* Debug infos */
if (controlParameters[cpHosRV] > 1) {
fprintf(stdout,"\n Return value: %d\n",retVal);
}
/*----------------------------------------------------------------------*/
/* Free tensors */
for (i=0; i<indepDim; i++)
delete[] ZPP[i];
delete[] ZPP;
for (i=0; i<indepDim; i++)
delete[] XPP[i];
delete[] XPP;
delete[] YP;
}
/****************************************************************************/
/* 9. FOV_REVERSE */
if (controlParameters[cpFovRV]) {
fprintf(stdout,"--------------------------------------------------------");
fprintf(stdout,"\nTASK %d: reverse(tag, m=1, n=%d, d=0, p=%d, U[p], Z[p][n])\n",
taskCount++,indepDim,pRV);
fprintf(stdout," ---> fov_reverse\n");
/*----------------------------------------------------------------------*/
/* Allocation & initialisation of tensors */
ZPP = new double*[pRV];
for (i=0; i<pRV; i++)
ZPP[i] = new double[indepDim];
UP = new double[pRV];
for (i=0; i<pRV; i++)
UP[i] = (double)rand();
/*----------------------------------------------------------------------*/
/* Forward with keep*/
forward(tag,1,indepDim,1,indeps,&depTape);
/*----------------------------------------------------------------------*/
/* Reverse */
t00 = myclock();
for (i=0; i<evalCount; i++)
retVal = reverse(tag,1,indepDim,0,pRV,UP,ZPP);
t01 = myclock();
fprintf(stdout," ");
fprintf(stdout,TIMEFORMAT,(t01-t00)*timeUnit,
(t01-t00)/evalCount);
/*----------------------------------------------------------------------*/
/* Debug infos */
if (controlParameters[cpFovRV] > 1) {
fprintf(stdout,"\n Return value: %d\n",retVal);
}
/*----------------------------------------------------------------------*/
/* Free tensors */
for (i=0; i<pRV; i++)
delete[] ZPP[i];
delete[] ZPP;
delete[] UP;
}
/****************************************************************************/
/* 10. HOV_REVERSE */
if (controlParameters[cpHovRV]) {
fprintf(stdout,"--------------------------------------------------------");
fprintf(stdout,"\nTASK %d: reverse(tag, m=1, n=%d, d=%d, p=%d, U[p], Z[p][n][d+1], nz[p][n])\n",
taskCount++,indepDim,degree,pRV);
fprintf(stdout," ---> hov_reverse\n");
/*----------------------------------------------------------------------*/
/* Allocation & initialisation of tensors */
ZPPP = new double**[pRV];
for (i=0; i<pRV; i++) {
ZPPP[i] = new double*[indepDim];
for (j=0; j<indepDim; j++)
ZPPP[i][j] = new double[degree+1];
}
UP = new double[pRV];
for (i=0; i<pRV; i++)
UP[i] = (double)rand();
XPP = new double*[indepDim];
for (i=0; i<indepDim; i++) {
XPP[i] = new double[1+degree];
XPP[i][0] = indeps[i];
for (j=1; j<=degree; j++)
XPP[i][j] = (double)rand();
}
YP = new double[1+degree];
nzPP = new short*[pRV];
for (i=0; i<pRV; i++)
nzPP[i] = new short[indepDim];
/*----------------------------------------------------------------------*/
/* Forward with keep*/
forward(tag,1,indepDim,degree,keep,XPP,YP);
/*----------------------------------------------------------------------*/
/* Reverse without nonzero pattern*/
t00 = myclock();
for (i=0; i<evalCount; i++)
retVal = reverse(tag,1,indepDim,degree,pRV,UP,ZPPP);
t01 = myclock();
fprintf(stdout," ");
fprintf(stdout,TIMEFORMAT,(t01-t00)*timeUnit,
(t01-t00)/evalCount);
/*----------------------------------------------------------------------*/
/* Reverse with nonzero pattern*/
t00 = myclock();
for (i=0; i<evalCount; i++)
retVal = reverse(tag,1,indepDim,degree,pRV,UP,ZPPP,nzPP);
t01 = myclock();
fprintf(stdout," (NZ)");
fprintf(stdout,TIMEFORMAT,(t01-t00)*timeUnit,
(t01-t00)/evalCount);
/*----------------------------------------------------------------------*/
/* Debug infos */
if (controlParameters[cpHovRV] > 1) {
fprintf(stdout,"\n Return value: %d\n",retVal);
}
/*----------------------------------------------------------------------*/
/* Free tensors */
for (i=0; i<pRV; i++) {
for (j=0; j<indepDim; j++)
delete[] ZPPP[i][j];
delete[] ZPPP[i];
delete[] nzPP[i];
}
delete[] ZPPP;
delete[] nzPP;
delete[] UP;
for (i=0; i<indepDim; i++)
delete[] XPP[i];
delete[] XPP;
delete[] YP;
}
/****************************************************************************/
/* 11. FUNCTION */
if (controlParameters[cpFunction]) {
fprintf(stdout,"--------------------------------------------------------");
fprintf(stdout,"\nTASK %d: function(tag, m=1, n=%d, X[n], Y[m])\n",
taskCount++,indepDim);
/*----------------------------------------------------------------------*/
/* Function evaluation */
t00 = myclock();
for (i=0; i<evalCount; i++)
retVal = function(tag,1,indepDim,indeps,&depTape);
t01 = myclock();
fprintf(stdout," ");
fprintf(stdout,TIMEFORMAT,(t01-t00)*timeUnit,
(t01-t00)/evalCount);
/*----------------------------------------------------------------------*/
/* Debug infos */
if (controlParameters[cpFunction] > 1) {
fprintf(stdout,"\n Return value: %d\n",retVal);
fprintf(stdout," Should be the same values:\n");
fprintf(stdout," (original) %12.8E =? %12.8E (forward from tape)\n",
depOrig,depTape);
}
}
/****************************************************************************/
/* 12. JACOBIAN */
if (controlParameters[cpJacobian]) {
fprintf(stdout,"--------------------------------------------------------");
fprintf(stdout,"\nTASK %d: gradient(tag, n=%d, X[n], G[n])\n",
taskCount++,indepDim);
/*----------------------------------------------------------------------*/
/* Allocation & initialisation of tensors */
JP = new double[indepDim];
/*----------------------------------------------------------------------*/
/* Gradient evaluation */
t00 = myclock();
for (i=0; i<evalCount; i++)
retVal = gradient(tag,indepDim,indeps,JP);
t01 = myclock();
fprintf(stdout," ");
fprintf(stdout,TIMEFORMAT,(t01-t00)*timeUnit,
(t01-t00)/evalCount);
/*----------------------------------------------------------------------*/
/* Debug infos */
if (controlParameters[cpJacobian] > 1) {
fprintf(stdout,"\n Return value: %d\n",retVal);
}
/*----------------------------------------------------------------------*/
/* Free tensors */
delete[] JP;
}
/****************************************************************************/
/* 13. VECJAC */
if (controlParameters[cpVecJac]) {
fprintf(stdout,"--------------------------------------------------------");
fprintf(stdout,"\nTASK %d: vec_jac(tag, m=1, n=%d, repeat, X[n], U[m], V[n])\n",
taskCount++,indepDim);
/*----------------------------------------------------------------------*/
/* Allocation & initialisation of tensors */
UP = new double[1];
UP[0] = (double)rand();
VP = new double[indepDim];
/*----------------------------------------------------------------------*/
/* Evaluation without repeat */
t00 = myclock();
for (i=0; i<evalCount; i++)
retVal = vec_jac(tag,1,indepDim,0,indeps,UP,VP);
t01 = myclock();
fprintf(stdout,"(no repeat)");
fprintf(stdout,TIMEFORMAT,(t01-t00)*timeUnit,
(t01-t00)/evalCount);
/*----------------------------------------------------------------------*/
/* Evaluation with repeat */
t00 = myclock();
for (i=0; i<evalCount; i++)
retVal = vec_jac(tag,1,indepDim,1,indeps,UP,VP);
t01 = myclock();
fprintf(stdout," (repeat)");
fprintf(stdout,TIMEFORMAT,(t01-t00)*timeUnit,
(t01-t00)/evalCount);
/*----------------------------------------------------------------------*/
/* Debug infos */
if (controlParameters[cpVecJac] > 1) {
fprintf(stdout,"\n Return value: %d\n",retVal);
}
/*----------------------------------------------------------------------*/
/* Free tensors */
delete[] UP;
delete[] VP;
}
/****************************************************************************/
/* 14. JACVEC */
if (controlParameters[cpJacVec]) {
fprintf(stdout,"--------------------------------------------------------");
fprintf(stdout,"\nTASK %d: jac_vec(tag, m=1, n=%d, X[n], V[n], U[m])\n",
taskCount++,indepDim);
/*----------------------------------------------------------------------*/
/* Allocation & initialisation of tensors */
UP = new double[1];
VP = new double[indepDim];
for (i=0; i<indepDim; i++)
VP[i] = (double)rand();
/*----------------------------------------------------------------------*/
/* Evaluation */
t00 = myclock();
for (i=0; i<evalCount; i++)
retVal = jac_vec(tag,1,indepDim,indeps,VP,UP);
t01 = myclock();
fprintf(stdout," ");
fprintf(stdout,TIMEFORMAT,(t01-t00)*timeUnit,
(t01-t00)/evalCount);
/*----------------------------------------------------------------------*/
/* Debug infos */
if (controlParameters[cpJacVec] > 1) {
fprintf(stdout,"\n Return value: %d\n",retVal);
}
/*----------------------------------------------------------------------*/
/* Free tensors */
delete[] UP;
delete[] VP;
}
/****************************************************************************/
/* 15. HESSIAN */
if (controlParameters[cpHessian]) {
fprintf(stdout,"--------------------------------------------------------");
fprintf(stdout,"\nTASK %d: hessian(tag, n=%d, X[n], lower triangle of H[n][n])\n",
taskCount++,indepDim);
/*----------------------------------------------------------------------*/
/* Allocation & initialisation of tensors */
HPP = new double*[indepDim];
for (i=0; i<indepDim; i++)
HPP[i] = new double[indepDim];
/*----------------------------------------------------------------------*/
/* Evaluation */
t00 = myclock();
for (i=0; i<evalCount; i++)
retVal = hessian(tag,indepDim,indeps,HPP);
t01 = myclock();
fprintf(stdout," ");
fprintf(stdout,TIMEFORMAT,(t01-t00)*timeUnit,
(t01-t00)/evalCount);
/*----------------------------------------------------------------------*/
/* Debug infos */
if (controlParameters[cpHessian] > 1) {
fprintf(stdout,"\n Return value: %d\n",retVal);
}
/*----------------------------------------------------------------------*/
/* Free tensors */
for (i=0; i<indepDim; i++)
delete[] HPP[i];
delete[] HPP;
}
/****************************************************************************/
/* 16. HESSVEC */
if (controlParameters[cpHessVec]) {
fprintf(stdout,"--------------------------------------------------------");
fprintf(stdout,"\nTASK %d: hess_vec(tag, n=%d, X[n], V[n], W[n])\n",
taskCount++,indepDim);
/*----------------------------------------------------------------------*/
/* Allocation & initialisation of tensors */
VP = new double[indepDim];
for (i=0; i<indepDim; i++)
VP[i] = (double)rand();
WP = new double[indepDim];
/*----------------------------------------------------------------------*/
/* Evaluation */
t00 = myclock();
for (i=0; i<evalCount; i++)
retVal = hess_vec(tag,indepDim,indeps,VP,WP);
t01 = myclock();
fprintf(stdout," ");
fprintf(stdout,TIMEFORMAT,(t01-t00)*timeUnit,
(t01-t00)/evalCount);
/*----------------------------------------------------------------------*/
/* Debug infos */
if (controlParameters[cpHessVec] > 1) {
fprintf(stdout,"\n Return value: %d\n",retVal);
}
/*----------------------------------------------------------------------*/
/* Free tensors */
delete[] VP;
delete[] WP;
}
/****************************************************************************/
/* 17. LAGHESSVEC */
if (controlParameters[cpLagHessVec]) {
fprintf(stdout,"--------------------------------------------------------");
fprintf(stdout,"\nTASK %d: lagra_hess_vec(tag, m=1, n=%d, X[n], U[m], V[n], W[n])\n",
taskCount++,indepDim);
/*----------------------------------------------------------------------*/
/* Allocation & initialisation of tensors */
UP = new double[1];
UP[0] = (double)rand();
VP = new double[indepDim];
for (i=0; i<indepDim; i++)
VP[i] = (double)rand();
WP = new double[indepDim];
/*----------------------------------------------------------------------*/
/* Evaluation */
t00 = myclock();
for (i=0; i<evalCount; i++)
retVal = lagra_hess_vec(tag,1,indepDim,indeps,UP,VP,WP);
t01 = myclock();
fprintf(stdout," ");
fprintf(stdout,TIMEFORMAT,(t01-t00)*timeUnit,
(t01-t00)/evalCount);
/*----------------------------------------------------------------------*/
/* Debug infos */
if (controlParameters[cpLagHessVec] > 1) {
fprintf(stdout,"\n Return value: %d\n",retVal);
}
/*----------------------------------------------------------------------*/
/* Free tensors */
delete[] VP;
delete[] WP;
delete[] UP;
}
/****************************************************************************/
/* 18. TENSOR */
if (controlParameters[cpTensor]) {
fprintf(stdout,"--------------------------------------------------------");
fprintf(stdout,"\nTASK %d: tensor_eval(tag, m =1, n=%d, d=%d, p=%d, X[n], tensor[m][dim], S[n][p])\n",
taskCount++,indepDim,degree, pTR);
fprintf(stdout,"\n dim = ((p+d) over d)\n");
/*----------------------------------------------------------------------*/
/* Allocation & initialisation of tensors */
dim = binomi(pTR+degree,degree);
TPP = new double*[1];
TPP[0] = new double[dim];
SPP = new double*[indepDim];
for (i=0; i<indepDim; i++) {
SPP[i] = new double[pTR];
for (j=0; j<pTR; j++)
SPP[i][j]=(i==j)?1.0:0.0;
}
/*----------------------------------------------------------------------*/
/* tensor evaluation */
t00 = myclock();
for (i=0; i<evalCount; i++)
tensor_eval(tag,1,indepDim,degree,pTR,indeps,TPP,SPP);
t01 = myclock();
fprintf(stdout," ");
fprintf(stdout,TIMEFORMAT,(t01-t00)*timeUnit,
(t01-t00)/evalCount);
/*----------------------------------------------------------------------*/
/* Debug infos */
if (controlParameters[cpTensor] > 1) {}
/*----------------------------------------------------------------------*/
/* Free tensors */
delete[] TPP[0];
delete[] TPP;
for (i=0; i<indepDim; i++)
delete[] SPP[i];
delete[] SPP;
}
/****************************************************************************/
/* 19. INVERSE TENSOR */
if (controlParameters[cpInvTensor] && (1==indepDim)) {
fprintf(stdout,"--------------------------------------------------------");
fprintf(stdout,"\nTASK %d: inverse_tensor_eval(tag, m=n=1, d=%d, p=%d, X[n], tensor[m][dim], S[n][p])\n",
taskCount++,degree, pTR);
fprintf(stdout,"\n dim = ((p+d) over d)\n");
/*----------------------------------------------------------------------*/
/* Allocation & initialisation of tensors */
dim = binomi(pTR+degree,degree);
TPP = new double*[1];
TPP[0] = new double[dim];
SPP = new double*[1];
SPP[0] = new double[pTR];
for (j=0; j<pTR; j++)
SPP[0][j]=(0==j)?1.0:0.0;
/*----------------------------------------------------------------------*/
/* tensor evaluation */
t00 = myclock();
for (i=0; i<evalCount; i++)
inverse_tensor_eval(tag,1,degree,pTR,indeps,TPP,SPP);
t01 = myclock();
fprintf(stdout," ");
fprintf(stdout,TIMEFORMAT,(t01-t00)*timeUnit,
(t01-t00)/evalCount);
/*----------------------------------------------------------------------*/
/* Debug infos */
if (controlParameters[cpInvTensor] > 1) {}
/*----------------------------------------------------------------------*/
/* Free tensors */
delete[] TPP[0];
delete[] TPP;
delete[] SPP[0];
delete[] SPP;
}
return 1;
}
int tensor_eval( int tag, int m, int n, int d, int p,
double* x, double **tensor, double **S ) {
static int bd,dim;
static int dold,pold;
static struct item *coeff_list;
int i,j,k,dimten,ctr;
int **jm, jmbd=0;
int *it = (int*) malloc(d*sizeof(int));
double *y = (double*) malloc(m*sizeof(double));
double*** X;
double*** Y;
struct item *ptr[10];
int rc = 3;
dimten=binomi(p+d,d);
for (i=0; i<m; i++)
for (j=0; j<dimten; j++)
tensor[i][j] = 0;
if (d == 0) {
MINDEC(rc,zos_forward(1,m,n,0,x,y));
} else {
if ((d != dold) || (p != pold)) {
if (pold) {
dim = binomi(pold+dold-1,dold);
freecoefflist(dim,coeff_list);
free((char*) coeff_list);
}
dim = binomi(p+d-1,d);
if (dim < 10)
bd = dim;
else
bd = 10;
coeff_list = (struct item *) malloc(sizeof(struct item)*dim);
coeff(p,d, coeff_list);
dold = d;
pold = p;
}
jmbd = bd;
jm = (int **) malloc(jmbd*sizeof(int*));
for (i=0; i<jmbd; i++)
jm[i] = (int *) malloc(p*sizeof(int));
if (d == 1) {
X = myalloc3(1,n,bd);
Y = myalloc3(1,m,bd);
ctr = 0;
it[0] = 0;
for (i=0; i<dim; i++) /* sum over all multiindices jm with |jm| = d */
{ it[0] = it[0]+1;
convert(p,d,it,jm[ctr]);
ptr[ctr] = &coeff_list[i];
if (ctr < bd-1)
ctr += 1;
else {
multma2vec2(n,p,bd,X[0],S,jm);
MINDEC(rc,fov_forward(tag,m,n,bd,x,X[0],y,Y[0]));
for (k=0; k<bd; k++)
do {
for (j=0; j<m; j++)
tensor[j][ptr[k]->a] += Y[0][j][k]*ptr[k]->c;
ptr[k] = ptr[k]->next;
} while (ptr[k] != NULL);
if (dim-i < bd)
bd = dim-i-1;
ctr = 0;
}
}
} else {
X = myalloc3(n,bd,d);
Y = myalloc3(m,bd,d);
ctr = 0;
for (i=0; i<d-1; i++)
it[i] = 1;
it[d-1] = 0;
for (i=0; i<dim; i++) /* sum over all multiindices jm with |jm| = d */
{ it[d-1] = it[d-1]+1;
for (j=d-2; j>=0; j--)
it[j] = it[j] + it[j+1]/(p+1);
for (j=1; j<d; j++)
if (it[j] > p)
it[j] = it[j-1];
convert(p,d,it,jm[ctr]);
ptr[ctr] = &coeff_list[i];
if (ctr < bd-1)
ctr += 1;
else {
multma3vec2(n,p,d,bd,X,S,jm);
MINDEC(rc,hov_forward(tag,m,n,d,bd,x,X,y,Y));
for (k=0; k<bd; k++)
do {
for (j=0; j<m; j++)
tensor[j][ptr[k]->a] += Y[j][k][ptr[k]->b-1]*ptr[k]->c;
ptr[k] = ptr[k]->next;
} while (ptr[k] != NULL);
if (dim-i < bd)
bd = dim-i-1;
ctr = 0;
}
}
}
for (i=0; i<jmbd; i++)
free((char*) *(jm+i));
free((char*) jm);
free((char*) **X);
free((char*) *X);
free((char*) X);
free((char*) **Y);
free((char*) *Y);
free((char*) Y);
}
for(i=0;i<m;i++)
tensor[i][0] = y[i];
bd = jmbd;
free((char*) y);
free((char*) it);
return rc;
}
int inverse_tensor_eval( int tag, int n, int d, int p,
double *x, double **tensor, double** S ) {
static int dim;
static int dold,pold;
static struct item *coeff_list;
int i,j,dimten;
int *it = (int*) malloc(d*sizeof(int));
double** X;
double** Y;
int *jm;
double *y = (double*) malloc(n*sizeof(double));
struct item *ptr;
int rc = 3;
dimten=binomi(p+d,d);
for(i=0;i<n;i++)
for(j=0;j<dimten;j++)
tensor[i][j] = 0;
MINDEC(rc,zos_forward(1,n,n,0,x,y));
if (d > 0) {
if ((d != dold) || (p != pold)) {
if (pold) { /* olvo 980728 */
dim = binomi(pold+dold-1,dold);
freecoefflist(dim,coeff_list);
free((char*) coeff_list);
}
dim = binomi(p+d-1,d);
coeff_list = (struct item *) malloc(sizeof(struct item)*dim);
coeff(p,d, coeff_list);
dold = d;
pold = p;
}
jm = (int *)malloc(sizeof(int)*p);
X = myalloc2(n,d+1);
Y = myalloc2(n,d+1);
for (i=0; i<n; i++) {
X[i][0] = x[i];
for (j=1; j<d; j++)
X[i][j] = 0;
Y[i][0] = y[i];
}
if (d == 1) {
it[0] = 0;
for (i=0; i<dim; i++) /* sum over all multiindices jm with |jm| = d */
{ it[0] = it[0]+1;
convert(p,d,it,jm);
ptr = &coeff_list[i];
multma2vec1(n,p,d,Y,S,jm);
MINDEC(rc,inverse_Taylor_prop(tag,n,d,Y,X));
if (rc == -3)
return -3;
do {
for(j=0;j<n;j++)
tensor[j][ptr->a] += X[j][ptr->b]*ptr->c;
ptr = ptr->next;
} while (ptr != NULL);
}
} else {
for (i=0; i<d-1; i++)
it[i] = 1;
it[d-1] = 0;
for (i=0; i<dim; i++) /* sum over all multiindices jm with |jm| = d */
{ it[d-1] = it[d-1]+1;
for (j=d-2; j>=0; j--)
it[j] = it[j] + it[j+1]/(p+1);
for (j=1; j<d; j++)
if (it[j] > p) it[j] = it[j-1];
convert(p,d,it,jm);
multma2vec1(n,p,d,Y,S,jm); /* Store S*jm in Y */
MINDEC(rc,inverse_Taylor_prop(tag,n,d,Y,X));
if (rc == -3)
return -3;
ptr = &coeff_list[i];
do {
for(j=0;j<n;j++)
tensor[j][ptr->a] += X[j][ptr->b]*ptr->c;
ptr = ptr->next;
} while (ptr != NULL);
}
}
free((char*) jm);
free((char*) *X);
free((char*) X);
free((char*) *Y);
free((char*) Y);
}
for(i=0;i<n;i++)
tensor[i][0] = x[i];
free((char*) y);
free((char*) it);
return rc;
}
void coeff(int p, int d, struct item* coeff_list) {
int i, j, u, n, index_coeff_list, order_im, order_km, address;
int* jm = (int*) malloc(p*sizeof(int)); /* Multiindex j */
int* im = (int*) malloc(p*sizeof(int)); /* Multiindex i */
int* km = (int*) malloc(p*sizeof(int)); /* Multiindex k */
struct item* ptr;
double sum;
long binomiZ; /* whole number binomial coefficient */
jm[0] = d;
for (i=1; i<p; i++) jm[i] = im[i] = 0;
for (i=0; i<p; i++) km[i] = 0;
order_km = 0;
for (index_coeff_list = 0; 1; index_coeff_list++) { /* travers coeff_list, i.e. create all j with |j| = d. */
ptr = NULL;
for (order_im=1; order_im<=d; order_im++) { /* travers all orders from 1 to d for i */
im[p-1]=0;
im[0] = order_im;
while (1) { /* create all i with order order_im. */
sum = 0;
binomiZ = 1;
for (i=0; i<p; i++) /* check, whether i valid. */
if ((jm[i]>0)&&(im[i]==0)) break;
if (i==p)
while (1) { /* create all k where 0<k<=i */
for (i=p-1; i>=0; i--)
if (km[i]<im[i]) {
km[i]++;
order_km++;
binomiZ *= im[i]-km[i]+1; /* for (i over k)/(i over k-1) = (i-k+1)/k */
binomiZ /= km[i];
break;
} else {
/* binomiZ doesn't change, for (i over k) = 1 if k=0 and also if k=i */
order_km -= km[i];
km[i] = 0;
};
if (i==-1) break;
sum += summand(p,d,jm,km,order_im,order_km,binomiZ);
};
if (sum!=0) { /* Store coefficient */
if (ptr==NULL)
ptr = &coeff_list[index_coeff_list];
else {
ptr->next = (struct item*) malloc(sizeof(struct item));
ptr = ptr->next;
};
address = 0; /* calculate address for ptr->a */
j = d-order_im+1;
for (u=0; u<p; u++) /* It is sum(binomial(i+k,j+k),k=0..n-1) = */
if (im[u]!=0) /* = ((j+n)*binomial(i+n,j+n)-j*binomial(i,j))/(1+i-j) */
{
i = u+j;
n = im[u];
address += ((j+n)*binomi(i+n,j+n)-j*binomi(i,j))/(1+i-j);
j += n;
};
ptr->a = address;
ptr->b = order_im;
ptr->c = sum;
};
if ((im[p-1]==order_im)||(p==1)) break;
for (i=p-2; im[i]==0; i--); /* find first nonvanishing entry on the right. */
im[i]--;
im[i+1] = im[p-1]+1;
if (i!=p-2) im[p-1] = 0;
};
};
ptr->next = NULL; /* mark end of queue. */
if ((jm[p-1]==d)||(p==1)) break;
for (i=p-2; jm[i]==0; i--); /* find first nonvanishing entry on the right. */
jm[i]--;
jm[i+1] = jm[p-1]+1;
if (i!=p-2) jm[p-1] = 0;
};
free((char*) jm);
free((char*) im);
free((char*) km);
};
double evaluate_derivatives(int n, int m, double* x, int* options) {
int order = options[0];
int nnz;
double t1 = k_getTime();
if (options[1] == 0) { // Teed = new double*[n];
assert(m == 1);
double** seed = new double*[n];
for (int i = 0; i < n; i++) {
seed[i] = new double[n];
for (int j = 0; j < n; j++) {
seed[i][j] = ((i==j)?1.0:0.0);
}
}
int dim = binomi(n+order, order);
double** tensorhelp = myalloc2(1, dim);
tensor_eval(TAG, 1, n, order, n, x, tensorhelp, seed);
for (int i = 0; i < n; i++) {
delete[] seed[i];
}
delete[] seed;
myfree2(tensorhelp);
} else {
if (order == 2) { // Hessian
assert(m == 1);
if (options[1] == 1 || options[1] == 2) { // Direct or Indirect
int opt[2] = {0, 0}; // default is indirect;
if (options[1] == 1) {opt[0] = 1;} // set direct;
unsigned int * rind = NULL;
unsigned int * cind = NULL;
double * values = NULL;
sparse_hess(TAG, n, 0, x, &nnz, &rind, &cind, &values, opt);
#ifdef PRINT_RESULT
for (int i = 0; i < nnz; i++) {
printf("H[%d, %d] = %.6f\n", rind[i], cind[i], values[i]);
}
#endif
free(rind);
free(cind);
free(values);
} else if (options[1] == 3) { // FullHess
double** H = new double*[n];
for (int i = 0; i < n; i++) {
H[i] = new double[n];
}
hessian(TAG, n, x, H);
nnz = n*n;
#ifdef PRINT_RESULT
for (int i = 0; i < n; i++) {
for (int j = 0; j <= i; j++) {
printf("H[%d, %d] = %.6f\n", i, j, H[i][j]);
}
}
#endif
for (int i = 0; i < n; i++) {
delete[] H[i];
}
delete[] H;
} else if (options[1] == 4) { // Single Hv
double v[n];
double Hv[n];
for (int i = 0; i < n; i++) {
v[i] = 1.0;
Hv[i] = 0.0;
}
hess_vec(TAG, n, x, v, Hv);
nnz = n;
} else if (options[1] == 5) { // dense second order reverse
double** H = new double*[n];
for (int i = 0; i < n; i++) {
H[i] = new double[n];
}
hessian_dense(TAG, n, x, H);
nnz = n*n;
#ifdef PRINT_RESULT
for (int i = 0; i < n; i++) {
for (int j = 0; j <= i; j++) {
printf("H[%d, %d] = %.6f\n", i, j, H[i][j]);
}
}
#endif
for (int i = 0; i < n; i++) {
delete[] H[i];
}
delete[] H;
} else if (options[1] == 6){ // sparse second order reverse
unsigned int * rind = NULL;
unsigned int * cind = NULL;
double * values = NULL;
hessian_sparse(TAG, n, x, &nnz, &rind, &cind, &values);
#ifdef PRINT_RESULT
for (int i = 0; i < nnz; i++) {
printf("H[%d, %d] = %.6f\n", rind[i], cind[i], values[i]);
}
#endif
free(rind);
free(cind);
free(values);
} else if (options[1] == 7) { // Hess-matrix options
double** H = myalloc2(n, n);
double y;
double*** Xppp = myalloc3(n, n, 1);
double*** Yppp = myalloc3(1, n, 1);
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
Xppp[i][j][0] = 0;
}
Xppp[i][i][0] = 1.0;
}
double** Upp = myalloc2(1,2);
Upp[0][0] = 1; Upp[0][1] = 0;
double*** Zppp = myalloc3(n, n, 2);
int ret_val = hov_wk_forward(TAG,1,n,1,2,n,x,Xppp,&y,Yppp);
ret_val = hos_ov_reverse(TAG,1,n,1,n,Upp,Zppp);
for (int i = 0; i < n; ++i) {
for (int l = 0; l < n; ++l) {
H[l][i] = Zppp[i][l][1];
}
}
#ifdef PRINT_RESULT
for (int i = 0; i < n; i++) {
for (int j = 0; j <= i; j++) {
printf("H[%d, %d] = %.6f\n", i, j, H[i][j]);
}
}
#endif
myfree2(H);
myfree3(Xppp);
myfree3(Yppp);
myfree2(Upp);
myfree3(Zppp);
}
} else if (order == 1) { // Gradient or Jacobian
if (m == 1) { // gradient
double g[n];
gradient(TAG, n, x, g);
#ifdef PRINT_RESULT
for (int i = 0; i < n; i++) {
printf("g[%d] = %.6f\n", i, g[i]);
}
#endif
} else { // jacobian
double** J = new double*[m];
for (int i = 0; i < m; i++) {
J[i] = new double[n];
}
jacobian(TAG, m, n, x, J);
#ifdef PRINT_RESULT
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
printf("J[%d][%d] = %.6f\n", i, j, J[i][j]);
}
}
#endif
for (int i = 0; i < m; i++) {
delete[] J[i];
}
delete[] J;
}
nnz = n*m;
}
}
double time_elapsed = k_getTime() - t1;
size_t size;
size_t** tind;
double* values;
printf("ADOLC nnz[%d] method[%d] order[%d] timing = %.6f\n", nnz, options[1], options[0], time_elapsed);
return time_elapsed;
}