double chiSquare(python::object resArr) { PyObject *matObj = resArr.ptr(); if (!PyArray_Check(matObj)) { throw_value_error("Expecting a Numeric array object"); } PyArrayObject *copy; copy = (PyArrayObject *)PyArray_ContiguousFromObject( matObj, ((PyArrayObject *)matObj)->descr->type_num, 2, 2); long int rows = (long int)((PyArrayObject *)matObj)->dimensions[0]; long int cols = (long int)((PyArrayObject *)matObj)->dimensions[1]; double res = 0.0; if (((PyArrayObject *)matObj)->descr->type_num == PyArray_DOUBLE) { double *data = (double *)copy->data; res = ChiSquare(data, rows, cols); } else if (((PyArrayObject *)matObj)->descr->type_num == PyArray_FLOAT) { float *data = (float *)copy->data; res = ChiSquare(data, rows, cols); } else if (((PyArrayObject *)matObj)->descr->type_num == PyArray_INT) { int *data = (int *)copy->data; res = ChiSquare(data, rows, cols); } else if (((PyArrayObject *)matObj)->descr->type_num == PyArray_LONG) { long int *data = (long int *)copy->data; res = ChiSquare(data, rows, cols); } else { throw_value_error( "Numeric array object of type int or long or float or double"); } Py_DECREF(copy); return res; }
float32_t PulseClusterer::computePfa(int32_t n, float32_t power) { float64_t pfa, logPfa, pPulse; // pulse probability is doubled because there are two polarizations pPulse = 2 * pow(M_E, -pulseThreshold); pfa = (bins * pow(4.0, n - 2) * pow(spectra, 3) * pow(pPulse, n)) / 3.0; if (pfa < DBL_MIN) logPfa = -FLT_MAX; else logPfa = log(pfa); // cout << "bins = " << bins << ", sp = " << spectra << ", pulse prob = " << pPulse << endl; // cout << "n = " << n << ", power = " << power; // cout << ", thresh " << pulseThreshold; // cout << ", base pfa = " << logPfa; if ((power -= n * pulseThreshold) < 0) power = 0; logPfa += ChiSquare(2 * n, 2 * power); if (logPfa < -FLT_MAX) logPfa = -FLT_MAX; // cout << ", log pfa = " << logPfa << endl; return (logPfa); }
double InfoBitRanker::BiasChiSquareGain(RDKit::USHORT *resMat) const { PRECONDITION(resMat,"bad result pointer"); bool bitOk = this->BiasCheckBit(resMat); double info=0.0; if (bitOk) { info = ChiSquare(resMat, 2, d_classes); } return info; }
static int Integrate(This *t, real *integral, real *error, real *prob) { TYPEDEFREGION; typedef struct pool { struct pool *next; Region region[POOLSIZE]; } Pool; count dim, comp, ncur, ipool, npool; int fail; Totals totals[NCOMP]; Pool *cur = NULL, *pool; Region *region; if( VERBOSE > 1 ) { char s[256]; sprintf(s, "Cuhre input parameters:\n" " ndim " COUNT "\n ncomp " COUNT "\n" " epsrel " REAL "\n epsabs " REAL "\n" " flags %d\n mineval " NUMBER "\n maxeval " NUMBER "\n" " key " COUNT, t->ndim, t->ncomp, t->epsrel, t->epsabs, t->flags, t->mineval, t->maxeval, t->key); Print(s); } if( BadComponent(t) ) return -2; if( BadDimension(t) ) return -1; t->epsabs = Max(t->epsabs, NOTZERO); RuleAlloc(t); t->mineval = IMax(t->mineval, t->rule.n + 1); FrameAlloc(t, ShmRm(t)); ForkCores(t); if( (fail = setjmp(t->abort)) ) goto abort; Alloc(cur, 1); cur->next = NULL; ncur = 1; region = cur->region; region->div = 0; for( dim = 0; dim < t->ndim; ++dim ) { Bounds *b = ®ion->bounds[dim]; b->lower = 0; b->upper = 1; } Sample(t, region); for( comp = 0; comp < t->ncomp; ++comp ) { Totals *tot = &totals[comp]; Result *r = ®ion->result[comp]; tot->avg = tot->lastavg = tot->guess = r->avg; tot->err = tot->lasterr = r->err; tot->weightsum = 1/Max(Sq(r->err), NOTZERO); tot->avgsum = tot->weightsum*r->avg; tot->chisq = tot->chisqsum = tot->chisum = 0; } for( t->nregions = 1; ; ++t->nregions ) { count maxcomp, bisectdim; real maxratio, maxerr; Result result[NCOMP]; Region *regionL, *regionR; Bounds *bL, *bR; if( VERBOSE ) { char s[128 + 128*NCOMP], *p = s; p += sprintf(p, "\n" "Iteration " COUNT ": " NUMBER " integrand evaluations so far", t->nregions, t->neval); for( comp = 0; comp < t->ncomp; ++comp ) { cTotals *tot = &totals[comp]; p += sprintf(p, "\n[" COUNT "] " REAL " +- " REAL " \tchisq " REAL " (" COUNT " df)", comp + 1, tot->avg, tot->err, tot->chisq, t->nregions - 1); } Print(s); } maxratio = -INFTY; maxcomp = 0; for( comp = 0; comp < t->ncomp; ++comp ) { creal ratio = totals[comp].err/MaxErr(totals[comp].avg); if( ratio > maxratio ) { maxratio = ratio; maxcomp = comp; } } if( maxratio <= 1 && t->neval >= t->mineval ) break; if( t->neval >= t->maxeval ) { fail = 1; break; } maxerr = -INFTY; regionL = cur->region; npool = ncur; for( pool = cur; pool; npool = POOLSIZE, pool = pool->next ) for( ipool = 0; ipool < npool; ++ipool ) { Region *region = &pool->region[ipool]; creal err = region->result[maxcomp].err; if( err > maxerr ) { maxerr = err; regionL = region; } } if( ncur == POOLSIZE ) { Pool *prev = cur; Alloc(cur, 1); cur->next = prev; ncur = 0; } regionR = &cur->region[ncur++]; regionR->div = ++regionL->div; FCopy(result, regionL->result); XCopy(regionR->bounds, regionL->bounds); bisectdim = result[maxcomp].bisectdim; bL = ®ionL->bounds[bisectdim]; bR = ®ionR->bounds[bisectdim]; bL->upper = bR->lower = .5*(bL->upper + bL->lower); Sample(t, regionL); Sample(t, regionR); for( comp = 0; comp < t->ncomp; ++comp ) { cResult *r = &result[comp]; Result *rL = ®ionL->result[comp]; Result *rR = ®ionR->result[comp]; Totals *tot = &totals[comp]; real diff, err, w, avg, sigsq; tot->lastavg += diff = rL->avg + rR->avg - r->avg; diff = fabs(.25*diff); err = rL->err + rR->err; if( err > 0 ) { creal c = 1 + 2*diff/err; rL->err *= c; rR->err *= c; } rL->err += diff; rR->err += diff; tot->lasterr += rL->err + rR->err - r->err; tot->weightsum += w = 1/Max(Sq(tot->lasterr), NOTZERO); sigsq = 1/tot->weightsum; tot->avgsum += w*tot->lastavg; avg = sigsq*tot->avgsum; tot->chisum += w *= tot->lastavg - tot->guess; tot->chisqsum += w*tot->lastavg; tot->chisq = tot->chisqsum - avg*tot->chisum; if( LAST ) { tot->avg = tot->lastavg; tot->err = tot->lasterr; } else { tot->avg = avg; tot->err = sqrt(sigsq); } } } for( comp = 0; comp < t->ncomp; ++comp ) { cTotals *tot = &totals[comp]; integral[comp] = tot->avg; error[comp] = tot->err; prob[comp] = ChiSquare(tot->chisq, t->nregions - 1); } #ifdef MLVERSION if( REGIONS ) { MLPutFunction(stdlink, "List", 2); MLPutFunction(stdlink, "List", t->nregions); npool = ncur; for( pool = cur; pool; npool = POOLSIZE, pool = pool->next ) for( ipool = 0; ipool < npool; ++ipool ) { Region const *region = &pool->region[ipool]; real lower[NDIM], upper[NDIM]; for( dim = 0; dim < t->ndim; ++dim ) { cBounds *b = ®ion->bounds[dim]; lower[dim] = b->lower; upper[dim] = b->upper; } MLPutFunction(stdlink, "Cuba`Cuhre`region", 3); MLPutRealList(stdlink, lower, t->ndim); MLPutRealList(stdlink, upper, t->ndim); MLPutFunction(stdlink, "List", t->ncomp); for( comp = 0; comp < t->ncomp; ++comp ) { cResult *r = ®ion->result[comp]; real res[] = {r->avg, r->err}; MLPutRealList(stdlink, res, Elements(res)); } } } #endif abort: while( (pool = cur) ) { cur = cur->next; free(pool); } WaitCores(t); FrameFree(t); RuleFree(t); return fail; }
// interfaccia della funzione precedente per Minuit void minuitChiSquare( int& nDim, double* gout, double& result, double* par, int flg) { result = ChiSquare (par[0], par[1], par[2], par[3]); }
static int Integrate(This *t, real *integral, real *error, real *prob) { bin_t *bins; count dim, comp; int fail; struct { count niter; number nsamples, neval; Cumulants cumul[NCOMP]; Grid grid[NDIM]; } state; int statemsg = VERBOSE; struct stat st; if( VERBOSE > 1 ) { char s[512]; sprintf(s, "Vegas input parameters:\n" " ndim " COUNT "\n ncomp " COUNT "\n" " epsrel " REAL "\n epsabs " REAL "\n" " flags %d\n seed %d\n" " mineval " NUMBER "\n maxeval " NUMBER "\n" " nstart " NUMBER "\n nincrease " NUMBER "\n" " nbatch " NUMBER "\n gridno %d\n" " statefile \"%s\"", t->ndim, t->ncomp, t->epsrel, t->epsabs, t->flags, t->seed, t->mineval, t->maxeval, t->nstart, t->nincrease, t->nbatch, t->gridno, t->statefile); Print(s); } if( BadComponent(t) ) return -2; if( BadDimension(t) ) return -1; FrameAlloc(t, ShmRm(t)); ForkCores(t); Alloc(bins, t->nbatch*t->ndim); if( (fail = setjmp(t->abort)) ) goto abort; IniRandom(t); if( t->statefile && *t->statefile == 0 ) t->statefile = NULL; if( t->statefile && stat(t->statefile, &st) == 0 && st.st_size == sizeof state && (st.st_mode & 0400) ) { cint h = open(t->statefile, O_RDONLY); read(h, &state, sizeof state); close(h); t->rng.skiprandom(t, t->neval = state.neval); if( VERBOSE ) { char s[256]; sprintf(s, "\nRestoring state from %s.", t->statefile); Print(s); } } else { state.niter = 0; state.nsamples = t->nstart; Zap(state.cumul); GetGrid(t, state.grid); } /* main iteration loop */ for( ; ; ) { number nsamples = state.nsamples; creal jacobian = 1./nsamples; Grid margsum[NCOMP][NDIM]; Zap(margsum); for( ; nsamples > 0; nsamples -= t->nbatch ) { cnumber n = IMin(t->nbatch, nsamples); real *w = t->frame; real *x = w + n; real *f = x + n*t->ndim; real *lastf = f + n*t->ncomp; bin_t *bin = bins; while( x < f ) { real weight = jacobian; t->rng.getrandom(t, x); for( dim = 0; dim < t->ndim; ++dim ) { creal pos = *x*NBINS; ccount ipos = (count)pos; creal prev = (ipos == 0) ? 0 : state.grid[dim][ipos - 1]; creal diff = state.grid[dim][ipos] - prev; *x++ = prev + (pos - ipos)*diff; *bin++ = ipos; weight *= diff*NBINS; } *w++ = weight; } DoSample(t, n, w, f, t->frame, state.niter + 1); bin = bins; w = t->frame; while( f < lastf ) { creal weight = *w++; for( comp = 0; comp < t->ncomp; ++comp ) { real wfun = weight*(*f++); if( wfun ) { Cumulants *c = &state.cumul[comp]; Grid *m = margsum[comp]; c->sum += wfun; c->sqsum += wfun *= wfun; for( dim = 0; dim < t->ndim; ++dim ) m[dim][bin[dim]] += wfun; } } bin += t->ndim; } } fail = 0; /* compute the integral and error values */ for( comp = 0; comp < t->ncomp; ++comp ) { Cumulants *c = &state.cumul[comp]; real avg, sigsq; real w = Weight(c->sum, c->sqsum, state.nsamples); sigsq = 1/(c->weightsum += w); avg = sigsq*(c->avgsum += w*c->sum); c->avg = LAST ? (sigsq = 1/w, c->sum) : avg; c->err = sqrt(sigsq); fail |= (c->err > MaxErr(c->avg)); if( state.niter == 0 ) c->guess = c->sum; else { c->chisum += w *= c->sum - c->guess; c->chisqsum += w*c->sum; } c->chisq = c->chisqsum - avg*c->chisum; c->sum = c->sqsum = 0; } if( VERBOSE ) { char s[128 + 128*NCOMP], *p = s; p += sprintf(p, "\n" "Iteration " COUNT ": " NUMBER " integrand evaluations so far", state.niter + 1, t->neval); for( comp = 0; comp < t->ncomp; ++comp ) { cCumulants *c = &state.cumul[comp]; p += sprintf(p, "\n[" COUNT "] " REAL " +- " REAL " \tchisq " REAL " (" COUNT " df)", comp + 1, c->avg, c->err, c->chisq, state.niter); } Print(s); } if( fail == 0 && t->neval >= t->mineval ) { if( t->statefile && KEEPFILE == 0 ) unlink(t->statefile); break; } if( t->neval >= t->maxeval && t->statefile == NULL ) break; if( t->ncomp == 1 ) for( dim = 0; dim < t->ndim; ++dim ) RefineGrid(t, state.grid[dim], margsum[0][dim]); else { for( dim = 0; dim < t->ndim; ++dim ) { Grid wmargsum; Zap(wmargsum); for( comp = 0; comp < t->ncomp; ++comp ) { real w = state.cumul[comp].avg; if( w != 0 ) { creal *m = margsum[comp][dim]; count bin; w = 1/Sq(w); for( bin = 0; bin < NBINS; ++bin ) wmargsum[bin] += w*m[bin]; } } RefineGrid(t, state.grid[dim], wmargsum); } } ++state.niter; state.nsamples += t->nincrease; if( t->statefile ) { cint h = creat(t->statefile, 0666); if( h != -1 ) { state.neval = t->neval; write(h, &state, sizeof state); close(h); if( statemsg ) { char s[256]; sprintf(s, "\nSaving state to %s.", t->statefile); Print(s); statemsg = false; } } if( t->neval >= t->maxeval ) break; } } for( comp = 0; comp < t->ncomp; ++comp ) { cCumulants *c = &state.cumul[comp]; integral[comp] = c->avg; error[comp] = c->err; prob[comp] = ChiSquare(c->chisq, state.niter); } abort: PutGrid(t, state.grid); free(bins); WaitCores(t); FrameFree(t); return fail; }
static int Integrate(This *t, real *integral, real *error, real *prob) { TYPEDEFREGION; Totals totals[NCOMP]; real nneed, weight; count dim, comp, iter, pass = 0, err, iregion; number nwant, nmin = INT_MAX; int fail; if( VERBOSE > 1 ) { char s[512]; sprintf(s, "Divonne input parameters:\n" " ndim " COUNT "\n ncomp " COUNT "\n" " epsrel " REAL "\n epsabs " REAL "\n" " flags %d\n seed %d\n" " mineval " NUMBER "\n maxeval " NUMBER "\n" " key1 %d\n key2 %d\n key3 %d\n maxpass " COUNT "\n" " border " REAL "\n maxchisq " REAL "\n mindeviation " REAL "\n" " ngiven " NUMBER "\n nextra " NUMBER, t->ndim, t->ncomp, t->epsrel, t->epsabs, t->flags, t->seed, t->mineval, t->maxeval, t->key1, t->key2, t->key3, t->maxpass, t->border.lower, t->maxchisq, t->mindeviation, t->ngiven, t->nextra); Print(s); } if( BadComponent(t) ) return -2; if( BadDimension(t, t->key1) || BadDimension(t, t->key2) || ((t->key3 & -2) && BadDimension(t, t->key3)) ) return -1; t->neval_opt = t->neval_cut = 0; t->size = CHUNKSIZE; MemAlloc(t->voidregion, t->size*sizeof(Region)); for( dim = 0; dim < t->ndim; ++dim ) { Bounds *b = &RegionPtr(0)->bounds[dim]; b->lower = 0; b->upper = 1; } RuleIni(&t->rule7); RuleIni(&t->rule9); RuleIni(&t->rule11); RuleIni(&t->rule13); SamplesIni(&t->samples[0]); SamplesIni(&t->samples[1]); SamplesIni(&t->samples[2]); if( (fail = setjmp(t->abort)) ) goto abort; t->epsabs = Max(t->epsabs, NOTZERO); /* Step 1: partition the integration region */ if( VERBOSE ) Print("Partitioning phase:"); if( IsSobol(t->key1) || IsSobol(t->key2) || IsSobol(t->key3) ) IniRandom(t); SamplesLookup(t, &t->samples[0], t->key1, (number)47, (number)INT_MAX, (number)0); SamplesAlloc(t, &t->samples[0]); t->totals = totals; Zap(totals); t->phase = 1; Explore(t, 0, &t->samples[0], INIDEPTH, 1); for( iter = 1; ; ++iter ) { Totals *maxtot; count valid; for( comp = 0; comp < t->ncomp; ++comp ) { Totals *tot = &totals[comp]; tot->avg = tot->spreadsq = 0; tot->spread = tot->secondspread = -INFTY; } for( iregion = 0; iregion < t->nregions; ++iregion ) { Region *region = RegionPtr(iregion); for( comp = 0; comp < t->ncomp; ++comp ) { cResult *r = ®ion->result[comp]; Totals *tot = &totals[comp]; tot->avg += r->avg; tot->spreadsq += Sq(r->spread); if( r->spread > tot->spread ) { tot->secondspread = tot->spread; tot->spread = r->spread; tot->iregion = iregion; } else if( r->spread > tot->secondspread ) tot->secondspread = r->spread; } } maxtot = totals; valid = 0; for( comp = 0; comp < t->ncomp; ++comp ) { Totals *tot = &totals[comp]; integral[comp] = tot->avg; valid += tot->avg == tot->avg; if( tot->spreadsq > maxtot->spreadsq ) maxtot = tot; tot->spread = sqrt(tot->spreadsq); error[comp] = tot->spread*t->samples[0].weight; } if( VERBOSE ) { char s[128 + 64*NCOMP], *p = s; p += sprintf(p, "\n" "Iteration " COUNT " (pass " COUNT "): " COUNT " regions\n" NUMBER7 " integrand evaluations so far,\n" NUMBER7 " in optimizing regions,\n" NUMBER7 " in finding cuts", iter, pass, t->nregions, t->neval, t->neval_opt, t->neval_cut); for( comp = 0; comp < t->ncomp; ++comp ) p += sprintf(p, "\n[" COUNT "] " REAL " +- " REAL, comp + 1, integral[comp], error[comp]); Print(s); } if( valid == 0 ) goto abort; /* all NaNs */ if( t->neval > t->maxeval ) break; nneed = maxtot->spread/MaxErr(maxtot->avg); if( nneed < MAXPRIME ) { cnumber n = t->neval + t->nregions*(number)ceil(nneed); if( n < nmin ) { nmin = n; pass = 0; } else if( ++pass > t->maxpass && n >= t->mineval ) break; } Split(t, maxtot->iregion, DEPTH); } /* Step 2: do a "full" integration on each region */ /* nneed = t->samples[0].neff + 1; */ nneed = 2*t->samples[0].neff; for( comp = 0; comp < t->ncomp; ++comp ) { Totals *tot = &totals[comp]; creal maxerr = MaxErr(tot->avg); tot->nneed = tot->spread/maxerr; nneed = Max(nneed, tot->nneed); tot->maxerrsq = Sq(maxerr); tot->mindevsq = tot->maxerrsq*Sq(t->mindeviation); } nwant = (number)Min(ceil(nneed), MARKMASK/40.); err = SamplesLookup(t, &t->samples[1], t->key2, nwant, (t->maxeval - t->neval)/t->nregions + 1, t->samples[0].n + 1); /* the number of points needed to reach the desired accuracy */ fail = Unmark(err)*t->nregions; if( Marked(err) ) { if( VERBOSE ) Print("\nNot enough samples left for main integration."); for( comp = 0; comp < t->ncomp; ++comp ) prob[comp] = -999; weight = t->samples[0].weight; } else { bool can_adjust = (t->key3 == 1 && t->samples[1].sampler != SampleRule && (t->key2 < 0 || t->samples[1].neff < MAXPRIME)); count df, nlimit; SamplesAlloc(t, &t->samples[1]); if( VERBOSE ) { char s[128]; sprintf(s, "\nMain integration on " COUNT " regions with " NUMBER " samples per region.", t->nregions, t->samples[1].neff); Print(s); } ResClear(integral); ResClear(error); ResClear(prob); nlimit = t->maxeval - t->nregions*t->samples[1].n; df = 0; for( iregion = 0; iregion < t->nregions; ++iregion ) { Region *region = RegionPtr(iregion); char s[64*NDIM + 256*NCOMP], *p = s; int todo; refine: t->phase = 2; t->samples[1].sampler(t, &t->samples[1], region->bounds, region->vol); if( can_adjust ) for( comp = 0; comp < t->ncomp; ++comp ) totals[comp].spreadsq -= Sq(region->result[comp].spread); nlimit += t->samples[1].n; todo = 0; for( comp = 0; comp < t->ncomp; ++comp ) { cResult *r = ®ion->result[comp]; Totals *tot = &totals[comp]; t->samples[0].avg[comp] = r->avg; t->samples[0].err[comp] = r->err; if( t->neval < nlimit ) { creal avg2 = t->samples[1].avg[comp]; creal err2 = t->samples[1].err[comp]; creal diffsq = Sq(avg2 - r->avg); #define Var(s) Sq((s.err[comp] == 0) ? r->spread*s.weight : s.err[comp]) if( err2*tot->nneed > r->spread || diffsq > Max(t->maxchisq*(Var(t->samples[0]) + Var(t->samples[1])), EPS*Sq(avg2)) ) { if( t->key3 && diffsq > tot->mindevsq ) { if( t->key3 == 1 ) { ccount xregion = t->nregions; if( VERBOSE > 2 ) Print("\nSplit"); t->phase = 1; Explore(t, iregion, &t->samples[1], POSTDEPTH, 2); if( can_adjust ) { number nnew; count ireg, xreg; for( ireg = iregion, xreg = xregion; ireg < t->nregions; ireg = xreg++ ) { cResult *result = RegionPtr(ireg)->result; count c; for( c = 0; c < t->ncomp; ++c ) totals[c].spreadsq += Sq(result[c].spread); } nnew = (tot->spreadsq/Sq(MARKMASK) > tot->maxerrsq) ? MARKMASK : (number)ceil(sqrt(tot->spreadsq/tot->maxerrsq)); if( nnew > nwant + nwant/64 ) { ccount err = SamplesLookup(t, &t->samples[1], t->key2, nnew, (t->maxeval - t->neval)/t->nregions + 1, t->samples[1].n); fail += Unmark(err)*t->nregions; nwant = nnew; SamplesFree(&t->samples[1]); SamplesAlloc(t, &t->samples[1]); if( t->key2 > 0 && t->samples[1].neff >= MAXPRIME ) can_adjust = false; if( VERBOSE > 2 ) { char s[128]; sprintf(s, "Sampling remaining " COUNT " regions with " NUMBER " points per region.", t->nregions, t->samples[1].neff); Print(s); } } } goto refine; } todo |= 3; } todo |= 1; } } } if( can_adjust ) { for( comp = 0; comp < t->ncomp; ++comp ) totals[comp].maxerrsq -= Sq(region->result[comp].spread*t->samples[1].weight); } switch( todo ) { case 1: /* get spread right */ Explore(t, iregion, &t->samples[1], 0, 2); break; case 3: /* sample region again with more points */ if( SamplesIniQ(&t->samples[2]) ) { SamplesLookup(t, &t->samples[2], t->key3, nwant, (number)INT_MAX, (number)0); SamplesAlloc(t, &t->samples[2]); } t->phase = 3; t->samples[2].sampler(t, &t->samples[2], region->bounds, region->vol); Explore(t, iregion, &t->samples[2], 0, 2); ++region->depth; /* misused for df here */ ++df; } ++region->depth; /* misused for df here */ if( VERBOSE > 2 ) { for( dim = 0; dim < t->ndim; ++dim ) { cBounds *b = ®ion->bounds[dim]; p += sprintf(p, (dim == 0) ? "\nRegion (" REALF ") - (" REALF ")" : "\n (" REALF ") - (" REALF ")", b->lower, b->upper); } } for( comp = 0; comp < t->ncomp; ++comp ) { Result *r = ®ion->result[comp]; creal x1 = t->samples[0].avg[comp]; creal s1 = Var(t->samples[0]); creal x2 = t->samples[1].avg[comp]; creal s2 = Var(t->samples[1]); creal r2 = (s1 == 0) ? Sq(t->samples[1].neff*t->samples[0].weight) : s2/s1; real norm = 1 + r2; real avg = x2 + r2*x1; real sigsq = s2; real chisq = Sq(x2 - x1); real chiden = s1 + s2; if( todo == 3 ) { creal x3 = t->samples[2].avg[comp]; creal s3 = Var(t->samples[2]); creal r3 = (s2 == 0) ? Sq(t->samples[2].neff*t->samples[1].weight) : s3/s2; norm = 1 + r3*norm; avg = x3 + r3*avg; sigsq = s3; chisq = s1*Sq(x3 - x2) + s2*Sq(x3 - x1) + s3*chisq; chiden = s1*s2 + s3*chiden; } avg = LAST ? r->avg : (sigsq *= norm = 1/norm, avg*norm); if( chisq > EPS ) chisq /= Max(chiden, NOTZERO); #define Out(s) s.avg[comp], r->spread*s.weight, s.err[comp] if( VERBOSE > 2 ) { p += sprintf(p, "\n[" COUNT "] " REAL " +- " REAL "(" REAL ")\n " REAL " +- " REAL "(" REAL ")", comp + 1, Out(t->samples[0]), Out(t->samples[1])); if( todo == 3 ) p += sprintf(p, "\n " REAL " +- " REAL "(" REAL ")", Out(t->samples[2])); p += sprintf(p, " \tchisq " REAL, chisq); } integral[comp] += avg; error[comp] += sigsq; prob[comp] += chisq; r->avg = avg; r->spread = sqrt(sigsq); r->chisq = chisq; } if( VERBOSE > 2 ) Print(s); } for( comp = 0; comp < t->ncomp; ++comp ) error[comp] = sqrt(error[comp]); df += t->nregions; if( VERBOSE > 2 ) { char s[16 + 128*NCOMP], *p = s; p += sprintf(p, "\nTotals:"); for( comp = 0; comp < t->ncomp; ++comp ) p += sprintf(p, "\n[" COUNT "] " REAL " +- " REAL " \tchisq " REAL " (" COUNT " df)", comp + 1, integral[comp], error[comp], prob[comp], df); Print(s); } for( comp = 0; comp < t->ncomp; ++comp ) prob[comp] = ChiSquare(prob[comp], df); weight = 1; } #ifdef MLVERSION if( REGIONS ) { MLPutFunction(stdlink, "List", 2); MLPutFunction(stdlink, "List", t->nregions); for( iregion = 0; iregion < t->nregions; ++iregion ) { Region *region = RegionPtr(iregion); cBounds *b = region->bounds; real lower[NDIM], upper[NDIM]; for( dim = 0; dim < t->ndim; ++dim ) { lower[dim] = b[dim].lower; upper[dim] = b[dim].upper; } MLPutFunction(stdlink, "Cuba`Divonne`region", 4); MLPutRealList(stdlink, lower, t->ndim); MLPutRealList(stdlink, upper, t->ndim); MLPutFunction(stdlink, "List", t->ncomp); for( comp = 0; comp < t->ncomp; ++comp ) { cResult *r = ®ion->result[comp]; real res[] = {r->avg, r->spread*weight, r->chisq}; MLPutRealList(stdlink, res, Elements(res)); } MLPutInteger(stdlink, region->depth); /* misused for df */ } } #endif abort: SamplesFree(&t->samples[2]); SamplesFree(&t->samples[1]); SamplesFree(&t->samples[0]); RuleFree(&t->rule13); RuleFree(&t->rule11); RuleFree(&t->rule9); RuleFree(&t->rule7); free(t->voidregion); return fail; }
static int Integrate(creal epsrel, creal epsabs, cint flags, number mineval, cnumber maxeval, ccount key, real *integral, real *error, real *prob) { TYPEDEFREGION; count dim, comp; int fail = 1; Rule rule; Totals totals[NCOMP]; Region *anchor = NULL, *region = NULL; if( VERBOSE > 1 ) { char s[256]; sprintf(s, "Cuhre input parameters:\n" " ndim " COUNT "\n ncomp " COUNT "\n" " epsrel " REAL "\n epsabs " REAL "\n" " flags %d\n mineval " NUMBER "\n maxeval " NUMBER "\n" " key " COUNT, ndim_, ncomp_, epsrel, epsabs, flags, mineval, maxeval, key); Print(s); } #ifdef MLVERSION if( setjmp(abort_) ) goto abort; #endif if( key == 13 && ndim_ == 2 ) Rule13Alloc(&rule); else if( key == 11 && ndim_ == 3 ) Rule11Alloc(&rule); else if( key == 9 ) Rule9Alloc(&rule); else if( key == 7 ) Rule7Alloc(&rule); else { if( ndim_ == 2 ) Rule13Alloc(&rule); else if( ndim_ == 3 ) Rule11Alloc(&rule); else Rule9Alloc(&rule); } Alloc(rule.x, rule.n*(ndim_ + ncomp_)); rule.f = rule.x + rule.n*ndim_; mineval = IMax(mineval, rule.n + 1); Alloc(anchor, 1); anchor->next = NULL; anchor->div = 0; for( dim = 0; dim < ndim_; ++dim ) { Bounds *b = &anchor->bounds[dim]; b->lower = 0; b->upper = 1; } Sample(&rule, anchor, flags); for( comp = 0; comp < ncomp_; ++comp ) { Totals *tot = &totals[comp]; Result *r = &anchor->result[comp]; tot->avg = tot->lastavg = tot->guess = r->avg; tot->err = tot->lasterr = r->err; tot->weightsum = 1/Max(Sq(r->err), NOTZERO); tot->avgsum = tot->weightsum*r->avg; tot->chisq = tot->chisqsum = tot->chisum = 0; } for( nregions_ = 1; ; ++nregions_ ) { count maxcomp, bisectdim; real maxratio, maxerr; Region *regionL, *regionR, *reg, **parent, **par; Bounds *bL, *bR; if( VERBOSE ) { char s[128 + 128*NCOMP], *p = s; p += sprintf(p, "\n" "Iteration " COUNT ": " NUMBER " integrand evaluations so far", nregions_, neval_); for( comp = 0; comp < ncomp_; ++comp ) { cTotals *tot = &totals[comp]; p += sprintf(p, "\n[" COUNT "] " REAL " +- " REAL " \tchisq " REAL " (" COUNT " df)", comp + 1, tot->avg, tot->err, tot->chisq, nregions_ - 1); } Print(s); } maxratio = -INFTY; maxcomp = 0; for( comp = 0; comp < ncomp_; ++comp ) { creal ratio = totals[comp].err/MaxErr(totals[comp].avg); if( ratio > maxratio ) { maxratio = ratio; maxcomp = comp; } } if( maxratio <= 1 && neval_ >= mineval ) { fail = 0; break; } if( neval_ >= maxeval ) break; maxerr = -INFTY; parent = &anchor; region = anchor; for( par = &anchor; (reg = *par); par = ®->next ) { creal err = reg->result[maxcomp].err; if( err > maxerr ) { maxerr = err; parent = par; region = reg; } } Alloc(regionL, 1); Alloc(regionR, 1); *parent = regionL; regionL->next = regionR; regionR->next = region->next; regionL->div = regionR->div = region->div + 1; VecCopy(regionL->bounds, region->bounds); VecCopy(regionR->bounds, region->bounds); bisectdim = region->result[maxcomp].bisectdim; bL = ®ionL->bounds[bisectdim]; bR = ®ionR->bounds[bisectdim]; bL->upper = bR->lower = .5*(bL->upper + bL->lower); Sample(&rule, regionL, flags); Sample(&rule, regionR, flags); for( comp = 0; comp < ncomp_; ++comp ) { cResult *r = ®ion->result[comp]; Result *rL = ®ionL->result[comp]; Result *rR = ®ionR->result[comp]; Totals *tot = &totals[comp]; real diff, err, w, avg, sigsq; tot->lastavg += diff = rL->avg + rR->avg - r->avg; diff = fabs(.25*diff); err = rL->err + rR->err; if( err > 0 ) { creal c = 1 + 2*diff/err; rL->err *= c; rR->err *= c; } rL->err += diff; rR->err += diff; tot->lasterr += rL->err + rR->err - r->err; tot->weightsum += w = 1/Max(Sq(tot->lasterr), NOTZERO); sigsq = 1/tot->weightsum; tot->avgsum += w*tot->lastavg; avg = sigsq*tot->avgsum; tot->chisum += w *= tot->lastavg - tot->guess; tot->chisqsum += w*tot->lastavg; tot->chisq = tot->chisqsum - avg*tot->chisum; if( LAST ) { tot->avg = tot->lastavg; tot->err = tot->lasterr; } else { tot->avg = avg; tot->err = sqrt(sigsq); } } free(region); region = NULL; } for( comp = 0; comp < ncomp_; ++comp ) { cTotals *tot = &totals[comp]; integral[comp] = tot->avg; error[comp] = tot->err; prob[comp] = ChiSquare(tot->chisq, nregions_ - 1); } #ifdef MLVERSION if( REGIONS ) { MLPutFunction(stdlink, "List", 2); MLPutFunction(stdlink, "List", nregions_); for( region = anchor; region; region = region->next ) { real lower[NDIM], upper[NDIM]; for( dim = 0; dim < ndim_; ++dim ) { cBounds *b = ®ion->bounds[dim]; lower[dim] = b->lower; upper[dim] = b->upper; } MLPutFunction(stdlink, "Cuba`Cuhre`region", 3); MLPutRealList(stdlink, lower, ndim_); MLPutRealList(stdlink, upper, ndim_); MLPutFunction(stdlink, "List", ncomp_); for( comp = 0; comp < ncomp_; ++comp ) { cResult *r = ®ion->result[comp]; real res[] = {r->avg, r->err}; MLPutRealList(stdlink, res, Elements(res)); } } } #endif #ifdef MLVERSION abort: #endif if( region ) free(region); while( (region = anchor) ) { anchor = anchor->next; free(region); } free(rule.x); RuleFree(&rule); return fail; }
double *InfoBitRanker::getTopN(unsigned int num) { // this is a place holder to pass along to infogain function // the size of this container should nVals*d_classes, where nVals // is the number of values a variable can take. // since we are dealing with a binary bit vector nVals = 2 // in addition the infogain function pretends that this is a 2D matrix // with the number of rows equal to nVals and num of columns equal to // d_classes if(num>d_dims) throw ValueErrorException("attempt to rank more bits than present in the bit vectors"); if(dp_maskBits) CHECK_INVARIANT(num <= dp_maskBits->getNumOnBits(), "Can't rank more bits than the ensemble size"); RDKit::USHORT *resMat = new RDKit::USHORT[2*d_classes]; PR_QUEUE topN; for (unsigned int i = 0; i < d_dims; i++) { // we may want to ignore bits that are not turned on in any item of class // "ignoreNoClass" /* if ((0 <= ignoreNoClass) && (d_classes > ignoreNoClass)) { if (d_counts[ignoreNoClass][i] == 0) { continue; } }*/ if (dp_maskBits && !dp_maskBits->getBit(i)) { continue; } // fill up dmat for (unsigned int j = 0; j < d_classes; j++) { // we know that we have only two rows here resMat[j] = d_counts[j][i]; resMat[d_classes + j] = (d_clsCount[j] - d_counts[j][i]); } double info = 0.0; switch (d_type) { case ENTROPY: info = InfoEntropyGain(resMat, 2, d_classes); break; case BIASENTROPY: info = this->BiasInfoEntropyGain(resMat); break; case CHISQUARE: info = ChiSquare(resMat, 2, d_classes); break; case BIASCHISQUARE: info = BiasChiSquareGain(resMat); break; default: break; } PAIR_D_I entry(info, i); if (info >= 0.0) { if (topN.size() < num) { topN.push(entry); } else if (info > topN.top().first) { topN.pop(); topN.push(entry); } } } delete [] resMat; // now fill up the result matrix for the topN bits // the result from this function is a double * of size // num*4. The caller of this function interprets this // array as a two dimensional array of size num*(2+d_classes) with each row // containing the following entries // bitId, infogain, 1 additional column for number of hits for each class //double *res = new double[num*(2+d_classes)]; d_top = num; int ncols = 2+d_classes; delete [] dp_topBits; dp_topBits = new double[num*ncols]; int offset, bid; RDKit::INT_VECT maskBits; if (dp_maskBits && topN.size() < num) { dp_maskBits->getOnBits(maskBits); } for (int i = num - 1; i >= 0; i--) { offset = i*ncols; if (topN.size() == 0 ) { if (dp_maskBits) { bid = maskBits[i]; } else { bid = i; } dp_topBits[offset + 1] = 0.0; } else { bid = topN.top().second; // bit id dp_topBits[offset + 1] = topN.top().first; // value of the infogain topN.pop(); } dp_topBits[offset] = (double)bid; for (unsigned int j = 0; j < d_classes; j++) { dp_topBits[offset + 2 + j] = (double)d_counts[j][bid]; } } return dp_topBits; }
static int Integrate(creal epsrel, creal epsabs, cint flags, cnumber mineval, cnumber maxeval, int key1, int key2, int key3, ccount maxpass, creal maxchisq, creal mindeviation, real *integral, real *error, real *prob) { TYPEDEFREGION; Region anchor, *region; Totals totals[NCOMP]; real nneed, weight; count dim, comp, iter, nregions, pass = 0, err; number nwant, nmin = INT_MAX; int fail = -1; if( VERBOSE > 1 ) { char s[512]; sprintf(s, "Divonne input parameters:\n" " ndim " COUNT "\n ncomp " COUNT "\n" " epsrel " REAL "\n epsabs " REAL "\n" " flags %d\n mineval " NUMBER "\n maxeval " NUMBER "\n" " key1 %d\n key2 %d\n key3 %d\n maxpass " COUNT "\n" " border " REAL "\n maxchisq " REAL "\n mindeviation " REAL "\n" " ngiven " NUMBER "\n nextra " NUMBER "\n", ndim_, ncomp_, epsrel, epsabs, flags, mineval, maxeval, key1, key2, key3, maxpass, border_.lower, maxchisq, mindeviation, ngiven_, nextra_); Print(s); } anchor.next = NULL; for( dim = 0; dim < ndim_; ++dim ) { Bounds *b = &anchor.bounds[dim]; b->lower = 0; b->upper = 1; } RuleIni(&rule7_); RuleIni(&rule9_); RuleIni(&rule11_); RuleIni(&rule13_); SamplesIni(&samples_[0]); SamplesIni(&samples_[1]); SamplesIni(&samples_[2]); #ifdef MLVERSION if( setjmp(abort_) ) goto abort; #endif /* Step 1: partition the integration region */ if( VERBOSE ) Print("Partitioning phase:"); if( IsSobol(key1) || IsSobol(key2) || IsSobol(key3) ) IniRandom(2*maxeval, flags); SamplesLookup(&samples_[0], key1, (number)47, (number)INT_MAX, (number)0); SamplesAlloc(&samples_[0]); totals_ = totals; Zap(totals); phase_ = 1; Explore(&anchor, &samples_[0], INIDEPTH, 1); for( iter = 1; ; ++iter ) { Totals *maxtot; for( comp = 0; comp < ncomp_; ++comp ) { Totals *tot = &totals[comp]; tot->avg = tot->spreadsq = 0; tot->spread = tot->secondspread = -INFTY; } nregions = 0; for( region = anchor.next; region; region = region->next ) { ++nregions; for( comp = 0; comp < ncomp_; ++comp ) { cResult *r = ®ion->result[comp]; Totals *tot = &totals[comp]; tot->avg += r->avg; tot->spreadsq += Sq(r->spread); if( r->spread > tot->spread ) { tot->secondspread = tot->spread; tot->spread = r->spread; tot->region = region; } else if( r->spread > tot->secondspread ) tot->secondspread = r->spread; } } maxtot = totals; for( comp = 0; comp < ncomp_; ++comp ) { Totals *tot = &totals[comp]; integral[comp] = tot->avg; if( tot->spreadsq > maxtot->spreadsq ) maxtot = tot; tot->spread = sqrt(tot->spreadsq); error[comp] = tot->spread*samples_[0].weight; } if( VERBOSE ) { char s[128 + 64*NCOMP], *p = s; p += sprintf(p, "\n" "Iteration " COUNT " (pass " COUNT "): " COUNT " regions\n" NUMBER7 " integrand evaluations so far,\n" NUMBER7 " in optimizing regions,\n" NUMBER7 " in finding cuts", iter, pass, nregions, neval_, neval_opt_, neval_cut_); for( comp = 0; comp < ncomp_; ++comp ) p += sprintf(p, "\n[" COUNT "] " REAL " +- " REAL, comp + 1, integral[comp], error[comp]); Print(s); } if( neval_ > maxeval ) break; nneed = maxtot->spread/MaxErr(maxtot->avg); if( nneed < MAXPRIME ) { cnumber n = neval_ + nregions*(number)ceil(nneed); if( n < nmin ) { nmin = n; pass = 0; } else if( ++pass > maxpass && n >= mineval ) break; } Split(maxtot->region, DEPTH); } /* Step 2: do a "full" integration on each region */ /* nneed = samples_[0].neff + 1; */ nneed = 2*samples_[0].neff; for( comp = 0; comp < ncomp_; ++comp ) { Totals *tot = &totals[comp]; creal maxerr = MaxErr(tot->avg); tot->nneed = tot->spread/maxerr; nneed = Max(nneed, tot->nneed); tot->maxerrsq = Sq(maxerr); tot->mindevsq = tot->maxerrsq*Sq(mindeviation); } nwant = (number)Min(ceil(nneed), MARKMASK/40.); err = SamplesLookup(&samples_[1], key2, nwant, (maxeval - neval_)/nregions + 1, samples_[0].n + 1); /* the number of points needed to reach the desired accuracy */ fail = Unmark(err)*nregions; if( Marked(err) ) { if( VERBOSE ) Print("\nNot enough samples left for main integration."); for( comp = 0; comp < ncomp_; ++comp ) prob[comp] = -999; weight = samples_[0].weight; nregions_ = nregions; } else { bool can_adjust = (key3 == 1 && samples_[1].sampler != SampleRule && (key2 < 0 || samples_[1].neff < MAXPRIME)); count df, nlimit; SamplesAlloc(&samples_[1]); if( VERBOSE ) { char s[128]; sprintf(s, "\nMain integration on " COUNT " regions with " NUMBER " samples per region.", nregions, samples_[1].neff); Print(s); } ResClear(integral); ResClear(error); ResClear(prob); nlimit = maxeval - nregions*samples_[1].n; df = nregions_ = 0; for( region = anchor.next; region; region = region->next ) { char s[64*NDIM + 256*NCOMP], *p = s; int todo; refine: phase_ = 2; samples_[1].sampler(&samples_[1], region->bounds, region->vol); if( can_adjust ) { --nregions; for( comp = 0; comp < ncomp_; ++comp ) totals[comp].spreadsq -= Sq(region->result[comp].spread); } nlimit += samples_[1].n; todo = 0; for( comp = 0; comp < ncomp_; ++comp ) { cResult *r = ®ion->result[comp]; Totals *tot = &totals[comp]; samples_[0].avg[comp] = r->avg; samples_[0].err[comp] = r->err; if( neval_ < nlimit ) { creal avg2 = samples_[1].avg[comp]; creal err2 = samples_[1].err[comp]; creal diffsq = Sq(avg2 - r->avg); #define Var(s) Sq((s.err[comp] == 0) ? r->spread*s.weight : s.err[comp]) if( err2*tot->nneed > r->spread || diffsq > Max(maxchisq*(Var(samples_[0]) + Var(samples_[1])), EPS*Sq(avg2)) ) { if( key3 && diffsq > tot->mindevsq ) { if( key3 == 1 ) { const Region *next = region->next; if( VERBOSE > 2 ) Print("\nSplit"); phase_ = 1; Explore(region, &samples_[1], POSTDEPTH, 2); if( can_adjust ) { number nnew; Region *child; for( child = region; child != next; child = child->next ) { count c; for( c = 0; c < ncomp_; ++c ) totals[c].spreadsq += Sq(child->result[c].spread); ++nregions; } nnew = (tot->spreadsq/Sq(MARKMASK) > tot->maxerrsq) ? MARKMASK : (number)ceil(sqrt(tot->spreadsq/tot->maxerrsq)); if( nnew > nwant + nwant/64 ) { ccount err = SamplesLookup(&samples_[1], key2, nnew, (maxeval - neval_)/nregions + 1, samples_[1].n); fail += Unmark(err)*nregions; nwant = nnew; SamplesFree(&samples_[1]); SamplesAlloc(&samples_[1]); if( key2 > 0 && samples_[1].neff >= MAXPRIME ) can_adjust = false; if( VERBOSE > 2 ) { char s[128]; sprintf(s, "Sampling remaining " COUNT " regions with " NUMBER " points per region.", nregions, samples_[1].neff); Print(s); } } } goto refine; } todo |= 3; } todo |= 1; } } } if( can_adjust ) { for( comp = 0; comp < ncomp_; ++comp ) totals[comp].maxerrsq -= Sq(region->result[comp].spread*samples_[1].weight); } switch( todo ) { case 1: /* get spread right */ Explore(region, &samples_[1], 0, 2); break; case 3: /* sample region again with more points */ if( MEM(&samples_[2]) == NULL ) { SamplesLookup(&samples_[2], key3, nwant, (number)INT_MAX, (number)0); SamplesAlloc(&samples_[2]); } phase_ = 3; samples_[2].sampler(&samples_[2], region->bounds, region->vol); Explore(region, &samples_[2], 0, 2); ++region->depth; /* misused for df here */ ++df; } ++region->depth; /* misused for df here */ ++nregions_; if( VERBOSE > 2 ) { for( dim = 0; dim < ndim_; ++dim ) { cBounds *b = ®ion->bounds[dim]; p += sprintf(p, (dim == 0) ? "\nRegion (" REALF ") - (" REALF ")" : "\n (" REALF ") - (" REALF ")", b->lower, b->upper); } } for( comp = 0; comp < ncomp_; ++comp ) { Result *r = ®ion->result[comp]; creal x1 = samples_[0].avg[comp]; creal s1 = Var(samples_[0]); creal x2 = samples_[1].avg[comp]; creal s2 = Var(samples_[1]); creal r2 = (s1 == 0) ? Sq(samples_[1].neff*samples_[0].weight) : s2/s1; real norm = 1 + r2; real avg = x2 + r2*x1; real sigsq = s2; real chisq = Sq(x2 - x1); real chiden = s1 + s2; if( todo == 3 ) { creal x3 = samples_[2].avg[comp]; creal s3 = Var(samples_[2]); creal r3 = (s2 == 0) ? Sq(samples_[2].neff*samples_[1].weight) : s3/s2; norm = 1 + r3*norm; avg = x3 + r3*avg; sigsq = s3; chisq = s1*Sq(x3 - x2) + s2*Sq(x3 - x1) + s3*chisq; chiden = s1*s2 + s3*chiden; } avg = LAST ? r->avg : (sigsq *= norm = 1/norm, avg*norm); if( chisq > EPS ) chisq /= Max(chiden, NOTZERO); #define Out(s) s.avg[comp], r->spread*s.weight, s.err[comp] if( VERBOSE > 2 ) { p += sprintf(p, "\n[" COUNT "] " REAL " +- " REAL "(" REAL ")\n " REAL " +- " REAL "(" REAL ")", comp + 1, Out(samples_[0]), Out(samples_[1])); if( todo == 3 ) p += sprintf(p, "\n " REAL " +- " REAL "(" REAL ")", Out(samples_[2])); p += sprintf(p, " \tchisq " REAL, chisq); } integral[comp] += avg; error[comp] += sigsq; prob[comp] += chisq; r->avg = avg; r->spread = sqrt(sigsq); r->chisq = chisq; } if( VERBOSE > 2 ) Print(s); } for( comp = 0; comp < ncomp_; ++comp ) error[comp] = sqrt(error[comp]); df += nregions_; if( VERBOSE > 2 ) { char s[16 + 128*NCOMP], *p = s; p += sprintf(p, "\nTotals:"); for( comp = 0; comp < ncomp_; ++comp ) p += sprintf(p, "\n[" COUNT "] " REAL " +- " REAL " \tchisq " REAL " (" COUNT " df)", comp + 1, integral[comp], error[comp], prob[comp], df); Print(s); } for( comp = 0; comp < ncomp_; ++comp ) prob[comp] = ChiSquare(prob[comp], df); weight = 1; } #ifdef MLVERSION if( REGIONS ) { MLPutFunction(stdlink, "List", 2); MLPutFunction(stdlink, "List", nregions_); for( region = anchor.next; region; region = region->next ) { cBounds *b = region->bounds; real lower[NDIM], upper[NDIM]; for( dim = 0; dim < ndim_; ++dim ) { lower[dim] = b[dim].lower; upper[dim] = b[dim].upper; } MLPutFunction(stdlink, "Cuba`Divonne`region", 4); MLPutRealList(stdlink, lower, ndim_); MLPutRealList(stdlink, upper, ndim_); MLPutFunction(stdlink, "List", ncomp_); for( comp = 0; comp < ncomp_; ++comp ) { cResult *r = ®ion->result[comp]; real res[] = {r->avg, r->spread*weight, r->chisq}; MLPutRealList(stdlink, res, Elements(res)); } MLPutInteger(stdlink, region->depth); /* misused for df */ } } #endif #ifdef MLVERSION abort: #endif SamplesFree(&samples_[2]); SamplesFree(&samples_[1]); SamplesFree(&samples_[0]); RuleFree(&rule13_); RuleFree(&rule11_); RuleFree(&rule9_); RuleFree(&rule7_); for( region = anchor.next; region; ) { Region *next = region->next; free(region); region = next; } return fail; }